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

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

L
Linus Torvalds 已提交
67
#include <linux/mm.h>
68
#include <linux/slab.h>
L
Linus Torvalds 已提交
69 70
#include <linux/module.h>
#include <linux/sysctl.h>
71
#include <linux/kernel.h>
72
#include <linux/prefetch.h>
73
#include <net/dst.h>
L
Linus Torvalds 已提交
74 75 76 77
#include <net/tcp.h>
#include <net/inet_common.h>
#include <linux/ipsec.h>
#include <asm/unaligned.h>
78
#include <linux/errqueue.h>
79
#include <trace/events/tcp.h>
80
#include <linux/static_key.h>
L
Linus Torvalds 已提交
81

82
int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
L
Linus Torvalds 已提交
83 84 85 86 87 88 89 90

#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				*/
91
#define FLAG_LOST_RETRANS	0x80 /* This ACK marks some retransmission lost */
92
#define FLAG_SLOWPATH		0x100 /* Do not skip RFC checks for window update.*/
Y
Yuchung Cheng 已提交
93
#define FLAG_ORIG_SACK_ACKED	0x200 /* Never retransmitted data are (s)acked	*/
94
#define FLAG_SND_UNA_ADVANCED	0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
95
#define FLAG_DSACKING_ACK	0x800 /* SACK blocks contained D-SACK info */
96
#define FLAG_SET_XMIT_TIMER	0x1000 /* Set TLP or RTO timer */
97
#define FLAG_SACK_RENEGING	0x2000 /* snd_una advanced to a sacked seq */
98
#define FLAG_UPDATE_TS_RECENT	0x4000 /* tcp_replace_ts_recent() */
99
#define FLAG_NO_CHALLENGE_ACK	0x8000 /* do not call tcp_send_challenge_ack()	*/
100
#define FLAG_ACK_MAYBE_DELAYED	0x10000 /* Likely a delayed ACK */
L
Linus Torvalds 已提交
101 102 103

#define FLAG_ACKED		(FLAG_DATA_ACKED|FLAG_SYN_ACKED)
#define FLAG_NOT_DUP		(FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED)
104
#define FLAG_CA_ALERT		(FLAG_DATA_SACKED|FLAG_ECE|FLAG_DSACKING_ACK)
L
Linus Torvalds 已提交
105 106 107
#define FLAG_FORWARD_PROGRESS	(FLAG_ACKED|FLAG_DATA_SACKED)

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

110 111 112 113
#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 */

I
Ilya Lesokhin 已提交
114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132
#if IS_ENABLED(CONFIG_TLS_DEVICE)
static DEFINE_STATIC_KEY_FALSE(clean_acked_data_enabled);

void clean_acked_data_enable(struct inet_connection_sock *icsk,
			     void (*cad)(struct sock *sk, u32 ack_seq))
{
	icsk->icsk_clean_acked = cad;
	static_branch_inc(&clean_acked_data_enabled);
}
EXPORT_SYMBOL_GPL(clean_acked_data_enable);

void clean_acked_data_disable(struct inet_connection_sock *icsk)
{
	static_branch_dec(&clean_acked_data_enabled);
	icsk->icsk_clean_acked = NULL;
}
EXPORT_SYMBOL_GPL(clean_acked_data_disable);
#endif

133 134
static void tcp_gro_dev_warn(struct sock *sk, const struct sk_buff *skb,
			     unsigned int len)
135 136 137 138 139 140 141 142 143 144
{
	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);
145 146 147
		if (!dev || len >= dev->mtu)
			pr_warn("%s: Driver has suspect GRO implementation, TCP performance may be compromised.\n",
				dev ? dev->name : "Unknown driver");
148 149 150 151
		rcu_read_unlock();
	}
}

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

161
	icsk->icsk_ack.last_seg_size = 0;
L
Linus Torvalds 已提交
162 163 164 165

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

206
static void tcp_incr_quickack(struct sock *sk)
L
Linus Torvalds 已提交
207
{
208
	struct inet_connection_sock *icsk = inet_csk(sk);
209
	unsigned int quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
L
Linus Torvalds 已提交
210

211 212
	if (quickacks == 0)
		quickacks = 2;
213 214
	if (quickacks > icsk->icsk_ack.quick)
		icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS);
L
Linus Torvalds 已提交
215 216
}

217
static void tcp_enter_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
218
{
219 220 221 222
	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 已提交
223 224 225 226 227 228
}

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

229
static bool tcp_in_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
230
{
231
	const struct inet_connection_sock *icsk = inet_csk(sk);
232
	const struct dst_entry *dst = __sk_dst_get(sk);
E
Eric Dumazet 已提交
233

234 235
	return (dst && dst_metric(dst, RTAX_QUICKACK)) ||
		(icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong);
L
Linus Torvalds 已提交
236 237
}

238
static void tcp_ecn_queue_cwr(struct tcp_sock *tp)
239
{
240
	if (tp->ecn_flags & TCP_ECN_OK)
241 242 243
		tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}

244
static void tcp_ecn_accept_cwr(struct tcp_sock *tp, const struct sk_buff *skb)
245 246 247 248 249
{
	if (tcp_hdr(skb)->cwr)
		tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

250
static void tcp_ecn_withdraw_cwr(struct tcp_sock *tp)
251 252 253 254
{
	tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

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

270 271 272 273 274
		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;
		}
275 276
		tp->ecn_flags |= TCP_ECN_SEEN;
		break;
277
	default:
278 279
		if (tcp_ca_needs_ecn((struct sock *)tp))
			tcp_ca_event((struct sock *)tp, CA_EVENT_ECN_NO_CE);
280
		tp->ecn_flags |= TCP_ECN_SEEN;
281
		break;
282 283 284
	}
}

285 286 287 288 289 290 291
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)
292
{
293
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || th->cwr))
294 295 296
		tp->ecn_flags &= ~TCP_ECN_OK;
}

297
static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
298
{
299
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
300 301 302
		tp->ecn_flags &= ~TCP_ECN_OK;
}

303
static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
304
{
305
	if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
E
Eric Dumazet 已提交
306 307
		return true;
	return false;
308 309
}

L
Linus Torvalds 已提交
310 311 312 313 314
/* Buffer size and advertised window tuning.
 *
 * 1. Tuning sk->sk_sndbuf, when connection enters established state.
 */

E
Eric Dumazet 已提交
315
static void tcp_sndbuf_expand(struct sock *sk)
L
Linus Torvalds 已提交
316
{
E
Eric Dumazet 已提交
317
	const struct tcp_sock *tp = tcp_sk(sk);
318
	const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
E
Eric Dumazet 已提交
319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336
	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
337
	 * extra cushion (application might react slowly to EPOLLOUT)
E
Eric Dumazet 已提交
338
	 */
339 340
	sndmem = ca_ops->sndbuf_expand ? ca_ops->sndbuf_expand(sk) : 2;
	sndmem *= nr_segs * per_mss;
L
Linus Torvalds 已提交
341

342
	if (sk->sk_sndbuf < sndmem)
343
		sk->sk_sndbuf = min(sndmem, sock_net(sk)->ipv4.sysctl_tcp_wmem[2]);
L
Linus Torvalds 已提交
344 345 346 347 348 349 350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366
}

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

/* Slow part of check#2. */
372
static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
373
{
374
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
375
	/* Optimize this! */
376
	int truesize = tcp_win_from_space(sk, skb->truesize) >> 1;
377
	int window = tcp_win_from_space(sk, sock_net(sk)->ipv4.sysctl_tcp_rmem[2]) >> 1;
L
Linus Torvalds 已提交
378 379 380

	while (tp->rcv_ssthresh <= window) {
		if (truesize <= skb->len)
381
			return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
L
Linus Torvalds 已提交
382 383 384 385 386 387 388

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

389
static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
390
{
391 392
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
393 394 395
	/* Check #1 */
	if (tp->rcv_ssthresh < tp->window_clamp &&
	    (int)tp->rcv_ssthresh < tcp_space(sk) &&
396
	    !tcp_under_memory_pressure(sk)) {
L
Linus Torvalds 已提交
397 398 399 400 401
		int incr;

		/* Check #2. Increase window, if skb with such overhead
		 * will fit to rcvbuf in future.
		 */
402
		if (tcp_win_from_space(sk, skb->truesize) <= skb->len)
403
			incr = 2 * tp->advmss;
L
Linus Torvalds 已提交
404
		else
405
			incr = __tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
406 407

		if (incr) {
408
			incr = max_t(int, incr, 2 * skb->len);
409 410
			tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr,
					       tp->window_clamp);
411
			inet_csk(sk)->icsk_ack.quick |= 1;
L
Linus Torvalds 已提交
412 413 414 415 416 417 418
		}
	}
}

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

422 423
	rcvmem = 2 * SKB_TRUESIZE(mss + MAX_TCP_HEADER) *
		 tcp_default_init_rwnd(mss);
424

E
Eric Dumazet 已提交
425 426 427
	/* Dynamic Right Sizing (DRS) has 2 to 3 RTT latency
	 * Allow enough cushion so that sender is not limited by our window
	 */
428
	if (sock_net(sk)->ipv4.sysctl_tcp_moderate_rcvbuf)
E
Eric Dumazet 已提交
429 430
		rcvmem <<= 2;

431
	if (sk->sk_rcvbuf < rcvmem)
432
		sk->sk_rcvbuf = min(rcvmem, sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
433 434
}

S
Stephen Hemminger 已提交
435
/* 4. Try to fixup all. It is made immediately after connection enters
L
Linus Torvalds 已提交
436 437
 *    established state.
 */
438
void tcp_init_buffer_space(struct sock *sk)
L
Linus Torvalds 已提交
439
{
440
	int tcp_app_win = sock_net(sk)->ipv4.sysctl_tcp_app_win;
L
Linus Torvalds 已提交
441 442 443 444 445 446
	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 已提交
447
		tcp_sndbuf_expand(sk);
L
Linus Torvalds 已提交
448 449

	tp->rcvq_space.space = tp->rcv_wnd;
450
	tcp_mstamp_refresh(tp);
451
	tp->rcvq_space.time = tp->tcp_mstamp;
E
Eric Dumazet 已提交
452
	tp->rcvq_space.seq = tp->copied_seq;
L
Linus Torvalds 已提交
453 454 455 456 457 458

	maxwin = tcp_full_space(sk);

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

459
		if (tcp_app_win && maxwin > 4 * tp->advmss)
L
Linus Torvalds 已提交
460
			tp->window_clamp = max(maxwin -
461
					       (maxwin >> tcp_app_win),
L
Linus Torvalds 已提交
462 463 464 465
					       4 * tp->advmss);
	}

	/* Force reservation of one segment. */
466
	if (tcp_app_win &&
L
Linus Torvalds 已提交
467 468 469 470 471
	    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);
472
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
473 474 475
}

/* 5. Recalculate window clamp after socket hit its memory bounds. */
476
static void tcp_clamp_window(struct sock *sk)
L
Linus Torvalds 已提交
477
{
478
	struct tcp_sock *tp = tcp_sk(sk);
479
	struct inet_connection_sock *icsk = inet_csk(sk);
480
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
481

482
	icsk->icsk_ack.quick = 0;
L
Linus Torvalds 已提交
483

484
	if (sk->sk_rcvbuf < net->ipv4.sysctl_tcp_rmem[2] &&
485
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
486
	    !tcp_under_memory_pressure(sk) &&
487
	    sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)) {
488
		sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
489
				    net->ipv4.sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
490
	}
491
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf)
492
		tp->rcv_ssthresh = min(tp->window_clamp, 2U * tp->advmss);
L
Linus Torvalds 已提交
493 494
}

S
Stephen Hemminger 已提交
495 496 497 498 499 500 501 502 503
/* 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)
{
504
	const struct tcp_sock *tp = tcp_sk(sk);
S
Stephen Hemminger 已提交
505 506
	unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);

507
	hint = min(hint, tp->rcv_wnd / 2);
508
	hint = min(hint, TCP_MSS_DEFAULT);
S
Stephen Hemminger 已提交
509 510 511 512
	hint = max(hint, TCP_MIN_MSS);

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

L
Linus Torvalds 已提交
515 516 517 518
/* 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.
519
 * <http://public.lanl.gov/radiant/pubs.html#DRS>
L
Linus Torvalds 已提交
520 521
 *
 * More detail on this code can be found at
522
 * <http://staff.psc.edu/jheffner/>,
L
Linus Torvalds 已提交
523 524 525 526 527
 * 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)
{
528
	u32 new_sample = tp->rcv_rtt_est.rtt_us;
L
Linus Torvalds 已提交
529 530 531 532 533 534 535 536 537
	long m = sample;

	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 已提交
538
		 * non-timestamp case, we do not smooth things out
S
Stephen Hemminger 已提交
539
		 * else with timestamps disabled convergence takes too
L
Linus Torvalds 已提交
540 541 542 543 544
		 * long.
		 */
		if (!win_dep) {
			m -= (new_sample >> 3);
			new_sample += m;
545 546 547 548 549
		} else {
			m <<= 3;
			if (m < new_sample)
				new_sample = m;
		}
L
Linus Torvalds 已提交
550
	} else {
S
Stephen Hemminger 已提交
551
		/* No previous measure. */
L
Linus Torvalds 已提交
552 553 554
		new_sample = m << 3;
	}

555
	tp->rcv_rtt_est.rtt_us = new_sample;
L
Linus Torvalds 已提交
556 557 558 559
}

static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
{
560 561
	u32 delta_us;

562
	if (tp->rcv_rtt_est.time == 0)
L
Linus Torvalds 已提交
563 564 565
		goto new_measure;
	if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
		return;
566
	delta_us = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcv_rtt_est.time);
567 568
	if (!delta_us)
		delta_us = 1;
569
	tcp_rcv_rtt_update(tp, delta_us, 1);
L
Linus Torvalds 已提交
570 571 572

new_measure:
	tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
573
	tp->rcv_rtt_est.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
574 575
}

576 577
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
578
{
579
	struct tcp_sock *tp = tcp_sk(sk);
580

L
Linus Torvalds 已提交
581 582
	if (tp->rx_opt.rcv_tsecr &&
	    (TCP_SKB_CB(skb)->end_seq -
583 584
	     TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss)) {
		u32 delta = tcp_time_stamp(tp) - tp->rx_opt.rcv_tsecr;
585
		u32 delta_us;
586

587 588 589
		if (!delta)
			delta = 1;
		delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ);
590 591
		tcp_rcv_rtt_update(tp, delta_us, 0);
	}
L
Linus Torvalds 已提交
592 593 594 595 596 597 598 599 600
}

/*
 * 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);
601
	u32 copied;
L
Linus Torvalds 已提交
602
	int time;
603

604 605
	trace_tcp_rcv_space_adjust(sk);

606
	tcp_mstamp_refresh(tp);
607
	time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time);
608
	if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0)
L
Linus Torvalds 已提交
609
		return;
610

E
Eric Dumazet 已提交
611 612 613 614 615 616 617 618 619 620 621 622 623 624
	/* 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 .... >
	 */

625
	if (sock_net(sk)->ipv4.sysctl_tcp_moderate_rcvbuf &&
E
Eric Dumazet 已提交
626
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
627
		int rcvmem, rcvbuf;
E
Eric Dumazet 已提交
628
		u64 rcvwin, grow;
L
Linus Torvalds 已提交
629

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

E
Eric Dumazet 已提交
635 636 637 638
		/* Accommodate for sender rate increase (eg. slow start) */
		grow = rcvwin * (copied - tp->rcvq_space.space);
		do_div(grow, tp->rcvq_space.space);
		rcvwin += (grow << 1);
L
Linus Torvalds 已提交
639

E
Eric Dumazet 已提交
640
		rcvmem = SKB_TRUESIZE(tp->advmss + MAX_TCP_HEADER);
641
		while (tcp_win_from_space(sk, rcvmem) < tp->advmss)
E
Eric Dumazet 已提交
642
			rcvmem += 128;
L
Linus Torvalds 已提交
643

644 645 646
		do_div(rcvwin, tp->advmss);
		rcvbuf = min_t(u64, rcvwin * rcvmem,
			       sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
E
Eric Dumazet 已提交
647 648
		if (rcvbuf > sk->sk_rcvbuf) {
			sk->sk_rcvbuf = rcvbuf;
L
Linus Torvalds 已提交
649

E
Eric Dumazet 已提交
650
			/* Make the window clamp follow along.  */
651
			tp->window_clamp = tcp_win_from_space(sk, rcvbuf);
L
Linus Torvalds 已提交
652 653
		}
	}
E
Eric Dumazet 已提交
654
	tp->rcvq_space.space = copied;
655

L
Linus Torvalds 已提交
656 657
new_measure:
	tp->rcvq_space.seq = tp->copied_seq;
658
	tp->rcvq_space.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
659 660 661 662 663 664 665 666 667 668 669 670
}

/* 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
 */
671
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
672
{
673
	struct tcp_sock *tp = tcp_sk(sk);
674
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
675 676
	u32 now;

677
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
678

679
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
680 681

	tcp_rcv_rtt_measure(tp);
682

683
	now = tcp_jiffies32;
L
Linus Torvalds 已提交
684

685
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
686 687 688
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
689 690
		tcp_incr_quickack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
691
	} else {
692
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
693

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

711
	tcp_ecn_check_ce(tp, skb);
L
Linus Torvalds 已提交
712 713

	if (skb->len >= 128)
714
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
715 716 717 718 719 720 721 722 723 724 725
}

/* 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
 */
726
static void tcp_rtt_estimator(struct sock *sk, long mrtt_us)
L
Linus Torvalds 已提交
727
{
728
	struct tcp_sock *tp = tcp_sk(sk);
729 730
	long m = mrtt_us; /* RTT */
	u32 srtt = tp->srtt_us;
L
Linus Torvalds 已提交
731 732 733 734

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

E
Eric Dumazet 已提交
790 791 792 793 794 795
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) */
796 797 798 799 800 801 802 803 804 805 806
	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)
807
		rate *= sock_net(sk)->ipv4.sysctl_tcp_pacing_ss_ratio;
808
	else
809
		rate *= sock_net(sk)->ipv4.sysctl_tcp_pacing_ca_ratio;
E
Eric Dumazet 已提交
810 811 812

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

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

816
	/* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate
817 818 819
	 * without any lock. We want to make sure compiler wont store
	 * intermediate values in this location.
	 */
820 821
	WRITE_ONCE(sk->sk_pacing_rate, min_t(u64, rate,
					     sk->sk_max_pacing_rate));
E
Eric Dumazet 已提交
822 823
}

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

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

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

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

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

863
/* Take a notice that peer is sending D-SACKs */
864 865
static void tcp_dsack_seen(struct tcp_sock *tp)
{
866
	tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
867
	tp->rack.dsack_seen = 1;
868 869
}

870 871 872 873 874 875
/* It's reordering when higher sequence was delivered (i.e. sacked) before
 * some lower never-retransmitted sequence ("low_seq"). The maximum reordering
 * distance is approximated in full-mss packet distance ("reordering").
 */
static void tcp_check_sack_reordering(struct sock *sk, const u32 low_seq,
				      const int ts)
L
Linus Torvalds 已提交
876
{
877
	struct tcp_sock *tp = tcp_sk(sk);
878 879
	const u32 mss = tp->mss_cache;
	u32 fack, metric;
880

881 882
	fack = tcp_highest_sack_seq(tp);
	if (!before(low_seq, fack))
883 884
		return;

885 886
	metric = fack - low_seq;
	if ((metric > tp->reordering * mss) && mss) {
L
Linus Torvalds 已提交
887
#if FASTRETRANS_DEBUG > 1
888 889 890
		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,
891
			 0,
892 893
			 tp->sacked_out,
			 tp->undo_marker ? tp->undo_retrans : 0);
L
Linus Torvalds 已提交
894
#endif
895 896
		tp->reordering = min_t(u32, (metric + mss - 1) / mss,
				       sock_net(sk)->ipv4.sysctl_tcp_max_reordering);
L
Linus Torvalds 已提交
897
	}
Y
Yuchung Cheng 已提交
898

Y
Yuchung Cheng 已提交
899
	tp->rack.reord = 1;
900
	/* This exciting event is worth to be remembered. 8) */
901 902
	NET_INC_STATS(sock_net(sk),
		      ts ? LINUX_MIB_TCPTSREORDER : LINUX_MIB_TCPSACKREORDER);
L
Linus Torvalds 已提交
903 904
}

905
/* This must be called before lost_out is incremented */
906 907
static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
{
908
	if (!tp->retransmit_skb_hint ||
909 910
	    before(TCP_SKB_CB(skb)->seq,
		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
911
		tp->retransmit_skb_hint = skb;
912 913
}

914 915 916 917 918 919 920 921 922 923 924 925 926 927 928 929
/* 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);
}

930 931 932 933 934 935
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);
936
		tcp_sum_lost(tp, skb);
937 938 939 940
		TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
	}
}

Y
Yuchung Cheng 已提交
941
void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb)
942 943 944
{
	tcp_verify_retransmit_hint(tp, skb);

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

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

1056
	/* In outstanding window? ...This is valid exit for D-SACKs too.
I
Ilpo Järvinen 已提交
1057 1058 1059
	 * start_seq == snd_una is non-sensical (see comments above)
	 */
	if (after(start_seq, tp->snd_una))
E
Eric Dumazet 已提交
1060
		return true;
I
Ilpo Järvinen 已提交
1061 1062

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

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

	if (!before(start_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1070
		return true;
I
Ilpo Järvinen 已提交
1071 1072 1073

	/* Too old */
	if (!after(end_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1074
		return false;
I
Ilpo Järvinen 已提交
1075 1076 1077 1078 1079 1080 1081

	/* 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 已提交
1082 1083 1084
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)
1085
{
1086
	struct tcp_sock *tp = tcp_sk(sk);
1087 1088
	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 已提交
1089
	bool dup_sack = false;
1090 1091

	if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
E
Eric Dumazet 已提交
1092
		dup_sack = true;
1093
		tcp_dsack_seen(tp);
1094
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
1095
	} else if (num_sacks > 1) {
1096 1097
		u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
		u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
1098 1099 1100

		if (!after(end_seq_0, end_seq_1) &&
		    !before(start_seq_0, start_seq_1)) {
E
Eric Dumazet 已提交
1101
			dup_sack = true;
1102
			tcp_dsack_seen(tp);
1103
			NET_INC_STATS(sock_net(sk),
1104
					LINUX_MIB_TCPDSACKOFORECV);
1105 1106 1107 1108
		}
	}

	/* D-SACK for already forgotten data... Do dumb counting. */
Y
Yuchung Cheng 已提交
1109
	if (dup_sack && tp->undo_marker && tp->undo_retrans > 0 &&
1110 1111 1112 1113 1114 1115 1116
	    !after(end_seq_0, prior_snd_una) &&
	    after(end_seq_0, tp->undo_marker))
		tp->undo_retrans--;

	return dup_sack;
}

1117
struct tcp_sacktag_state {
1118
	u32	reord;
1119 1120 1121 1122
	/* 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.
	 */
1123 1124
	u64	first_sackt;
	u64	last_sackt;
1125
	struct rate_sample *rate;
1126
	int	flag;
1127
	unsigned int mss_now;
1128 1129
};

1130 1131 1132 1133 1134
/* 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).
1135 1136
 *
 * FIXME: this could be merged to shift decision code
1137
 */
1138
static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
E
Eric Dumazet 已提交
1139
				  u32 start_seq, u32 end_seq)
1140
{
E
Eric Dumazet 已提交
1141 1142
	int err;
	bool in_sack;
1143
	unsigned int pkt_len;
1144
	unsigned int mss;
1145 1146 1147 1148 1149 1150

	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)) {
1151
		mss = tcp_skb_mss(skb);
1152 1153
		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);

1154
		if (!in_sack) {
1155
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1156 1157 1158
			if (pkt_len < mss)
				pkt_len = mss;
		} else {
1159
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1160 1161 1162 1163 1164 1165 1166 1167 1168
			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;
1169
			if (!in_sack && new_len < pkt_len)
1170 1171 1172
				new_len += mss;
			pkt_len = new_len;
		}
1173 1174 1175 1176

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

1177 1178
		err = tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
				   pkt_len, mss, GFP_ATOMIC);
1179 1180 1181 1182 1183 1184 1185
		if (err < 0)
			return err;
	}

	return in_sack;
}

1186 1187 1188 1189
/* 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,
1190
			  int dup_sack, int pcount,
1191
			  u64 xmit_time)
1192
{
1193
	struct tcp_sock *tp = tcp_sk(sk);
1194 1195 1196

	/* Account D-SACK for retransmitted packet. */
	if (dup_sack && (sacked & TCPCB_RETRANS)) {
Y
Yuchung Cheng 已提交
1197
		if (tp->undo_marker && tp->undo_retrans > 0 &&
1198
		    after(end_seq, tp->undo_marker))
1199
			tp->undo_retrans--;
1200 1201 1202
		if ((sacked & TCPCB_SACKED_ACKED) &&
		    before(start_seq, state->reord))
				state->reord = start_seq;
1203 1204 1205
	}

	/* Nothing to do; acked frame is about to be dropped (was ACKed). */
1206
	if (!after(end_seq, tp->snd_una))
1207
		return sacked;
1208 1209

	if (!(sacked & TCPCB_SACKED_ACKED)) {
1210
		tcp_rack_advance(tp, sacked, end_seq, xmit_time);
1211

1212 1213 1214 1215 1216 1217
		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) {
1218
				sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
1219 1220
				tp->lost_out -= pcount;
				tp->retrans_out -= pcount;
1221 1222 1223 1224 1225 1226
			}
		} else {
			if (!(sacked & TCPCB_RETRANS)) {
				/* New sack for not retransmitted frame,
				 * which was in hole. It is reordering.
				 */
1227
				if (before(start_seq,
1228 1229 1230 1231
					   tcp_highest_sack_seq(tp)) &&
				    before(start_seq, state->reord))
					state->reord = start_seq;

Y
Yuchung Cheng 已提交
1232 1233
				if (!after(end_seq, tp->high_seq))
					state->flag |= FLAG_ORIG_SACK_ACKED;
1234 1235 1236
				if (state->first_sackt == 0)
					state->first_sackt = xmit_time;
				state->last_sackt = xmit_time;
1237 1238 1239
			}

			if (sacked & TCPCB_LOST) {
1240
				sacked &= ~TCPCB_LOST;
1241
				tp->lost_out -= pcount;
1242 1243 1244
			}
		}

1245 1246
		sacked |= TCPCB_SACKED_ACKED;
		state->flag |= FLAG_DATA_SACKED;
1247
		tp->sacked_out += pcount;
Y
Yuchung Cheng 已提交
1248
		tp->delivered += pcount;  /* Out-of-order packets delivered */
1249 1250

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
Y
Yuchung Cheng 已提交
1251
		if (tp->lost_skb_hint &&
1252
		    before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
1253
			tp->lost_cnt_hint += pcount;
1254 1255 1256 1257 1258 1259
	}

	/* 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.
	 */
1260 1261
	if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
		sacked &= ~TCPCB_SACKED_RETRANS;
1262
		tp->retrans_out -= pcount;
1263 1264
	}

1265
	return sacked;
1266 1267
}

1268 1269 1270
/* Shift newly-SACKed bytes from this skb to the immediately previous
 * already-SACKed sk_buff. Mark the newly-SACKed bytes as such.
 */
1271 1272
static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *prev,
			    struct sk_buff *skb,
E
Eric Dumazet 已提交
1273 1274 1275
			    struct tcp_sacktag_state *state,
			    unsigned int pcount, int shifted, int mss,
			    bool dup_sack)
1276 1277
{
	struct tcp_sock *tp = tcp_sk(sk);
1278 1279
	u32 start_seq = TCP_SKB_CB(skb)->seq;	/* start of newly-SACKed */
	u32 end_seq = start_seq + shifted;	/* end of newly-SACKed */
1280 1281 1282

	BUG_ON(!pcount);

1283 1284 1285 1286 1287 1288 1289
	/* 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 已提交
1290
			start_seq, end_seq, dup_sack, pcount,
1291
			skb->skb_mstamp);
1292
	tcp_rate_skb_delivered(sk, skb, state->rate);
1293 1294

	if (skb == tp->lost_skb_hint)
1295 1296
		tp->lost_cnt_hint += pcount;

1297 1298 1299
	TCP_SKB_CB(prev)->end_seq += shifted;
	TCP_SKB_CB(skb)->seq += shifted;

1300 1301 1302
	tcp_skb_pcount_add(prev, pcount);
	BUG_ON(tcp_skb_pcount(skb) < pcount);
	tcp_skb_pcount_add(skb, -pcount);
1303 1304 1305 1306 1307 1308

	/* 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.
	 */
1309 1310
	if (!TCP_SKB_CB(prev)->tcp_gso_size)
		TCP_SKB_CB(prev)->tcp_gso_size = mss;
1311 1312

	/* CHECKME: To clear or not to clear? Mimics normal skb currently */
1313
	if (tcp_skb_pcount(skb) <= 1)
1314
		TCP_SKB_CB(skb)->tcp_gso_size = 0;
1315 1316 1317 1318 1319 1320

	/* 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));
1321
		NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTED);
E
Eric Dumazet 已提交
1322
		return false;
1323 1324 1325 1326
	}

	/* Whole SKB was eaten :-) */

1327 1328 1329 1330 1331 1332 1333
	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);
	}

1334
	TCP_SKB_CB(prev)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
1335
	TCP_SKB_CB(prev)->eor = TCP_SKB_CB(skb)->eor;
1336 1337 1338
	if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
		TCP_SKB_CB(prev)->end_seq++;

1339 1340 1341
	if (skb == tcp_highest_sack(sk))
		tcp_advance_highest_sack(sk, skb);

1342
	tcp_skb_collapse_tstamp(prev, skb);
1343 1344
	if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp))
		TCP_SKB_CB(prev)->tx.delivered_mstamp = 0;
1345

1346
	tcp_rtx_queue_unlink_and_free(skb, sk);
1347

1348
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
1349

E
Eric Dumazet 已提交
1350
	return true;
1351 1352 1353 1354 1355
}

/* I wish gso_size would have a bit more sane initialization than
 * something-or-zero which complicates things
 */
1356
static int tcp_skb_seglen(const struct sk_buff *skb)
1357
{
1358
	return tcp_skb_pcount(skb) == 1 ? skb->len : tcp_skb_mss(skb);
1359 1360 1361
}

/* Shifting pages past head area doesn't work */
1362
static int skb_can_shift(const struct sk_buff *skb)
1363 1364 1365 1366 1367 1368 1369 1370
{
	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,
1371
					  struct tcp_sacktag_state *state,
1372
					  u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1373
					  bool dup_sack)
1374 1375 1376 1377 1378 1379 1380 1381 1382 1383
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *prev;
	int mss;
	int pcount = 0;
	int len;
	int in_sack;

	/* Normally R but no L won't result in plain S */
	if (!dup_sack &&
1384
	    (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1385 1386 1387 1388 1389 1390 1391 1392
		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 */
1393 1394
	prev = skb_rb_prev(skb);
	if (!prev)
1395 1396 1397 1398 1399
		goto fallback;

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

1400 1401 1402
	if (!tcp_skb_can_collapse_to(prev))
		goto fallback;

1403 1404 1405 1406 1407 1408
	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);
1409
		mss = tcp_skb_seglen(skb);
1410 1411 1412 1413

		/* TODO: Fix DSACKs to not fragment already SACKed and we can
		 * drop this restriction as unnecessary
		 */
1414
		if (mss != tcp_skb_seglen(prev))
1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436 1437 1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449 1450 1451 1452 1453 1454
			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
		 */
1455
		if (mss != tcp_skb_seglen(prev))
1456 1457 1458 1459 1460 1461 1462 1463 1464 1465 1466 1467
			goto fallback;

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

1468 1469 1470 1471
	/* tcp_sacktag_one() won't SACK-tag ranges below snd_una */
	if (!after(TCP_SKB_CB(skb)->seq + len, tp->snd_una))
		goto fallback;

1472 1473
	if (!skb_shift(prev, skb, len))
		goto fallback;
1474
	if (!tcp_shifted_skb(sk, prev, skb, state, pcount, len, mss, dup_sack))
1475 1476 1477 1478 1479
		goto out;

	/* Hole filled allows collapsing with the next as well, this is very
	 * useful when hole on every nth skb pattern happens
	 */
1480 1481
	skb = skb_rb_next(prev);
	if (!skb)
1482 1483
		goto out;

1484 1485
	if (!skb_can_shift(skb) ||
	    ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1486
	    (mss != tcp_skb_seglen(skb)))
1487 1488 1489 1490 1491
		goto out;

	len = skb->len;
	if (skb_shift(prev, skb, len)) {
		pcount += tcp_skb_pcount(skb);
1492 1493
		tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb),
				len, mss, 0);
1494 1495 1496 1497 1498 1499 1500 1501 1502
	}

out:
	return prev;

noop:
	return skb;

fallback:
1503
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1504 1505 1506
	return NULL;
}

1507 1508
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
1509
					struct tcp_sacktag_state *state,
1510
					u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1511
					bool dup_sack_in)
1512
{
1513 1514 1515
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *tmp;

1516
	skb_rbtree_walk_from(skb) {
1517
		int in_sack = 0;
E
Eric Dumazet 已提交
1518
		bool dup_sack = dup_sack_in;
1519 1520 1521 1522 1523

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

1524
		if (next_dup  &&
1525 1526 1527 1528 1529
		    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 已提交
1530
				dup_sack = true;
1531 1532
		}

1533 1534 1535 1536 1537
		/* 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) {
1538 1539
			tmp = tcp_shift_skb_data(sk, skb, state,
						 start_seq, end_seq, dup_sack);
1540
			if (tmp) {
1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553
				if (tmp != skb) {
					skb = tmp;
					continue;
				}

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

1554 1555 1556
		if (unlikely(in_sack < 0))
			break;

1557
		if (in_sack) {
1558 1559 1560 1561 1562 1563 1564
			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 已提交
1565
						tcp_skb_pcount(skb),
1566
						skb->skb_mstamp);
1567
			tcp_rate_skb_delivered(sk, skb, state->rate);
1568 1569
			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
				list_del_init(&skb->tcp_tsorted_anchor);
1570

1571 1572 1573 1574
			if (!before(TCP_SKB_CB(skb)->seq,
				    tcp_highest_sack_seq(tp)))
				tcp_advance_highest_sack(sk, skb);
		}
1575 1576 1577 1578
	}
	return skb;
}

1579 1580 1581 1582 1583 1584 1585 1586 1587 1588 1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601
static struct sk_buff *tcp_sacktag_bsearch(struct sock *sk,
					   struct tcp_sacktag_state *state,
					   u32 seq)
{
	struct rb_node *parent, **p = &sk->tcp_rtx_queue.rb_node;
	struct sk_buff *skb;

	while (*p) {
		parent = *p;
		skb = rb_to_skb(parent);
		if (before(seq, TCP_SKB_CB(skb)->seq)) {
			p = &parent->rb_left;
			continue;
		}
		if (!before(seq, TCP_SKB_CB(skb)->end_seq)) {
			p = &parent->rb_right;
			continue;
		}
		return skb;
	}
	return NULL;
}

1602
static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,
1603 1604
					struct tcp_sacktag_state *state,
					u32 skip_to_seq)
1605
{
1606 1607
	if (skb && after(TCP_SKB_CB(skb)->seq, skip_to_seq))
		return skb;
1608

1609
	return tcp_sacktag_bsearch(sk, state, skip_to_seq);
1610 1611 1612 1613 1614
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
1615 1616
						struct tcp_sacktag_state *state,
						u32 skip_to_seq)
1617
{
1618
	if (!next_dup)
1619 1620 1621
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1622 1623 1624 1625
		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);
1626 1627 1628 1629 1630
	}

	return skb;
}

1631
static int tcp_sack_cache_ok(const struct tcp_sock *tp, const struct tcp_sack_block *cache)
1632 1633 1634 1635
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

L
Linus Torvalds 已提交
1636
static int
1637
tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
1638
			u32 prior_snd_una, struct tcp_sacktag_state *state)
L
Linus Torvalds 已提交
1639 1640
{
	struct tcp_sock *tp = tcp_sk(sk);
1641 1642
	const unsigned char *ptr = (skb_transport_header(ack_skb) +
				    TCP_SKB_CB(ack_skb)->sacked);
1643
	struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);
1644
	struct tcp_sack_block sp[TCP_NUM_SACKS];
1645 1646
	struct tcp_sack_block *cache;
	struct sk_buff *skb;
1647
	int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);
1648
	int used_sacks;
E
Eric Dumazet 已提交
1649
	bool found_dup_sack = false;
1650
	int i, j;
1651
	int first_sack_index;
L
Linus Torvalds 已提交
1652

1653
	state->flag = 0;
1654
	state->reord = tp->snd_nxt;
1655

1656
	if (!tp->sacked_out)
1657
		tcp_highest_sack_reset(sk);
L
Linus Torvalds 已提交
1658

1659
	found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,
1660
					 num_sacks, prior_snd_una);
1661
	if (found_dup_sack) {
1662
		state->flag |= FLAG_DSACKING_ACK;
1663 1664
		tp->delivered++; /* A spurious retransmission is delivered */
	}
1665 1666 1667 1668 1669 1670 1671 1672

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

1673 1674 1675
	if (!tp->packets_out)
		goto out;

1676 1677 1678
	used_sacks = 0;
	first_sack_index = 0;
	for (i = 0; i < num_sacks; i++) {
E
Eric Dumazet 已提交
1679
		bool dup_sack = !i && found_dup_sack;
1680

1681 1682
		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);
1683 1684 1685 1686

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

1689 1690
			if (dup_sack) {
				if (!tp->undo_marker)
1691
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;
1692
				else
1693
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;
1694 1695 1696 1697 1698
			} 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;
1699
				mib_idx = LINUX_MIB_TCPSACKDISCARD;
1700
			}
1701

1702
			NET_INC_STATS(sock_net(sk), mib_idx);
1703 1704 1705 1706 1707 1708 1709 1710 1711 1712 1713 1714
			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++;
	}

1715 1716
	/* order SACK blocks to allow in order walk of the retrans queue */
	for (i = used_sacks - 1; i > 0; i--) {
1717 1718
		for (j = 0; j < i; j++) {
			if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1719
				swap(sp[j], sp[j + 1]);
1720

1721 1722
				/* Track where the first SACK block goes to */
				if (j == first_sack_index)
1723
					first_sack_index = j + 1;
1724 1725 1726 1727
			}
		}
	}

1728 1729
	state->mss_now = tcp_current_mss(sk);
	skb = NULL;
1730 1731 1732 1733 1734 1735 1736 1737 1738 1739 1740
	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++;
1741 1742
	}

1743
	while (i < used_sacks) {
1744 1745
		u32 start_seq = sp[i].start_seq;
		u32 end_seq = sp[i].end_seq;
E
Eric Dumazet 已提交
1746
		bool dup_sack = (found_dup_sack && (i == first_sack_index));
1747
		struct tcp_sack_block *next_dup = NULL;
1748

1749 1750
		if (found_dup_sack && ((i + 1) == first_sack_index))
			next_dup = &sp[i + 1];
L
Linus Torvalds 已提交
1751

1752 1753 1754 1755 1756 1757 1758 1759 1760 1761 1762
		/* 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)) {
1763
				skb = tcp_sacktag_skip(skb, sk, state,
1764
						       start_seq);
1765
				skb = tcp_sacktag_walk(skb, sk, next_dup,
1766
						       state,
1767 1768
						       start_seq,
						       cache->start_seq,
1769
						       dup_sack);
1770
			}
1771

1772
			/* Rest of the block already fully processed? */
1773
			if (!after(end_seq, cache->end_seq))
1774
				goto advance_sp;
1775

1776
			skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
1777
						       state,
1778
						       cache->end_seq);
1779

1780
			/* ...tail remains todo... */
1781
			if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1782
				/* ...but better entrypoint exists! */
1783
				skb = tcp_highest_sack(sk);
1784
				if (!skb)
1785
					break;
1786 1787
				cache++;
				goto walk;
1788 1789
			}

1790
			skb = tcp_sacktag_skip(skb, sk, state, cache->end_seq);
1791 1792 1793 1794
			/* Check overlap against next cached too (past this one already) */
			cache++;
			continue;
		}
L
Linus Torvalds 已提交
1795

1796 1797
		if (!before(start_seq, tcp_highest_sack_seq(tp))) {
			skb = tcp_highest_sack(sk);
1798
			if (!skb)
1799
				break;
L
Linus Torvalds 已提交
1800
		}
1801
		skb = tcp_sacktag_skip(skb, sk, state, start_seq);
1802 1803

walk:
1804
		skb = tcp_sacktag_walk(skb, sk, next_dup, state,
1805
				       start_seq, end_seq, dup_sack);
1806

1807 1808
advance_sp:
		i++;
L
Linus Torvalds 已提交
1809 1810
	}

1811 1812 1813 1814 1815 1816 1817 1818
	/* 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];

1819 1820
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_Loss || tp->undo_marker)
		tcp_check_sack_reordering(sk, state->reord, 0);
L
Linus Torvalds 已提交
1821

1822
	tcp_verify_left_out(tp);
1823 1824
out:

L
Linus Torvalds 已提交
1825
#if FASTRETRANS_DEBUG > 0
1826 1827 1828 1829
	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 已提交
1830
#endif
1831
	return state->flag;
L
Linus Torvalds 已提交
1832 1833
}

1834
/* Limits sacked_out so that sum with lost_out isn't ever larger than
E
Eric Dumazet 已提交
1835
 * packets_out. Returns false if sacked_out adjustement wasn't necessary.
1836
 */
E
Eric Dumazet 已提交
1837
static bool tcp_limit_reno_sacked(struct tcp_sock *tp)
1838 1839 1840 1841 1842 1843 1844 1845
{
	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 已提交
1846
		return true;
1847
	}
E
Eric Dumazet 已提交
1848
	return false;
1849 1850 1851 1852 1853 1854 1855 1856 1857
}

/* 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);
1858 1859 1860 1861 1862 1863 1864

	if (!tcp_limit_reno_sacked(tp))
		return;

	tp->reordering = min_t(u32, tp->packets_out + addend,
			       sock_net(sk)->ipv4.sysctl_tcp_max_reordering);
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRENOREORDER);
1865 1866 1867 1868 1869 1870 1871
}

/* 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 已提交
1872 1873
	u32 prior_sacked = tp->sacked_out;

1874 1875
	tp->sacked_out++;
	tcp_check_reno_reordering(sk, 0);
Y
Yuchung Cheng 已提交
1876 1877
	if (tp->sacked_out > prior_sacked)
		tp->delivered++; /* Some out-of-order packet is delivered */
1878
	tcp_verify_left_out(tp);
1879 1880 1881 1882 1883 1884 1885 1886 1887 1888
}

/* 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 已提交
1889
		tp->delivered += max_t(int, acked - tp->sacked_out, 1);
1890
		if (acked - 1 >= tp->sacked_out)
1891 1892
			tp->sacked_out = 0;
		else
1893
			tp->sacked_out -= acked - 1;
1894 1895
	}
	tcp_check_reno_reordering(sk, acked);
1896
	tcp_verify_left_out(tp);
1897 1898 1899 1900 1901 1902 1903
}

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

Y
Yuchung Cheng 已提交
1904
void tcp_clear_retrans(struct tcp_sock *tp)
L
Linus Torvalds 已提交
1905 1906 1907 1908
{
	tp->retrans_out = 0;
	tp->lost_out = 0;
	tp->undo_marker = 0;
Y
Yuchung Cheng 已提交
1909
	tp->undo_retrans = -1;
Y
Yuchung Cheng 已提交
1910
	tp->sacked_out = 0;
L
Linus Torvalds 已提交
1911 1912
}

Y
Yuchung Cheng 已提交
1913
static inline void tcp_init_undo(struct tcp_sock *tp)
1914
{
Y
Yuchung Cheng 已提交
1915 1916 1917
	tp->undo_marker = tp->snd_una;
	/* Retransmission still in flight may cause DSACKs later. */
	tp->undo_retrans = tp->retrans_out ? : -1;
1918 1919
}

1920
/* Enter Loss state. If we detect SACK reneging, forget all SACK information
L
Linus Torvalds 已提交
1921 1922 1923
 * and reset tags completely, otherwise preserve SACKs. If receiver
 * dropped its ofo queue, we will know this due to reneging detection.
 */
1924
void tcp_enter_loss(struct sock *sk)
L
Linus Torvalds 已提交
1925
{
1926
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1927
	struct tcp_sock *tp = tcp_sk(sk);
1928
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
1929
	struct sk_buff *skb;
1930
	bool new_recovery = icsk->icsk_ca_state < TCP_CA_Recovery;
1931
	bool is_reneg;			/* is receiver reneging on SACKs? */
1932
	bool mark_lost;
L
Linus Torvalds 已提交
1933 1934

	/* Reduce ssthresh if it has not yet been made inside this window. */
Y
Yuchung Cheng 已提交
1935 1936
	if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
	    !after(tp->high_seq, tp->snd_una) ||
1937 1938
	    (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
1939
		tp->prior_cwnd = tp->snd_cwnd;
1940 1941
		tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		tcp_ca_event(sk, CA_EVENT_LOSS);
Y
Yuchung Cheng 已提交
1942
		tcp_init_undo(tp);
L
Linus Torvalds 已提交
1943 1944 1945
	}
	tp->snd_cwnd	   = 1;
	tp->snd_cwnd_cnt   = 0;
1946
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
1947

Y
Yuchung Cheng 已提交
1948 1949
	tp->retrans_out = 0;
	tp->lost_out = 0;
1950 1951 1952

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

1954
	skb = tcp_rtx_queue_head(sk);
1955 1956
	is_reneg = skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED);
	if (is_reneg) {
1957
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
1958
		tp->sacked_out = 0;
1959 1960
		/* Mark SACK reneging until we recover from this loss event. */
		tp->is_sack_reneg = 1;
1961
	}
1962
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
1963

1964
	skb_rbtree_walk_from(skb) {
1965 1966 1967 1968
		mark_lost = (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
			     is_reneg);
		if (mark_lost)
			tcp_sum_lost(tp, skb);
L
Linus Torvalds 已提交
1969
		TCP_SKB_CB(skb)->sacked &= (~TCPCB_TAGBITS)|TCPCB_SACKED_ACKED;
1970
		if (mark_lost) {
L
Linus Torvalds 已提交
1971 1972 1973 1974 1975
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
		}
	}
1976
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1977

1978 1979 1980 1981
	/* 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 &&
1982
	    tp->sacked_out >= net->ipv4.sysctl_tcp_reordering)
1983
		tp->reordering = min_t(unsigned int, tp->reordering,
1984
				       net->ipv4.sysctl_tcp_reordering);
1985
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
1986
	tp->high_seq = tp->snd_nxt;
1987
	tcp_ecn_queue_cwr(tp);
Y
Yuchung Cheng 已提交
1988

1989 1990 1991
	/* 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
Y
Yuchung Cheng 已提交
1992
	 */
E
Eric Dumazet 已提交
1993
	tp->frto = net->ipv4.sysctl_tcp_frto &&
1994 1995
		   (new_recovery || icsk->icsk_retransmits) &&
		   !inet_csk(sk)->icsk_mtup.probe_size;
L
Linus Torvalds 已提交
1996 1997
}

1998 1999 2000 2001
/* 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).
 *
2002 2003 2004 2005 2006
 * 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.
2007
 */
E
Eric Dumazet 已提交
2008
static bool tcp_check_sack_reneging(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2009
{
2010
	if (flag & FLAG_SACK_RENEGING) {
2011 2012 2013
		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 已提交
2014

2015
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2016
					  delay, TCP_RTO_MAX);
E
Eric Dumazet 已提交
2017
		return true;
L
Linus Torvalds 已提交
2018
	}
E
Eric Dumazet 已提交
2019
	return false;
L
Linus Torvalds 已提交
2020 2021
}

2022 2023 2024 2025 2026 2027 2028 2029 2030 2031 2032
/* 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).
 *
 * 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.
 */
2033
static inline int tcp_dupack_heuristics(const struct tcp_sock *tp)
2034
{
Y
Yuchung Cheng 已提交
2035
	return tp->sacked_out + 1;
2036 2037
}

2038 2039 2040 2041 2042
static bool tcp_is_rack(const struct sock *sk)
{
	return sock_net(sk)->ipv4.sysctl_tcp_recovery & TCP_RACK_LOSS_DETECTION;
}

Y
Yuchung Cheng 已提交
2043
/* Linux NewReno/SACK/ECN state machine.
L
Linus Torvalds 已提交
2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
 * --------------------------------------
 *
 * "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.
 *
2090
 *		Essentially, we have now a few algorithms detecting
L
Linus Torvalds 已提交
2091 2092
 *		lost packets.
 *
2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110
 *		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.
 *
 *		If the receiver does not support SACK:
 *
 *		NewReno (RFC6582): in Recovery we assume that one segment
L
Linus Torvalds 已提交
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125 2126 2127 2128 2129 2130 2131 2132 2133 2134 2135 2136 2137 2138 2139
 *		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 已提交
2140
static bool tcp_time_to_recover(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2141
{
2142
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2143 2144 2145

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

	/* Not-A-Trick#2 : Classic rule... */
2149
	if (!tcp_is_rack(sk) && tcp_dupack_heuristics(tp) > tp->reordering)
E
Eric Dumazet 已提交
2150
		return true;
L
Linus Torvalds 已提交
2151

E
Eric Dumazet 已提交
2152
	return false;
L
Linus Torvalds 已提交
2153 2154
}

2155
/* Detect loss in event "A" above by marking head of queue up as lost.
Y
Yuchung Cheng 已提交
2156
 * For non-SACK(Reno) senders, the first "packets" number of segments
2157 2158 2159
 * 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.
2160
 */
I
Ilpo Järvinen 已提交
2161
static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
L
Linus Torvalds 已提交
2162
{
2163
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2164
	struct sk_buff *skb;
2165
	int cnt, oldcnt, lost;
2166
	unsigned int mss;
2167 2168
	/* 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 已提交
2169

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

2182
	skb_rbtree_walk_from(skb) {
2183 2184 2185 2186
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2187

2188
		if (after(TCP_SKB_CB(skb)->end_seq, loss_high))
2189 2190 2191
			break;

		oldcnt = cnt;
Y
Yuchung Cheng 已提交
2192
		if (tcp_is_reno(tp) ||
2193 2194 2195
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

2196
		if (cnt > packets) {
Y
Yuchung Cheng 已提交
2197
			if (tcp_is_sack(tp) ||
2198
			    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
2199
			    (oldcnt >= packets))
2200 2201
				break;

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

2212
		tcp_skb_mark_lost(tp, skb);
I
Ilpo Järvinen 已提交
2213 2214 2215

		if (mark_head)
			break;
L
Linus Torvalds 已提交
2216
	}
2217
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2218 2219 2220 2221
}

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

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

2226
	if (tcp_is_reno(tp)) {
I
Ilpo Järvinen 已提交
2227
		tcp_mark_head_lost(sk, 1, 1);
L
Linus Torvalds 已提交
2228
	} else {
2229
		int sacked_upto = tp->sacked_out - tp->reordering;
I
Ilpo Järvinen 已提交
2230 2231 2232 2233
		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 已提交
2234 2235 2236
	}
}

2237 2238 2239 2240 2241 2242
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);
}

2243 2244 2245 2246 2247 2248 2249 2250 2251 2252
/* 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 已提交
2253 2254 2255
/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
2256
static inline bool tcp_packet_delayed(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2257 2258
{
	return !tp->retrans_stamp ||
2259
	       tcp_tsopt_ecr_before(tp, tp->retrans_stamp);
L
Linus Torvalds 已提交
2260 2261 2262 2263
}

/* Undo procedures. */

2264 2265 2266 2267 2268 2269 2270 2271 2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285
/* 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;

2286
	skb = tcp_rtx_queue_head(sk);
2287 2288 2289 2290 2291 2292
	if (unlikely(skb && TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS))
		return true;

	return false;
}

2293
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2294
{
J
Joe Perches 已提交
2295
#if FASTRETRANS_DEBUG > 1
2296
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2297
	struct inet_sock *inet = inet_sk(sk);
2298

2299
	if (sk->sk_family == AF_INET) {
2300 2301 2302 2303 2304 2305
		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);
2306
	}
E
Eric Dumazet 已提交
2307
#if IS_ENABLED(CONFIG_IPV6)
2308
	else if (sk->sk_family == AF_INET6) {
2309 2310
		pr_debug("Undo %s %pI6/%u c%u l%u ss%u/%u p%u\n",
			 msg,
2311
			 &sk->sk_v6_daddr, ntohs(inet->inet_dport),
2312 2313 2314
			 tp->snd_cwnd, tcp_left_out(tp),
			 tp->snd_ssthresh, tp->prior_ssthresh,
			 tp->packets_out);
2315 2316
	}
#endif
L
Linus Torvalds 已提交
2317
#endif
J
Joe Perches 已提交
2318
}
L
Linus Torvalds 已提交
2319

2320
static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
L
Linus Torvalds 已提交
2321
{
2322 2323
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2324 2325 2326
	if (unmark_loss) {
		struct sk_buff *skb;

2327
		skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
Y
Yuchung Cheng 已提交
2328 2329 2330 2331 2332 2333
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
		}
		tp->lost_out = 0;
		tcp_clear_all_retrans_hints(tp);
	}

L
Linus Torvalds 已提交
2334
	if (tp->prior_ssthresh) {
2335 2336
		const struct inet_connection_sock *icsk = inet_csk(sk);

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

2339
		if (tp->prior_ssthresh > tp->snd_ssthresh) {
L
Linus Torvalds 已提交
2340
			tp->snd_ssthresh = tp->prior_ssthresh;
2341
			tcp_ecn_withdraw_cwr(tp);
L
Linus Torvalds 已提交
2342 2343
		}
	}
2344
	tp->snd_cwnd_stamp = tcp_jiffies32;
2345
	tp->undo_marker = 0;
2346
	tp->rack.advanced = 1; /* Force RACK to re-exam losses */
L
Linus Torvalds 已提交
2347 2348
}

2349
static inline bool tcp_may_undo(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2350
{
2351
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2352 2353 2354
}

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

L
Linus Torvalds 已提交
2359
	if (tcp_may_undo(tp)) {
2360 2361
		int mib_idx;

L
Linus Torvalds 已提交
2362 2363 2364
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2365
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2366
		tcp_undo_cwnd_reduction(sk, false);
2367
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2368
			mib_idx = LINUX_MIB_TCPLOSSUNDO;
L
Linus Torvalds 已提交
2369
		else
2370 2371
			mib_idx = LINUX_MIB_TCPFULLUNDO;

2372
		NET_INC_STATS(sock_net(sk), mib_idx);
2373 2374
	} else if (tp->rack.reo_wnd_persist) {
		tp->rack.reo_wnd_persist--;
L
Linus Torvalds 已提交
2375
	}
2376
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2377 2378 2379
		/* 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. */
2380 2381
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;
E
Eric Dumazet 已提交
2382
		return true;
L
Linus Torvalds 已提交
2383
	}
2384
	tcp_set_ca_state(sk, TCP_CA_Open);
2385
	tp->is_sack_reneg = 0;
E
Eric Dumazet 已提交
2386
	return false;
L
Linus Torvalds 已提交
2387 2388 2389
}

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

L
Linus Torvalds 已提交
2394
	if (tp->undo_marker && !tp->undo_retrans) {
2395 2396
		tp->rack.reo_wnd_persist = min(TCP_RACK_RECOVERY_THRESH,
					       tp->rack.reo_wnd_persist + 1);
2397
		DBGUNDO(sk, "D-SACK");
2398
		tcp_undo_cwnd_reduction(sk, false);
2399
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
2400
		return true;
L
Linus Torvalds 已提交
2401
	}
2402
	return false;
L
Linus Torvalds 已提交
2403 2404
}

Y
Yuchung Cheng 已提交
2405 2406
/* 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 已提交
2407
{
2408 2409
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2410
	if (frto_undo || tcp_may_undo(tp)) {
2411
		tcp_undo_cwnd_reduction(sk, true);
2412

2413
		DBGUNDO(sk, "partial loss");
2414
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
Y
Yuchung Cheng 已提交
2415
		if (frto_undo)
2416
			NET_INC_STATS(sock_net(sk),
2417
					LINUX_MIB_TCPSPURIOUSRTOS);
2418
		inet_csk(sk)->icsk_retransmits = 0;
2419
		if (frto_undo || tcp_is_sack(tp)) {
2420
			tcp_set_ca_state(sk, TCP_CA_Open);
2421 2422
			tp->is_sack_reneg = 0;
		}
E
Eric Dumazet 已提交
2423
		return true;
L
Linus Torvalds 已提交
2424
	}
E
Eric Dumazet 已提交
2425
	return false;
L
Linus Torvalds 已提交
2426 2427
}

2428
/* The cwnd reduction in CWR and Recovery uses the PRR algorithm in RFC 6937.
2429 2430 2431 2432
 * 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.
2433 2434 2435
 *   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.
2436
 */
2437
static void tcp_init_cwnd_reduction(struct sock *sk)
2438 2439 2440 2441
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->high_seq = tp->snd_nxt;
N
Nandita Dukkipati 已提交
2442
	tp->tlp_high_seq = 0;
2443 2444 2445 2446
	tp->snd_cwnd_cnt = 0;
	tp->prior_cwnd = tp->snd_cwnd;
	tp->prr_delivered = 0;
	tp->prr_out = 0;
2447
	tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);
2448
	tcp_ecn_queue_cwr(tp);
2449 2450
}

2451
void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int flag)
2452 2453 2454 2455 2456
{
	struct tcp_sock *tp = tcp_sk(sk);
	int sndcnt = 0;
	int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);

2457 2458 2459
	if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))
		return;

2460
	tp->prr_delivered += newly_acked_sacked;
2461
	if (delta < 0) {
2462 2463 2464
		u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
			       tp->prior_cwnd - 1;
		sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;
2465 2466
	} else if ((flag & FLAG_RETRANS_DATA_ACKED) &&
		   !(flag & FLAG_LOST_RETRANS)) {
2467 2468 2469
		sndcnt = min_t(int, delta,
			       max_t(int, tp->prr_delivered - tp->prr_out,
				     newly_acked_sacked) + 1);
2470 2471
	} else {
		sndcnt = min(delta, newly_acked_sacked);
2472
	}
2473 2474
	/* Force a fast retransmit upon entering fast recovery */
	sndcnt = max(sndcnt, (tp->prr_out ? 0 : 1));
2475 2476 2477
	tp->snd_cwnd = tcp_packets_in_flight(tp) + sndcnt;
}

2478
static inline void tcp_end_cwnd_reduction(struct sock *sk)
L
Linus Torvalds 已提交
2479
{
2480
	struct tcp_sock *tp = tcp_sk(sk);
2481

2482 2483 2484
	if (inet_csk(sk)->icsk_ca_ops->cong_control)
		return;

2485
	/* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
2486 2487
	if (tp->snd_ssthresh < TCP_INFINITE_SSTHRESH &&
	    (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR || tp->undo_marker)) {
2488
		tp->snd_cwnd = tp->snd_ssthresh;
2489
		tp->snd_cwnd_stamp = tcp_jiffies32;
2490
	}
2491
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2492 2493
}

2494
/* Enter CWR state. Disable cwnd undo since congestion is proven with ECN */
2495
void tcp_enter_cwr(struct sock *sk)
Y
Yuchung Cheng 已提交
2496 2497 2498 2499
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->prior_ssthresh = 0;
2500
	if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
Y
Yuchung Cheng 已提交
2501
		tp->undo_marker = 0;
2502
		tcp_init_cwnd_reduction(sk);
Y
Yuchung Cheng 已提交
2503 2504 2505
		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}
2506
EXPORT_SYMBOL(tcp_enter_cwr);
Y
Yuchung Cheng 已提交
2507

2508 2509 2510 2511 2512
static void tcp_try_keep_open(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int state = TCP_CA_Open;

2513
	if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
2514 2515 2516 2517 2518 2519 2520 2521
		state = TCP_CA_Disorder;

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

2522
static void tcp_try_to_open(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2523
{
2524 2525
	struct tcp_sock *tp = tcp_sk(sk);

2526 2527
	tcp_verify_left_out(tp);

Y
Yuchung Cheng 已提交
2528
	if (!tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2529 2530
		tp->retrans_stamp = 0;

2531
	if (flag & FLAG_ECE)
2532
		tcp_enter_cwr(sk);
L
Linus Torvalds 已提交
2533

2534
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2535
		tcp_try_keep_open(sk);
L
Linus Torvalds 已提交
2536 2537 2538
	}
}

J
John Heffner 已提交
2539 2540 2541 2542 2543 2544
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;
2545
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
J
John Heffner 已提交
2546 2547
}

2548
static void tcp_mtup_probe_success(struct sock *sk)
J
John Heffner 已提交
2549 2550 2551 2552 2553 2554 2555 2556 2557 2558
{
	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;
2559
	tp->snd_cwnd_stamp = tcp_jiffies32;
2560
	tp->snd_ssthresh = tcp_current_ssthresh(sk);
J
John Heffner 已提交
2561 2562 2563 2564

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

2568 2569 2570 2571 2572 2573 2574 2575 2576
/* 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 已提交
2577
	unsigned int mss = tcp_current_mss(sk);
2578

2579
	skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
2580
		if (tcp_skb_seglen(skb) > mss &&
2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591
		    !(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);

2592
	if (!tp->lost_out)
2593 2594 2595 2596 2597 2598 2599 2600 2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613
		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 已提交
2614
EXPORT_SYMBOL(tcp_simple_retransmit);
2615

2616
void tcp_enter_recovery(struct sock *sk, bool ece_ack)
2617 2618 2619 2620 2621 2622 2623 2624 2625
{
	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;

2626
	NET_INC_STATS(sock_net(sk), mib_idx);
2627 2628

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

2631
	if (!tcp_in_cwnd_reduction(sk)) {
2632 2633
		if (!ece_ack)
			tp->prior_ssthresh = tcp_current_ssthresh(sk);
2634
		tcp_init_cwnd_reduction(sk);
2635 2636 2637 2638
	}
	tcp_set_ca_state(sk, TCP_CA_Recovery);
}

2639 2640 2641
/* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
 * recovered or spurious. Otherwise retransmits more on partial ACKs.
 */
2642 2643
static void tcp_process_loss(struct sock *sk, int flag, bool is_dupack,
			     int *rexmit)
2644 2645
{
	struct tcp_sock *tp = tcp_sk(sk);
Y
Yuchung Cheng 已提交
2646
	bool recovered = !before(tp->snd_una, tp->high_seq);
2647

2648 2649 2650 2651
	if ((flag & FLAG_SND_UNA_ADVANCED) &&
	    tcp_try_undo_loss(sk, false))
		return;

2652
	if (tp->frto) { /* F-RTO RFC5682 sec 3.1 (sack enhanced version). */
2653 2654 2655 2656 2657 2658 2659
		/* Step 3.b. A timeout is spurious if not all data are
		 * lost, i.e., never-retransmitted data are (s)acked.
		 */
		if ((flag & FLAG_ORIG_SACK_ACKED) &&
		    tcp_try_undo_loss(sk, true))
			return;

2660 2661 2662
		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 已提交
2663 2664
		} else if (flag & FLAG_SND_UNA_ADVANCED && !recovered) {
			tp->high_seq = tp->snd_nxt;
2665 2666 2667 2668
			/* Step 2.b. Try send new data (but deferred until cwnd
			 * is updated in tcp_ack()). Otherwise fall back to
			 * the conventional recovery.
			 */
2669
			if (!tcp_write_queue_empty(sk) &&
2670 2671 2672 2673
			    after(tcp_wnd_end(tp), tp->snd_nxt)) {
				*rexmit = REXMIT_NEW;
				return;
			}
Y
Yuchung Cheng 已提交
2674 2675 2676 2677 2678 2679
			tp->frto = 0;
		}
	}

	if (recovered) {
		/* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
2680 2681 2682
		tcp_try_undo_recovery(sk);
		return;
	}
Y
Yuchung Cheng 已提交
2683 2684 2685 2686 2687 2688 2689 2690 2691
	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);
	}
2692
	*rexmit = REXMIT_LOST;
2693 2694
}

Y
Yuchung Cheng 已提交
2695
/* Undo during fast recovery after partial ACK. */
2696
static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una)
Y
Yuchung Cheng 已提交
2697 2698 2699
{
	struct tcp_sock *tp = tcp_sk(sk);

2700
	if (tp->undo_marker && tcp_packet_delayed(tp)) {
Y
Yuchung Cheng 已提交
2701
		/* Plain luck! Hole if filled with delayed
2702
		 * packet, rather than with a retransmit. Check reordering.
Y
Yuchung Cheng 已提交
2703
		 */
2704
		tcp_check_sack_reordering(sk, prior_snd_una, 1);
2705 2706 2707 2708 2709 2710

		/* 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.
		 */
2711
		if (tp->retrans_out)
2712 2713
			return true;

Y
Yuchung Cheng 已提交
2714 2715 2716
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;

2717 2718
		DBGUNDO(sk, "partial recovery");
		tcp_undo_cwnd_reduction(sk, true);
2719
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
2720 2721
		tcp_try_keep_open(sk);
		return true;
Y
Yuchung Cheng 已提交
2722
	}
2723
	return false;
Y
Yuchung Cheng 已提交
2724 2725
}

2726
static void tcp_rack_identify_loss(struct sock *sk, int *ack_flag)
2727 2728 2729
{
	struct tcp_sock *tp = tcp_sk(sk);

2730
	if (tcp_is_rack(sk)) {
2731 2732
		u32 prior_retrans = tp->retrans_out;

2733
		tcp_rack_mark_lost(sk);
2734 2735 2736 2737 2738
		if (prior_retrans > tp->retrans_out)
			*ack_flag |= FLAG_LOST_RETRANS;
	}
}

2739 2740 2741 2742 2743 2744 2745 2746
static bool tcp_force_fast_retransmit(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);

	return after(tcp_highest_sack_seq(tp),
		     tp->snd_una + tp->reordering * tp->mss_cache);
}

L
Linus Torvalds 已提交
2747 2748 2749 2750 2751
/* 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.
 *
2752 2753 2754
 * 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 已提交
2755 2756 2757 2758
 *
 * It does _not_ decide what to send, it is made in function
 * tcp_xmit_retransmit_queue().
 */
2759
static void tcp_fastretrans_alert(struct sock *sk, const u32 prior_snd_una,
2760
				  bool is_dupack, int *ack_flag, int *rexmit)
L
Linus Torvalds 已提交
2761
{
2762
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2763
	struct tcp_sock *tp = tcp_sk(sk);
2764
	int fast_rexmit = 0, flag = *ack_flag;
Y
Yuchung Cheng 已提交
2765
	bool do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
2766
				     tcp_force_fast_retransmit(sk));
L
Linus Torvalds 已提交
2767

2768
	if (!tp->packets_out && tp->sacked_out)
L
Linus Torvalds 已提交
2769 2770
		tp->sacked_out = 0;

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

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

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

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

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

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

2844
		if (icsk->icsk_ca_state <= TCP_CA_Disorder)
2845
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2846

2847
		tcp_rack_identify_loss(sk, ack_flag);
2848
		if (!tcp_time_to_recover(sk, flag)) {
2849
			tcp_try_to_open(sk, flag);
L
Linus Torvalds 已提交
2850 2851 2852
			return;
		}

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

2869
	if (!tcp_is_rack(sk) && do_lost)
2870
		tcp_update_scoreboard(sk, fast_rexmit);
2871
	*rexmit = REXMIT_LOST;
L
Linus Torvalds 已提交
2872 2873
}

2874
static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us, const int flag)
2875
{
2876
	u32 wlen = sock_net(sk)->ipv4.sysctl_tcp_min_rtt_wlen * HZ;
2877 2878
	struct tcp_sock *tp = tcp_sk(sk);

2879 2880 2881 2882 2883 2884 2885
	if ((flag & FLAG_ACK_MAYBE_DELAYED) && rtt_us > tcp_min_rtt(tp)) {
		/* If the remote keeps returning delayed ACKs, eventually
		 * the min filter would pick it up and overestimate the
		 * prop. delay when it expires. Skip suspected delayed ACKs.
		 */
		return;
	}
2886
	minmax_running_min(&tp->rtt_min, wlen, tcp_jiffies32,
2887
			   rtt_us ? : jiffies_to_usecs(1));
2888 2889
}

2890 2891 2892
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)
2893
{
2894 2895 2896 2897 2898 2899 2900
	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).
	 */
2901 2902
	if (seq_rtt_us < 0)
		seq_rtt_us = sack_rtt_us;
Y
Yuchung Cheng 已提交
2903

L
Linus Torvalds 已提交
2904 2905 2906 2907 2908 2909
	/* 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.
	 */
2910
	if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2911 2912 2913 2914 2915 2916
	    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;
	}
2917
	rs->rtt_us = ca_rtt_us; /* RTT of last (S)ACKed packet (or -1) */
2918
	if (seq_rtt_us < 0)
Y
Yuchung Cheng 已提交
2919
		return false;
L
Linus Torvalds 已提交
2920

2921 2922 2923 2924
	/* 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.
	 */
2925
	tcp_update_rtt_min(sk, ca_rtt_us, flag);
2926
	tcp_rtt_estimator(sk, seq_rtt_us);
2927
	tcp_set_rto(sk);
L
Linus Torvalds 已提交
2928

2929 2930
	/* RFC6298: only reset backoff on valid RTT measurement. */
	inet_csk(sk)->icsk_backoff = 0;
Y
Yuchung Cheng 已提交
2931
	return true;
L
Linus Torvalds 已提交
2932 2933
}

2934
/* Compute time elapsed between (last) SYNACK and the ACK completing 3WHS. */
Y
Yuchung Cheng 已提交
2935
void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
2936
{
2937
	struct rate_sample rs;
Y
Yuchung Cheng 已提交
2938
	long rtt_us = -1L;
2939

2940 2941
	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 已提交
2942

2943
	tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us, &rs);
2944 2945
}

Y
Yuchung Cheng 已提交
2946

2947
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
L
Linus Torvalds 已提交
2948
{
2949
	const struct inet_connection_sock *icsk = inet_csk(sk);
2950 2951

	icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
2952
	tcp_sk(sk)->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
2953 2954 2955 2956 2957
}

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

2963 2964 2965 2966 2967 2968
	/* 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 已提交
2969
	if (!tp->packets_out) {
2970
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
2971
	} else {
2972 2973
		u32 rto = inet_csk(sk)->icsk_rto;
		/* Offset the time elapsed after installing regular RTO */
Y
Yuchung Cheng 已提交
2974
		if (icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
N
Nandita Dukkipati 已提交
2975
		    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
2976
			s64 delta_us = tcp_rto_delta_us(sk);
E
Eric Dumazet 已提交
2977
			/* delta_us may not be positive if the socket is locked
N
Nandita Dukkipati 已提交
2978
			 * when the retrans timer fires and is rescheduled.
2979
			 */
2980
			rto = usecs_to_jiffies(max_t(int, delta_us, 1));
2981 2982 2983
		}
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, rto,
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
2984
	}
2985 2986
}

2987 2988 2989
/* Try to schedule a loss probe; if that doesn't work, then schedule an RTO. */
static void tcp_set_xmit_timer(struct sock *sk)
{
2990
	if (!tcp_schedule_loss_probe(sk, true))
2991 2992 2993
		tcp_rearm_rto(sk);
}

2994
/* If we get here, the whole TSO packet has not been acked. */
2995
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
2996 2997
{
	struct tcp_sock *tp = tcp_sk(sk);
2998
	u32 packets_acked;
L
Linus Torvalds 已提交
2999

3000
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
3001 3002

	packets_acked = tcp_skb_pcount(skb);
3003
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
3004 3005 3006 3007 3008
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

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

3012
	return packets_acked;
L
Linus Torvalds 已提交
3013 3014
}

3015 3016 3017 3018 3019 3020
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 */
3021
	if (likely(!TCP_SKB_CB(skb)->txstamp_ack))
3022 3023 3024
		return;

	shinfo = skb_shinfo(skb);
3025
	if (!before(shinfo->tskey, prior_snd_una) &&
3026 3027 3028 3029 3030
	    before(shinfo->tskey, tcp_sk(sk)->snd_una)) {
		tcp_skb_tsorted_save(skb) {
			__skb_tstamp_tx(skb, NULL, sk, SCM_TSTAMP_ACK);
		} tcp_skb_tsorted_restore(skb);
	}
3031 3032
}

3033 3034 3035 3036
/* 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.
 */
3037 3038
static int tcp_clean_rtx_queue(struct sock *sk, u32 prior_fack,
			       u32 prior_snd_una,
3039
			       struct tcp_sacktag_state *sack)
L
Linus Torvalds 已提交
3040
{
3041
	const struct inet_connection_sock *icsk = inet_csk(sk);
3042
	u64 first_ackt, last_ackt;
3043 3044
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_sacked = tp->sacked_out;
3045
	u32 reord = tp->snd_nxt; /* lowest acked un-retx un-sacked seq */
3046
	struct sk_buff *skb, *next;
3047
	bool fully_acked = true;
3048
	long sack_rtt_us = -1L;
3049
	long seq_rtt_us = -1L;
3050
	long ca_rtt_us = -1L;
3051
	u32 pkts_acked = 0;
3052
	u32 last_in_flight = 0;
3053
	bool rtt_update;
3054 3055
	int flag = 0;

3056
	first_ackt = 0;
L
Linus Torvalds 已提交
3057

3058
	for (skb = skb_rb_first(&sk->tcp_rtx_queue); skb; skb = next) {
3059
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3060
		const u32 start_seq = scb->seq;
3061
		u8 sacked = scb->sacked;
3062
		u32 acked_pcount;
L
Linus Torvalds 已提交
3063

3064
		tcp_ack_tstamp(sk, skb, prior_snd_una);
3065

3066
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
3067
		if (after(scb->end_seq, tp->snd_una)) {
3068 3069 3070 3071
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

3072 3073
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
3074
				break;
E
Eric Dumazet 已提交
3075
			fully_acked = false;
3076
		} else {
3077
			acked_pcount = tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
3078 3079
		}

3080
		if (unlikely(sacked & TCPCB_RETRANS)) {
3081
			if (sacked & TCPCB_SACKED_RETRANS)
3082
				tp->retrans_out -= acked_pcount;
3083
			flag |= FLAG_RETRANS_DATA_ACKED;
3084
		} else if (!(sacked & TCPCB_SACKED_ACKED)) {
3085
			last_ackt = skb->skb_mstamp;
3086 3087
			WARN_ON_ONCE(last_ackt == 0);
			if (!first_ackt)
3088 3089
				first_ackt = last_ackt;

3090
			last_in_flight = TCP_SKB_CB(skb)->tx.in_flight;
3091 3092
			if (before(start_seq, reord))
				reord = start_seq;
3093 3094
			if (!after(scb->end_seq, tp->high_seq))
				flag |= FLAG_ORIG_SACK_ACKED;
3095
		}
3096

Y
Yuchung Cheng 已提交
3097
		if (sacked & TCPCB_SACKED_ACKED) {
3098
			tp->sacked_out -= acked_pcount;
Y
Yuchung Cheng 已提交
3099 3100 3101
		} else if (tcp_is_sack(tp)) {
			tp->delivered += acked_pcount;
			if (!tcp_skb_spurious_retrans(tp, skb))
3102
				tcp_rack_advance(tp, sacked, scb->end_seq,
3103
						 skb->skb_mstamp);
Y
Yuchung Cheng 已提交
3104
		}
3105
		if (sacked & TCPCB_LOST)
3106
			tp->lost_out -= acked_pcount;
3107

3108 3109
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
3110
		tcp_rate_skb_delivered(sk, skb, sack->rate);
3111

3112 3113 3114 3115 3116 3117 3118
		/* 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.
		 */
3119
		if (likely(!(scb->tcp_flags & TCPHDR_SYN))) {
3120 3121 3122 3123 3124 3125
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

3126 3127 3128
		if (!fully_acked)
			break;

3129
		next = skb_rb_next(skb);
3130
		if (unlikely(skb == tp->retransmit_skb_hint))
3131
			tp->retransmit_skb_hint = NULL;
3132
		if (unlikely(skb == tp->lost_skb_hint))
3133
			tp->lost_skb_hint = NULL;
3134
		tcp_rtx_queue_unlink_and_free(skb, sk);
L
Linus Torvalds 已提交
3135 3136
	}

3137 3138 3139
	if (!skb)
		tcp_chrono_stop(sk, TCP_CHRONO_BUSY);

I
Ilpo Järvinen 已提交
3140 3141 3142
	if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
		tp->snd_up = tp->snd_una;

3143 3144 3145
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

3146 3147 3148
	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);
3149 3150 3151 3152 3153 3154 3155 3156 3157 3158 3159

		if (pkts_acked == 1 && last_in_flight < tp->mss_cache &&
		    last_in_flight && !prior_sacked && fully_acked &&
		    sack->rate->prior_delivered + 1 == tp->delivered &&
		    !(flag & (FLAG_CA_ALERT | FLAG_SYN_ACKED))) {
			/* Conservatively mark a delayed ACK. It's typically
			 * from a lone runt packet over the round trip to
			 * a receiver w/o out-of-order or CE events.
			 */
			flag |= FLAG_ACK_MAYBE_DELAYED;
		}
3160
	}
3161 3162 3163
	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);
3164
	}
3165
	rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
3166
					ca_rtt_us, sack->rate);
Y
Yuchung Cheng 已提交
3167

3168
	if (flag & FLAG_ACKED) {
3169
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
3170 3171 3172 3173 3174
		if (unlikely(icsk->icsk_mtup.probe_size &&
			     !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
			tcp_mtup_probe_success(sk);
		}

3175 3176 3177
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
		} else {
3178 3179
			int delta;

3180
			/* Non-retransmitted hole got filled? That's reordering */
3181 3182
			if (before(reord, prior_fack))
				tcp_check_sack_reordering(sk, reord, 0);
3183

Y
Yuchung Cheng 已提交
3184
			delta = prior_sacked - tp->sacked_out;
3185
			tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3186
		}
3187
	} else if (skb && rtt_update && sack_rtt_us >= 0 &&
3188
		   sack_rtt_us > tcp_stamp_us_delta(tp->tcp_mstamp, skb->skb_mstamp)) {
3189 3190 3191 3192
		/* 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.
		 */
3193
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
L
Linus Torvalds 已提交
3194 3195
	}

3196 3197
	if (icsk->icsk_ca_ops->pkts_acked) {
		struct ack_sample sample = { .pkts_acked = pkts_acked,
3198
					     .rtt_us = sack->rate->rtt_us,
3199
					     .in_flight = last_in_flight };
3200 3201 3202

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

L
Linus Torvalds 已提交
3204
#if FASTRETRANS_DEBUG > 0
3205 3206 3207
	WARN_ON((int)tp->sacked_out < 0);
	WARN_ON((int)tp->lost_out < 0);
	WARN_ON((int)tp->retrans_out < 0);
3208
	if (!tp->packets_out && tcp_is_sack(tp)) {
S
Stephen Hemminger 已提交
3209
		icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3210
		if (tp->lost_out) {
3211 3212
			pr_debug("Leak l=%u %d\n",
				 tp->lost_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3213 3214 3215
			tp->lost_out = 0;
		}
		if (tp->sacked_out) {
3216 3217
			pr_debug("Leak s=%u %d\n",
				 tp->sacked_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3218 3219 3220
			tp->sacked_out = 0;
		}
		if (tp->retrans_out) {
3221 3222
			pr_debug("Leak r=%u %d\n",
				 tp->retrans_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3223 3224 3225 3226
			tp->retrans_out = 0;
		}
	}
#endif
3227
	return flag;
L
Linus Torvalds 已提交
3228 3229 3230 3231
}

static void tcp_ack_probe(struct sock *sk)
{
3232
	struct inet_connection_sock *icsk = inet_csk(sk);
3233 3234
	struct sk_buff *head = tcp_send_head(sk);
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3235 3236

	/* Was it a usable window open? */
3237 3238 3239
	if (!head)
		return;
	if (!after(TCP_SKB_CB(head)->end_seq, tcp_wnd_end(tp))) {
3240 3241
		icsk->icsk_backoff = 0;
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
L
Linus Torvalds 已提交
3242 3243 3244 3245
		/* Socket must be waked up by subsequent tcp_data_snd_check().
		 * This function is not for random using!
		 */
	} else {
3246
		unsigned long when = tcp_probe0_when(sk, TCP_RTO_MAX);
3247

3248
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3249
					  when, TCP_RTO_MAX);
L
Linus Torvalds 已提交
3250 3251 3252
	}
}

3253
static inline bool tcp_ack_is_dubious(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3254
{
E
Eric Dumazet 已提交
3255 3256
	return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
		inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
L
Linus Torvalds 已提交
3257 3258
}

3259
/* Decide wheather to run the increase function of congestion control. */
3260
static inline bool tcp_may_raise_cwnd(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3261
{
3262 3263
	/* If reordering is high then always grow cwnd whenever data is
	 * delivered regardless of its ordering. Otherwise stay conservative
3264
	 * and only grow cwnd on in-order delivery (RFC5681). A stretched ACK w/
3265 3266 3267
	 * new SACK or ECE mark may first advance cwnd here and later reduce
	 * cwnd in tcp_fastretrans_alert() based on more states.
	 */
3268
	if (tcp_sk(sk)->reordering > sock_net(sk)->ipv4.sysctl_tcp_reordering)
3269 3270
		return flag & FLAG_FORWARD_PROGRESS;

3271
	return flag & FLAG_DATA_ACKED;
L
Linus Torvalds 已提交
3272 3273
}

Y
Yuchung Cheng 已提交
3274 3275 3276 3277 3278 3279
/* 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,
3280
			     int flag, const struct rate_sample *rs)
Y
Yuchung Cheng 已提交
3281
{
3282 3283 3284 3285 3286 3287 3288
	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 已提交
3289 3290 3291 3292 3293 3294 3295 3296 3297 3298
	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 已提交
3299 3300 3301
/* Check that window update is acceptable.
 * The function assumes that snd_una<=ack<=snd_next.
 */
3302
static inline bool tcp_may_update_window(const struct tcp_sock *tp,
3303 3304
					const u32 ack, const u32 ack_seq,
					const u32 nwin)
L
Linus Torvalds 已提交
3305
{
E
Eric Dumazet 已提交
3306
	return	after(ack, tp->snd_una) ||
L
Linus Torvalds 已提交
3307
		after(ack_seq, tp->snd_wl1) ||
E
Eric Dumazet 已提交
3308
		(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);
L
Linus Torvalds 已提交
3309 3310
}

3311 3312 3313 3314 3315
/* 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;

3316
	sock_owned_by_me((struct sock *)tp);
3317 3318 3319 3320
	tp->bytes_acked += delta;
	tp->snd_una = ack;
}

3321 3322 3323 3324 3325
/* 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;

3326
	sock_owned_by_me((struct sock *)tp);
3327 3328 3329 3330
	tp->bytes_received += delta;
	tp->rcv_nxt = seq;
}

L
Linus Torvalds 已提交
3331 3332 3333 3334 3335
/* 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.
 */
3336
static int tcp_ack_update_window(struct sock *sk, const struct sk_buff *skb, u32 ack,
3337
				 u32 ack_seq)
L
Linus Torvalds 已提交
3338
{
3339
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3340
	int flag = 0;
3341
	u32 nwin = ntohs(tcp_hdr(skb)->window);
L
Linus Torvalds 已提交
3342

3343
	if (likely(!tcp_hdr(skb)->syn))
L
Linus Torvalds 已提交
3344 3345 3346 3347
		nwin <<= tp->rx_opt.snd_wscale;

	if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {
		flag |= FLAG_WIN_UPDATE;
3348
		tcp_update_wl(tp, ack_seq);
L
Linus Torvalds 已提交
3349 3350 3351 3352

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

3353 3354 3355 3356 3357 3358
			/* Note, it is the only place, where
			 * fast path is recovered for sending TCP.
			 */
			tp->pred_flags = 0;
			tcp_fast_path_check(sk);

3359
			if (!tcp_write_queue_empty(sk))
3360 3361
				tcp_slow_start_after_idle_check(sk);

L
Linus Torvalds 已提交
3362 3363
			if (nwin > tp->max_window) {
				tp->max_window = nwin;
3364
				tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
3365 3366 3367 3368
			}
		}
	}

3369
	tcp_snd_una_update(tp, ack);
L
Linus Torvalds 已提交
3370 3371 3372 3373

	return flag;
}

3374 3375 3376 3377
static bool __tcp_oow_rate_limited(struct net *net, int mib_idx,
				   u32 *last_oow_ack_time)
{
	if (*last_oow_ack_time) {
3378
		s32 elapsed = (s32)(tcp_jiffies32 - *last_oow_ack_time);
3379

3380
		if (0 <= elapsed && elapsed < net->ipv4.sysctl_tcp_invalid_ratelimit) {
3381 3382 3383 3384 3385
			NET_INC_STATS(net, mib_idx);
			return true;	/* rate-limited: don't send yet! */
		}
	}

3386
	*last_oow_ack_time = tcp_jiffies32;
3387 3388 3389 3390

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

3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403
/* 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)
3404
		return false;
3405

3406
	return __tcp_oow_rate_limited(net, mib_idx, last_oow_ack_time);
3407 3408
}

3409
/* RFC 5961 7 [ACK Throttling] */
3410
static void tcp_send_challenge_ack(struct sock *sk, const struct sk_buff *skb)
3411 3412 3413 3414
{
	/* unprotected vars, we dont care of overwrites */
	static u32 challenge_timestamp;
	static unsigned int challenge_count;
3415
	struct tcp_sock *tp = tcp_sk(sk);
3416
	struct net *net = sock_net(sk);
3417
	u32 count, now;
3418 3419

	/* First check our per-socket dupack rate limit. */
3420
	if (__tcp_oow_rate_limited(net,
3421 3422
				   LINUX_MIB_TCPACKSKIPPEDCHALLENGE,
				   &tp->last_oow_ack_time))
3423
		return;
3424

3425
	/* Then check host-wide RFC 5961 rate limit. */
3426
	now = jiffies / HZ;
3427
	if (now != challenge_timestamp) {
3428 3429
		u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit;
		u32 half = (ack_limit + 1) >> 1;
3430

3431
		challenge_timestamp = now;
3432
		WRITE_ONCE(challenge_count, half + prandom_u32_max(ack_limit));
3433
	}
3434 3435 3436
	count = READ_ONCE(challenge_count);
	if (count > 0) {
		WRITE_ONCE(challenge_count, count - 1);
3437
		NET_INC_STATS(net, LINUX_MIB_TCPCHALLENGEACK);
3438 3439 3440 3441
		tcp_send_ack(sk);
	}
}

3442 3443 3444 3445 3446 3447 3448 3449 3450 3451 3452 3453 3454 3455 3456 3457 3458 3459 3460 3461 3462
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 已提交
3463
/* This routine deals with acks during a TLP episode.
3464 3465
 * We mark the end of a TLP episode on receiving TLP dupack or when
 * ack is after tlp_high_seq.
N
Nandita Dukkipati 已提交
3466 3467 3468 3469 3470 3471
 * 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);

3472
	if (before(ack, tp->tlp_high_seq))
N
Nandita Dukkipati 已提交
3473 3474
		return;

3475 3476 3477 3478 3479 3480 3481 3482 3483 3484 3485
	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);
3486
		NET_INC_STATS(sock_net(sk),
3487
				LINUX_MIB_TCPLOSSPROBERECOVERY);
3488 3489 3490
	} 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 已提交
3491 3492 3493 3494
		tp->tlp_high_seq = 0;
	}
}

3495 3496 3497 3498 3499 3500 3501 3502
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);
}

3503 3504 3505 3506 3507 3508 3509 3510 3511 3512 3513 3514 3515 3516 3517 3518 3519 3520 3521 3522 3523
/* 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);
}

3524 3525 3526
/* Returns the number of packets newly acked or sacked by the current ACK */
static u32 tcp_newly_delivered(struct sock *sk, u32 prior_delivered, int flag)
{
3527
	const struct net *net = sock_net(sk);
3528 3529 3530 3531
	struct tcp_sock *tp = tcp_sk(sk);
	u32 delivered;

	delivered = tp->delivered - prior_delivered;
3532 3533
	NET_ADD_STATS(net, LINUX_MIB_TCPDELIVERED, delivered);
	if (flag & FLAG_ECE) {
3534
		tp->delivered_ce += delivered;
3535 3536
		NET_ADD_STATS(net, LINUX_MIB_TCPDELIVEREDCE, delivered);
	}
3537 3538 3539
	return delivered;
}

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

3558
	sack_state.first_sackt = 0;
3559
	sack_state.rate = &rs;
L
Linus Torvalds 已提交
3560

3561 3562
	/* We very likely will need to access rtx queue. */
	prefetch(sk->tcp_rtx_queue.rb_node);
3563

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

3577 3578 3579 3580 3581 3582
	/* 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;

3583
	if (after(ack, prior_snd_una)) {
3584
		flag |= FLAG_SND_UNA_ADVANCED;
3585
		icsk->icsk_retransmits = 0;
I
Ilya Lesokhin 已提交
3586 3587 3588 3589 3590 3591

#if IS_ENABLED(CONFIG_TLS_DEVICE)
		if (static_branch_unlikely(&clean_acked_data_enabled))
			if (icsk->icsk_clean_acked)
				icsk->icsk_clean_acked(sk, ack);
#endif
3592
	}
3593

E
Eric Dumazet 已提交
3594
	prior_fack = tcp_is_sack(tp) ? tcp_highest_sack_seq(tp) : tp->snd_una;
3595
	rs.prior_in_flight = tcp_packets_in_flight(tp);
3596

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

3603 3604 3605 3606 3607 3608 3609 3610 3611 3612 3613 3614 3615
	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 {
3616
		u32 ack_ev_flags = CA_ACK_SLOWPATH;
L
Linus Torvalds 已提交
3617

3618 3619 3620 3621
		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 已提交
3622

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

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

3629 3630 3631 3632 3633 3634 3635
		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 已提交
3636

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

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

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

3652
	tcp_rack_update_reo_wnd(sk, &rs);
3653

3654 3655 3656 3657 3658 3659
	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);

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

3666 3667
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
		sk_dst_confirm(sk);
N
Nandita Dukkipati 已提交
3668

3669
	delivered = tcp_newly_delivered(sk, delivered, flag);
3670
	lost = tp->lost - lost;			/* freshly marked lost */
3671
	rs.is_ack_delayed = !!(flag & FLAG_ACK_MAYBE_DELAYED);
3672
	tcp_rate_gen(sk, delivered, lost, is_sack_reneg, sack_state.rate);
3673
	tcp_cong_control(sk, ack, delivered, flag, sack_state.rate);
3674
	tcp_xmit_recovery(sk, rexmit);
L
Linus Torvalds 已提交
3675 3676 3677
	return 1;

no_queue:
3678
	/* If data was DSACKed, see if we can undo a cwnd reduction. */
3679
	if (flag & FLAG_DSACKING_ACK) {
3680 3681
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
3682 3683
		tcp_newly_delivered(sk, delivered, flag);
	}
L
Linus Torvalds 已提交
3684 3685 3686 3687
	/* 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.
	 */
3688
	tcp_ack_probe(sk);
N
Nandita Dukkipati 已提交
3689 3690 3691

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

3694 3695 3696 3697
invalid_ack:
	SOCK_DEBUG(sk, "Ack %u after %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
	return -1;

L
Linus Torvalds 已提交
3698
old_ack:
3699 3700 3701
	/* 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.
	 */
3702
	if (TCP_SKB_CB(skb)->sacked) {
Y
Yuchung Cheng 已提交
3703
		flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
3704
						&sack_state);
3705 3706
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
3707
		tcp_newly_delivered(sk, delivered, flag);
3708
		tcp_xmit_recovery(sk, rexmit);
3709
	}
L
Linus Torvalds 已提交
3710

3711
	SOCK_DEBUG(sk, "Ack %u before %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
L
Linus Torvalds 已提交
3712 3713 3714
	return 0;
}

3715 3716 3717 3718 3719 3720 3721 3722 3723 3724 3725 3726 3727 3728 3729 3730 3731
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;
}

3732 3733 3734 3735 3736 3737 3738 3739 3740 3741 3742 3743 3744 3745 3746
static void smc_parse_options(const struct tcphdr *th,
			      struct tcp_options_received *opt_rx,
			      const unsigned char *ptr,
			      int opsize)
{
#if IS_ENABLED(CONFIG_SMC)
	if (static_branch_unlikely(&tcp_have_smc)) {
		if (th->syn && !(opsize & 1) &&
		    opsize >= TCPOLEN_EXP_SMC_BASE &&
		    get_unaligned_be32(ptr) == TCPOPT_SMC_MAGIC)
			opt_rx->smc_ok = 1;
	}
#endif
}

L
Linus Torvalds 已提交
3747 3748 3749 3750
/* 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.
 */
3751 3752
void tcp_parse_options(const struct net *net,
		       const struct sk_buff *skb,
C
Christoph Paasch 已提交
3753
		       struct tcp_options_received *opt_rx, int estab,
Y
Yuchung Cheng 已提交
3754
		       struct tcp_fastopen_cookie *foc)
L
Linus Torvalds 已提交
3755
{
3756 3757
	const unsigned char *ptr;
	const struct tcphdr *th = tcp_hdr(skb);
3758
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3759

3760
	ptr = (const unsigned char *)(th + 1);
L
Linus Torvalds 已提交
3761 3762
	opt_rx->saw_tstamp = 0;

S
Stephen Hemminger 已提交
3763
	while (length > 0) {
3764
		int opcode = *ptr++;
L
Linus Torvalds 已提交
3765 3766 3767
		int opsize;

		switch (opcode) {
3768 3769 3770 3771 3772 3773 3774 3775
		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 已提交
3776
				return;
3777 3778 3779 3780 3781
			if (opsize > length)
				return;	/* don't parse partial options */
			switch (opcode) {
			case TCPOPT_MSS:
				if (opsize == TCPOLEN_MSS && th->syn && !estab) {
3782
					u16 in_mss = get_unaligned_be16(ptr);
3783 3784 3785 3786 3787
					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 已提交
3788
					}
3789 3790 3791 3792
				}
				break;
			case TCPOPT_WINDOW:
				if (opsize == TCPOLEN_WINDOW && th->syn &&
3793
				    !estab && net->ipv4.sysctl_tcp_window_scaling) {
3794 3795
					__u8 snd_wscale = *(__u8 *)ptr;
					opt_rx->wscale_ok = 1;
3796 3797
					if (snd_wscale > TCP_MAX_WSCALE) {
						net_info_ratelimited("%s: Illegal window scaling value %d > %u received\n",
3798
								     __func__,
3799 3800 3801
								     snd_wscale,
								     TCP_MAX_WSCALE);
						snd_wscale = TCP_MAX_WSCALE;
L
Linus Torvalds 已提交
3802
					}
3803 3804 3805 3806 3807 3808
					opt_rx->snd_wscale = snd_wscale;
				}
				break;
			case TCPOPT_TIMESTAMP:
				if ((opsize == TCPOLEN_TIMESTAMP) &&
				    ((estab && opt_rx->tstamp_ok) ||
3809
				     (!estab && net->ipv4.sysctl_tcp_timestamps))) {
3810
					opt_rx->saw_tstamp = 1;
3811 3812
					opt_rx->rcv_tsval = get_unaligned_be32(ptr);
					opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
3813 3814 3815 3816
				}
				break;
			case TCPOPT_SACK_PERM:
				if (opsize == TCPOLEN_SACK_PERM && th->syn &&
E
Eric Dumazet 已提交
3817
				    !estab && net->ipv4.sysctl_tcp_sack) {
3818
					opt_rx->sack_ok = TCP_SACK_SEEN;
3819 3820 3821
					tcp_sack_reset(opt_rx);
				}
				break;
L
Linus Torvalds 已提交
3822

3823 3824 3825 3826 3827 3828 3829
			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;
3830
#ifdef CONFIG_TCP_MD5SIG
3831 3832 3833 3834 3835 3836
			case TCPOPT_MD5SIG:
				/*
				 * The MD5 Hash has already been
				 * checked (see tcp_v{4,6}_do_rcv()).
				 */
				break;
3837
#endif
3838 3839 3840 3841 3842 3843
			case TCPOPT_FASTOPEN:
				tcp_parse_fastopen_option(
					opsize - TCPOLEN_FASTOPEN_BASE,
					ptr, th->syn, foc, false);
				break;

Y
Yuchung Cheng 已提交
3844 3845
			case TCPOPT_EXP:
				/* Fast Open option shares code 254 using a
3846
				 * 16 bits magic number.
Y
Yuchung Cheng 已提交
3847
				 */
3848 3849 3850 3851 3852 3853
				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);
3854 3855 3856
				else
					smc_parse_options(th, opt_rx, ptr,
							  opsize);
Y
Yuchung Cheng 已提交
3857 3858 3859
				break;

			}
3860 3861
			ptr += opsize-2;
			length -= opsize;
3862
		}
L
Linus Torvalds 已提交
3863 3864
	}
}
E
Eric Dumazet 已提交
3865
EXPORT_SYMBOL(tcp_parse_options);
L
Linus Torvalds 已提交
3866

E
Eric Dumazet 已提交
3867
static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
3868
{
3869
	const __be32 *ptr = (const __be32 *)(th + 1);
3870 3871 3872 3873 3874 3875 3876

	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;
3877 3878 3879 3880
		if (*ptr)
			tp->rx_opt.rcv_tsecr = ntohl(*ptr) - tp->tsoffset;
		else
			tp->rx_opt.rcv_tsecr = 0;
E
Eric Dumazet 已提交
3881
		return true;
3882
	}
E
Eric Dumazet 已提交
3883
	return false;
3884 3885
}

L
Linus Torvalds 已提交
3886 3887 3888
/* Fast parse options. This hopes to only see timestamps.
 * If it is wrong it falls back on tcp_parse_options().
 */
3889 3890
static bool tcp_fast_parse_options(const struct net *net,
				   const struct sk_buff *skb,
C
Christoph Paasch 已提交
3891
				   const struct tcphdr *th, struct tcp_sock *tp)
L
Linus Torvalds 已提交
3892
{
3893 3894 3895 3896
	/* 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 已提交
3897
		tp->rx_opt.saw_tstamp = 0;
E
Eric Dumazet 已提交
3898
		return false;
L
Linus Torvalds 已提交
3899
	} else if (tp->rx_opt.tstamp_ok &&
3900
		   th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
3901
		if (tcp_parse_aligned_timestamp(tp, th))
E
Eric Dumazet 已提交
3902
			return true;
L
Linus Torvalds 已提交
3903
	}
3904

3905
	tcp_parse_options(net, skb, &tp->rx_opt, 1, NULL);
3906
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
3907 3908
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;

E
Eric Dumazet 已提交
3909
	return true;
L
Linus Torvalds 已提交
3910 3911
}

3912 3913 3914 3915
#ifdef CONFIG_TCP_MD5SIG
/*
 * Parse MD5 Signature option
 */
3916
const u8 *tcp_parse_md5sig_option(const struct tcphdr *th)
3917
{
3918 3919
	int length = (th->doff << 2) - sizeof(*th);
	const u8 *ptr = (const u8 *)(th + 1);
3920

J
Jann Horn 已提交
3921 3922
	/* If not enough data remaining, we can short cut */
	while (length >= TCPOLEN_MD5SIG) {
3923 3924 3925
		int opcode = *ptr++;
		int opsize;

W
Weilong Chen 已提交
3926
		switch (opcode) {
3927 3928 3929 3930 3931 3932 3933 3934 3935 3936
		case TCPOPT_EOL:
			return NULL;
		case TCPOPT_NOP:
			length--;
			continue;
		default:
			opsize = *ptr++;
			if (opsize < 2 || opsize > length)
				return NULL;
			if (opcode == TCPOPT_MD5SIG)
3937
				return opsize == TCPOLEN_MD5SIG ? ptr : NULL;
3938 3939 3940 3941 3942 3943
		}
		ptr += opsize - 2;
		length -= opsize;
	}
	return NULL;
}
E
Eric Dumazet 已提交
3944
EXPORT_SYMBOL(tcp_parse_md5sig_option);
3945 3946
#endif

L
Linus Torvalds 已提交
3947 3948 3949 3950 3951 3952 3953 3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969
/* 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) ]
 */

3970
static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
3971
{
3972 3973
	const struct tcp_sock *tp = tcp_sk(sk);
	const struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986
	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. */
3987
		(s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (inet_csk(sk)->icsk_rto * 1024) / HZ);
L
Linus Torvalds 已提交
3988 3989
}

3990
static inline bool tcp_paws_discard(const struct sock *sk,
3991
				   const struct sk_buff *skb)
L
Linus Torvalds 已提交
3992
{
3993
	const struct tcp_sock *tp = tcp_sk(sk);
I
Ilpo Järvinen 已提交
3994 3995 3996

	return !tcp_paws_check(&tp->rx_opt, TCP_PAWS_WINDOW) &&
	       !tcp_disordered_ack(sk, skb);
L
Linus Torvalds 已提交
3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008 4009 4010 4011
}

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

4012
static inline bool tcp_sequence(const struct tcp_sock *tp, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4013 4014 4015 4016 4017 4018
{
	return	!before(end_seq, tp->rcv_wup) &&
		!after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

/* When we get a reset we do this. */
4019
void tcp_reset(struct sock *sk)
L
Linus Torvalds 已提交
4020
{
4021 4022
	trace_tcp_receive_reset(sk);

L
Linus Torvalds 已提交
4023 4024
	/* We want the right error as BSD sees it (and indeed as we do). */
	switch (sk->sk_state) {
4025 4026 4027 4028 4029 4030 4031 4032 4033 4034
	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 已提交
4035
	}
T
Tom Marshall 已提交
4036 4037
	/* This barrier is coupled with smp_rmb() in tcp_poll() */
	smp_wmb();
L
Linus Torvalds 已提交
4038

4039
	tcp_write_queue_purge(sk);
4040 4041
	tcp_done(sk);

L
Linus Torvalds 已提交
4042 4043 4044 4045 4046 4047 4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059
	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.
 */
4060
void tcp_fin(struct sock *sk)
L
Linus Torvalds 已提交
4061 4062 4063
{
	struct tcp_sock *tp = tcp_sk(sk);

4064
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4065 4066 4067 4068 4069

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

	switch (sk->sk_state) {
4070 4071 4072 4073
	case TCP_SYN_RECV:
	case TCP_ESTABLISHED:
		/* Move to CLOSE_WAIT */
		tcp_set_state(sk, TCP_CLOSE_WAIT);
4074
		inet_csk(sk)->icsk_ack.pingpong = 1;
4075
		break;
L
Linus Torvalds 已提交
4076

4077 4078 4079 4080 4081 4082 4083 4084 4085
	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 已提交
4086

4087 4088 4089 4090 4091 4092 4093 4094 4095 4096 4097 4098 4099 4100 4101 4102 4103
	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 已提交
4104
		pr_err("%s: Impossible, sk->sk_state=%d\n",
4105
		       __func__, sk->sk_state);
4106
		break;
4107
	}
L
Linus Torvalds 已提交
4108 4109 4110 4111

	/* It _is_ possible, that we have something out-of-order _after_ FIN.
	 * Probably, we should reset in this case. For now drop them.
	 */
4112
	skb_rbtree_purge(&tp->out_of_order_queue);
4113
	if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4114
		tcp_sack_reset(&tp->rx_opt);
4115
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4116 4117 4118 4119 4120 4121 4122

	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)
4123
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP);
L
Linus Torvalds 已提交
4124
		else
4125
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
L
Linus Torvalds 已提交
4126 4127 4128
	}
}

E
Eric Dumazet 已提交
4129
static inline bool tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
4130
				  u32 end_seq)
L
Linus Torvalds 已提交
4131 4132 4133 4134 4135 4136
{
	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 已提交
4137
		return true;
L
Linus Torvalds 已提交
4138
	}
E
Eric Dumazet 已提交
4139
	return false;
L
Linus Torvalds 已提交
4140 4141
}

4142
static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4143
{
4144 4145
	struct tcp_sock *tp = tcp_sk(sk);

E
Eric Dumazet 已提交
4146
	if (tcp_is_sack(tp) && sock_net(sk)->ipv4.sysctl_tcp_dsack) {
4147 4148
		int mib_idx;

L
Linus Torvalds 已提交
4149
		if (before(seq, tp->rcv_nxt))
4150
			mib_idx = LINUX_MIB_TCPDSACKOLDSENT;
L
Linus Torvalds 已提交
4151
		else
4152 4153
			mib_idx = LINUX_MIB_TCPDSACKOFOSENT;

4154
		NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
4155 4156 4157 4158 4159 4160 4161

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

4162
static void tcp_dsack_extend(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4163
{
4164 4165
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
4166
	if (!tp->rx_opt.dsack)
4167
		tcp_dsack_set(sk, seq, end_seq);
L
Linus Torvalds 已提交
4168 4169 4170 4171
	else
		tcp_sack_extend(tp->duplicate_sack, seq, end_seq);
}

4172
static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
4173 4174 4175 4176 4177
{
	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)) {
4178
		NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4179
		tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4180

E
Eric Dumazet 已提交
4181
		if (tcp_is_sack(tp) && sock_net(sk)->ipv4.sysctl_tcp_dsack) {
L
Linus Torvalds 已提交
4182 4183 4184 4185
			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;
4186
			tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, end_seq);
L
Linus Torvalds 已提交
4187 4188 4189 4190 4191 4192 4193 4194 4195 4196 4197 4198 4199
		}
	}

	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];
4200
	struct tcp_sack_block *swalk = sp + 1;
L
Linus Torvalds 已提交
4201 4202 4203 4204

	/* See if the recent change to the first SACK eats into
	 * or hits the sequence space of other SACK blocks, if so coalesce.
	 */
4205
	for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;) {
L
Linus Torvalds 已提交
4206 4207 4208 4209 4210 4211 4212
		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--;
4213 4214
			for (i = this_sack; i < tp->rx_opt.num_sacks; i++)
				sp[i] = sp[i + 1];
L
Linus Torvalds 已提交
4215 4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230
			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;

4231
	for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
L
Linus Torvalds 已提交
4232 4233
		if (tcp_sack_extend(sp, seq, end_seq)) {
			/* Rotate this_sack to the first one. */
4234
			for (; this_sack > 0; this_sack--, sp--)
4235
				swap(*sp, *(sp - 1));
L
Linus Torvalds 已提交
4236 4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247
			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.
	 */
4248
	if (this_sack >= TCP_NUM_SACKS) {
L
Linus Torvalds 已提交
4249 4250 4251 4252
		this_sack--;
		tp->rx_opt.num_sacks--;
		sp--;
	}
S
Stephen Hemminger 已提交
4253
	for (; this_sack > 0; this_sack--, sp--)
4254
		*sp = *(sp - 1);
L
Linus Torvalds 已提交
4255 4256 4257 4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269 4270 4271

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. */
4272
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4273 4274 4275 4276
		tp->rx_opt.num_sacks = 0;
		return;
	}

4277
	for (this_sack = 0; this_sack < num_sacks;) {
L
Linus Torvalds 已提交
4278 4279 4280 4281 4282
		/* 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! */
4283
			WARN_ON(before(tp->rcv_nxt, sp->end_seq));
L
Linus Torvalds 已提交
4284 4285

			/* Zap this SACK, by moving forward any other SACKS. */
W
Weilong Chen 已提交
4286
			for (i = this_sack+1; i < num_sacks; i++)
L
Linus Torvalds 已提交
4287 4288 4289 4290 4291 4292 4293
				tp->selective_acks[i-1] = tp->selective_acks[i];
			num_sacks--;
			continue;
		}
		this_sack++;
		sp++;
	}
4294
	tp->rx_opt.num_sacks = num_sacks;
L
Linus Torvalds 已提交
4295 4296
}

4297 4298 4299
/**
 * tcp_try_coalesce - try to merge skb to prior one
 * @sk: socket
4300
 * @dest: destination queue
4301 4302 4303 4304 4305 4306 4307 4308 4309 4310 4311 4312 4313 4314 4315 4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328
 * @to: prior buffer
 * @from: buffer to add in queue
 * @fragstolen: pointer to boolean
 *
 * Before queueing skb @from after @to, try to merge them
 * to reduce overall memory use and queue lengths, if cost is small.
 * Packets in ofo or receive queues can stay a long time.
 * Better try to coalesce them right now to avoid future collapses.
 * Returns true if caller should free @from instead of queueing it
 */
static bool tcp_try_coalesce(struct sock *sk,
			     struct sk_buff *to,
			     struct sk_buff *from,
			     bool *fragstolen)
{
	int delta;

	*fragstolen = false;

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

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

	atomic_add(delta, &sk->sk_rmem_alloc);
	sk_mem_charge(sk, delta);
4329
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
4330 4331 4332
	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;
4333 4334 4335

	if (TCP_SKB_CB(from)->has_rxtstamp) {
		TCP_SKB_CB(to)->has_rxtstamp = true;
E
Eric Dumazet 已提交
4336
		to->tstamp = from->tstamp;
4337 4338
	}

4339 4340 4341
	return true;
}

4342 4343 4344 4345 4346 4347
static void tcp_drop(struct sock *sk, struct sk_buff *skb)
{
	sk_drops_add(sk, skb);
	__kfree_skb(skb);
}

L
Linus Torvalds 已提交
4348 4349 4350 4351 4352 4353 4354
/* 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;
4355
	bool fin, fragstolen, eaten;
4356
	struct sk_buff *skb, *tail;
4357
	struct rb_node *p;
L
Linus Torvalds 已提交
4358

4359 4360
	p = rb_first(&tp->out_of_order_queue);
	while (p) {
4361
		skb = rb_to_skb(p);
L
Linus Torvalds 已提交
4362 4363 4364 4365 4366 4367 4368
		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;
4369
			tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);
L
Linus Torvalds 已提交
4370
		}
4371 4372
		p = rb_next(p);
		rb_erase(&skb->rbnode, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
4373

4374
		if (unlikely(!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))) {
4375
			SOCK_DEBUG(sk, "ofo packet was already received\n");
4376
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4377 4378 4379 4380 4381 4382
			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);

4383
		tail = skb_peek_tail(&sk->sk_receive_queue);
E
Eric Dumazet 已提交
4384
		eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
4385
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
4386
		fin = TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN;
4387 4388
		if (!eaten)
			__skb_queue_tail(&sk->sk_receive_queue, skb);
4389
		else
4390
			kfree_skb_partial(skb, fragstolen);
4391 4392 4393 4394 4395 4396 4397 4398

		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 已提交
4399 4400 4401
	}
}

E
Eric Dumazet 已提交
4402
static bool tcp_prune_ofo_queue(struct sock *sk);
L
Linus Torvalds 已提交
4403 4404
static int tcp_prune_queue(struct sock *sk);

4405 4406
static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb,
				 unsigned int size)
4407 4408
{
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
4409
	    !sk_rmem_schedule(sk, skb, size)) {
4410 4411 4412 4413

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

4414
		while (!sk_rmem_schedule(sk, skb, size)) {
4415 4416
			if (!tcp_prune_ofo_queue(sk))
				return -1;
4417 4418 4419 4420 4421
		}
	}
	return 0;
}

E
Eric Dumazet 已提交
4422 4423 4424
static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
4425
	struct rb_node **p, *parent;
E
Eric Dumazet 已提交
4426 4427
	struct sk_buff *skb1;
	u32 seq, end_seq;
4428
	bool fragstolen;
E
Eric Dumazet 已提交
4429

4430
	tcp_ecn_check_ce(tp, skb);
E
Eric Dumazet 已提交
4431

4432
	if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
4433
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
4434
		tcp_drop(sk, skb);
E
Eric Dumazet 已提交
4435 4436 4437
		return;
	}

4438 4439
	/* Disable header prediction. */
	tp->pred_flags = 0;
E
Eric Dumazet 已提交
4440 4441
	inet_csk_schedule_ack(sk);

4442
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
4443 4444
	seq = TCP_SKB_CB(skb)->seq;
	end_seq = TCP_SKB_CB(skb)->end_seq;
E
Eric Dumazet 已提交
4445
	SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
4446
		   tp->rcv_nxt, seq, end_seq);
E
Eric Dumazet 已提交
4447

4448 4449
	p = &tp->out_of_order_queue.rb_node;
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
E
Eric Dumazet 已提交
4450 4451 4452
		/* Initial out of order segment, build 1 SACK. */
		if (tcp_is_sack(tp)) {
			tp->rx_opt.num_sacks = 1;
4453 4454
			tp->selective_acks[0].start_seq = seq;
			tp->selective_acks[0].end_seq = end_seq;
E
Eric Dumazet 已提交
4455
		}
4456 4457 4458
		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 已提交
4459 4460 4461
		goto end;
	}

4462 4463 4464
	/* 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.
	 */
E
Eric Dumazet 已提交
4465
	if (tcp_try_coalesce(sk, tp->ooo_last_skb,
4466
			     skb, &fragstolen)) {
4467 4468 4469 4470 4471 4472
coalesce_done:
		tcp_grow_window(sk, skb);
		kfree_skb_partial(skb, fragstolen);
		skb = NULL;
		goto add_sack;
	}
4473 4474 4475 4476 4477 4478
	/* 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;
	}
4479 4480 4481 4482 4483

	/* Find place to insert this segment. Handle overlaps on the way. */
	parent = NULL;
	while (*p) {
		parent = *p;
4484
		skb1 = rb_to_skb(parent);
4485 4486 4487
		if (before(seq, TCP_SKB_CB(skb1)->seq)) {
			p = &parent->rb_left;
			continue;
E
Eric Dumazet 已提交
4488
		}
4489 4490 4491 4492 4493 4494 4495 4496 4497 4498 4499 4500 4501 4502 4503 4504 4505 4506 4507 4508 4509 4510 4511 4512 4513
		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);
4514
				goto merge_right;
4515
			}
E
Eric Dumazet 已提交
4516
		} else if (tcp_try_coalesce(sk, skb1,
4517
					    skb, &fragstolen)) {
4518
			goto coalesce_done;
E
Eric Dumazet 已提交
4519
		}
4520
		p = &parent->rb_right;
E
Eric Dumazet 已提交
4521
	}
4522
insert:
4523 4524 4525
	/* 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 已提交
4526

4527
merge_right:
4528
	/* Remove other segments covered by skb. */
4529
	while ((skb1 = skb_rb_next(skb)) != NULL) {
E
Eric Dumazet 已提交
4530 4531 4532 4533 4534 4535 4536
		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;
		}
4537
		rb_erase(&skb1->rbnode, &tp->out_of_order_queue);
E
Eric Dumazet 已提交
4538 4539
		tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
				 TCP_SKB_CB(skb1)->end_seq);
4540
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
4541
		tcp_drop(sk, skb1);
E
Eric Dumazet 已提交
4542
	}
4543
	/* If there is no skb after us, we are the last_skb ! */
4544
	if (!skb1)
4545
		tp->ooo_last_skb = skb;
E
Eric Dumazet 已提交
4546 4547 4548 4549 4550

add_sack:
	if (tcp_is_sack(tp))
		tcp_sack_new_ofo_skb(sk, seq, end_seq);
end:
4551 4552
	if (skb) {
		tcp_grow_window(sk, skb);
4553
		skb_condense(skb);
E
Eric Dumazet 已提交
4554
		skb_set_owner_r(skb, sk);
4555
	}
E
Eric Dumazet 已提交
4556 4557
}

4558
static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen,
4559 4560 4561 4562 4563 4564 4565
		  bool *fragstolen)
{
	int eaten;
	struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue);

	__skb_pull(skb, hdrlen);
	eaten = (tail &&
E
Eric Dumazet 已提交
4566
		 tcp_try_coalesce(sk, tail,
4567
				  skb, fragstolen)) ? 1 : 0;
4568
	tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
4569 4570 4571 4572 4573 4574
	if (!eaten) {
		__skb_queue_tail(&sk->sk_receive_queue, skb);
		skb_set_owner_r(skb, sk);
	}
	return eaten;
}
E
Eric Dumazet 已提交
4575

4576 4577
int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size)
{
4578
	struct sk_buff *skb;
4579 4580
	int err = -ENOMEM;
	int data_len = 0;
4581 4582
	bool fragstolen;

4583 4584 4585
	if (size == 0)
		return 0;

4586 4587 4588 4589 4590 4591 4592 4593 4594
	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);
4595 4596 4597
	if (!skb)
		goto err;

4598 4599 4600 4601
	skb_put(skb, size - data_len);
	skb->data_len = data_len;
	skb->len = size;

4602
	if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
4603 4604
		goto err_free;

4605 4606
	err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
	if (err)
4607 4608 4609 4610 4611 4612
		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;

4613
	if (tcp_queue_rcv(sk, skb, 0, &fragstolen)) {
4614 4615 4616 4617 4618 4619 4620 4621
		WARN_ON_ONCE(fragstolen); /* should not happen */
		__kfree_skb(skb);
	}
	return size;

err_free:
	kfree_skb(skb);
err:
4622 4623
	return err;

4624 4625
}

4626 4627 4628 4629 4630 4631 4632 4633 4634 4635 4636
void tcp_data_ready(struct sock *sk)
{
	const struct tcp_sock *tp = tcp_sk(sk);
	int avail = tp->rcv_nxt - tp->copied_seq;

	if (avail < sk->sk_rcvlowat && !sock_flag(sk, SOCK_DONE))
		return;

	sk->sk_data_ready(sk);
}

L
Linus Torvalds 已提交
4637 4638 4639
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
E
Eric Dumazet 已提交
4640 4641
	bool fragstolen;
	int eaten;
L
Linus Torvalds 已提交
4642

4643 4644 4645 4646
	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
		__kfree_skb(skb);
		return;
	}
E
Eric Dumazet 已提交
4647
	skb_dst_drop(skb);
4648
	__skb_pull(skb, tcp_hdr(skb)->doff * 4);
L
Linus Torvalds 已提交
4649

4650
	tcp_ecn_accept_cwr(tp, skb);
L
Linus Torvalds 已提交
4651

4652
	tp->rx_opt.dsack = 0;
L
Linus Torvalds 已提交
4653 4654 4655 4656 4657 4658 4659 4660 4661 4662 4663

	/*  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 已提交
4664 4665 4666 4667 4668
		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;

4669
		eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);
4670
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
S
Stephen Hemminger 已提交
4671
		if (skb->len)
4672
			tcp_event_data_recv(sk, skb);
4673
		if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
4674
			tcp_fin(sk);
L
Linus Torvalds 已提交
4675

4676
		if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4677 4678 4679 4680 4681
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
4682
			if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4683
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
4684 4685 4686 4687 4688
		}

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

4689 4690
		tcp_fast_path_check(sk);

4691 4692
		if (eaten > 0)
			kfree_skb_partial(skb, fragstolen);
4693
		if (!sock_flag(sk, SOCK_DEAD))
4694
			tcp_data_ready(sk);
L
Linus Torvalds 已提交
4695 4696 4697 4698 4699
		return;
	}

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

out_of_window:
4704 4705
		tcp_enter_quickack_mode(sk);
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4706
drop:
4707
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4708 4709 4710 4711 4712 4713 4714
		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;

4715
	tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4716 4717 4718 4719 4720 4721 4722

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

4723
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
4724

L
Linus Torvalds 已提交
4725 4726 4727 4728 4729 4730 4731 4732
		/* 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 已提交
4733
	tcp_data_queue_ofo(sk, skb);
L
Linus Torvalds 已提交
4734 4735
}

4736 4737 4738 4739 4740
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;

4741
	return skb_rb_next(skb);
4742 4743
}

4744
static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
4745 4746
					struct sk_buff_head *list,
					struct rb_root *root)
4747
{
4748
	struct sk_buff *next = tcp_skb_next(skb, list);
4749

4750 4751 4752 4753
	if (list)
		__skb_unlink(skb, list);
	else
		rb_erase(&skb->rbnode, root);
4754 4755

	__kfree_skb(skb);
4756
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
4757 4758 4759 4760

	return next;
}

4761
/* Insert skb into rb tree, ordered by TCP_SKB_CB(skb)->seq */
4762
void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb)
4763 4764 4765 4766 4767 4768 4769
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct sk_buff *skb1;

	while (*p) {
		parent = *p;
4770
		skb1 = rb_to_skb(parent);
4771 4772 4773 4774 4775 4776 4777 4778 4779
		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 已提交
4780 4781
/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
4782
 *
4783
 * If tail is NULL, this means until the end of the queue.
4784
 *
L
Linus Torvalds 已提交
4785 4786 4787 4788
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
4789 4790
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 已提交
4791
{
4792 4793
	struct sk_buff *skb = head, *n;
	struct sk_buff_head tmp;
4794
	bool end_of_skbs;
L
Linus Torvalds 已提交
4795

S
Stephen Hemminger 已提交
4796
	/* First, check that queue is collapsible and find
4797 4798
	 * the point where collapsing can be useful.
	 */
4799
restart:
4800 4801 4802
	for (end_of_skbs = true; skb != NULL && skb != tail; skb = n) {
		n = tcp_skb_next(skb, list);

L
Linus Torvalds 已提交
4803 4804
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
4805
			skb = tcp_collapse_one(sk, skb, list, root);
4806 4807 4808
			if (!skb)
				break;
			goto restart;
L
Linus Torvalds 已提交
4809 4810 4811 4812 4813 4814 4815
		}

		/* The first skb to collapse is:
		 * - not SYN/FIN and
		 * - bloated or contains data before "start" or
		 *   overlaps to the next one.
		 */
4816
		if (!(TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)) &&
4817
		    (tcp_win_from_space(sk, skb->truesize) > skb->len ||
4818 4819
		     before(TCP_SKB_CB(skb)->seq, start))) {
			end_of_skbs = false;
L
Linus Torvalds 已提交
4820
			break;
4821 4822
		}

4823 4824 4825 4826
		if (n && n != tail &&
		    TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(n)->seq) {
			end_of_skbs = false;
			break;
4827
		}
L
Linus Torvalds 已提交
4828 4829 4830 4831

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

4836 4837
	__skb_queue_head_init(&tmp);

L
Linus Torvalds 已提交
4838
	while (before(start, end)) {
4839
		int copy = min_t(int, SKB_MAX_ORDER(0, 0), end - start);
L
Linus Torvalds 已提交
4840 4841
		struct sk_buff *nskb;

4842
		nskb = alloc_skb(copy, GFP_ATOMIC);
L
Linus Torvalds 已提交
4843
		if (!nskb)
4844
			break;
4845

L
Linus Torvalds 已提交
4846 4847
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
4848 4849 4850 4851
		if (list)
			__skb_queue_before(list, skb, nskb);
		else
			__skb_queue_tail(&tmp, nskb); /* defer rbtree insertion */
4852
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4853 4854 4855 4856 4857 4858

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

4859
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4860 4861 4862 4863 4864 4865 4866 4867 4868
			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)) {
4869
				skb = tcp_collapse_one(sk, skb, list, root);
4870 4871
				if (!skb ||
				    skb == tail ||
4872
				    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
4873
					goto end;
L
Linus Torvalds 已提交
4874 4875 4876
			}
		}
	}
4877 4878 4879
end:
	skb_queue_walk_safe(&tmp, skb, n)
		tcp_rbtree_insert(root, skb);
L
Linus Torvalds 已提交
4880 4881 4882 4883 4884 4885 4886 4887
}

/* 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);
4888
	struct sk_buff *skb, *head;
L
Linus Torvalds 已提交
4889 4890
	u32 start, end;

4891
	skb = skb_rb_first(&tp->out_of_order_queue);
4892 4893
new_range:
	if (!skb) {
4894
		tp->ooo_last_skb = skb_rb_last(&tp->out_of_order_queue);
L
Linus Torvalds 已提交
4895
		return;
4896
	}
L
Linus Torvalds 已提交
4897 4898
	start = TCP_SKB_CB(skb)->seq;
	end = TCP_SKB_CB(skb)->end_seq;
4899

4900
	for (head = skb;;) {
4901
		skb = skb_rb_next(skb);
L
Linus Torvalds 已提交
4902

4903 4904 4905
		/* Range is terminated when we see a gap or when
		 * we are at the queue end.
		 */
4906
		if (!skb ||
L
Linus Torvalds 已提交
4907 4908
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
4909
			tcp_collapse(sk, NULL, &tp->out_of_order_queue,
D
David S. Miller 已提交
4910
				     head, skb, start, end);
4911 4912 4913 4914
			goto new_range;
		}

		if (unlikely(before(TCP_SKB_CB(skb)->seq, start)))
L
Linus Torvalds 已提交
4915
			start = TCP_SKB_CB(skb)->seq;
4916
		if (after(TCP_SKB_CB(skb)->end_seq, end))
L
Linus Torvalds 已提交
4917 4918 4919 4920
			end = TCP_SKB_CB(skb)->end_seq;
	}
}

4921
/*
4922 4923 4924 4925 4926 4927 4928 4929
 * 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.
4930
 */
E
Eric Dumazet 已提交
4931
static bool tcp_prune_ofo_queue(struct sock *sk)
4932 4933
{
	struct tcp_sock *tp = tcp_sk(sk);
4934
	struct rb_node *node, *prev;
4935

4936
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4937
		return false;
4938

4939
	NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
4940 4941 4942 4943
	node = &tp->ooo_last_skb->rbnode;
	do {
		prev = rb_prev(node);
		rb_erase(node, &tp->out_of_order_queue);
4944
		tcp_drop(sk, rb_to_skb(node));
4945
		sk_mem_reclaim(sk);
4946 4947 4948
		if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
		    !tcp_under_memory_pressure(sk))
			break;
4949 4950
		node = prev;
	} while (node);
4951
	tp->ooo_last_skb = rb_to_skb(prev);
4952 4953 4954 4955 4956 4957 4958 4959 4960

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

L
Linus Torvalds 已提交
4963 4964 4965 4966 4967 4968 4969 4970 4971
/* 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)
{
4972
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
4973 4974 4975

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

4976
	NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
L
Linus Torvalds 已提交
4977 4978

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
4979
		tcp_clamp_window(sk);
4980
	else if (tcp_under_memory_pressure(sk))
L
Linus Torvalds 已提交
4981 4982 4983
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

	tcp_collapse_ofo_queue(sk);
4984
	if (!skb_queue_empty(&sk->sk_receive_queue))
4985
		tcp_collapse(sk, &sk->sk_receive_queue, NULL,
4986 4987 4988
			     skb_peek(&sk->sk_receive_queue),
			     NULL,
			     tp->copied_seq, tp->rcv_nxt);
4989
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4990 4991 4992 4993 4994 4995 4996

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

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

4997
	tcp_prune_ofo_queue(sk);
L
Linus Torvalds 已提交
4998 4999 5000 5001 5002 5003 5004 5005

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

	/* Massive buffer overcommit. */
5009
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
5010 5011 5012
	return -1;
}

E
Eric Dumazet 已提交
5013
static bool tcp_should_expand_sndbuf(const struct sock *sk)
5014
{
5015
	const struct tcp_sock *tp = tcp_sk(sk);
5016

5017 5018 5019 5020
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
E
Eric Dumazet 已提交
5021
		return false;
5022 5023

	/* If we are under global TCP memory pressure, do not expand.  */
5024
	if (tcp_under_memory_pressure(sk))
E
Eric Dumazet 已提交
5025
		return false;
5026 5027

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

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

E
Eric Dumazet 已提交
5035
	return true;
5036
}
L
Linus Torvalds 已提交
5037 5038 5039 5040 5041 5042 5043 5044 5045 5046 5047

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

5048
	if (tcp_should_expand_sndbuf(sk)) {
E
Eric Dumazet 已提交
5049
		tcp_sndbuf_expand(sk);
5050
		tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
5051 5052 5053 5054 5055
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
5056
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
5057 5058 5059
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
5060
		/* pairs with tcp_poll() */
5061
		smp_mb();
L
Linus Torvalds 已提交
5062
		if (sk->sk_socket &&
5063
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
L
Linus Torvalds 已提交
5064
			tcp_new_space(sk);
5065 5066 5067
			if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
				tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
		}
L
Linus Torvalds 已提交
5068 5069 5070
	}
}

5071
static inline void tcp_data_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5072
{
5073
	tcp_push_pending_frames(sk);
L
Linus Torvalds 已提交
5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084
	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... */
5085
	if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss &&
L
Linus Torvalds 已提交
5086
	     /* ... and right edge of window advances far enough.
5087 5088 5089
	      * (tcp_recvmsg() will send ACK otherwise).
	      * If application uses SO_RCVLOWAT, we want send ack now if
	      * we have not received enough bytes to satisfy the condition.
L
Linus Torvalds 已提交
5090
	      */
5091 5092
	    (tp->rcv_nxt - tp->copied_seq < sk->sk_rcvlowat ||
	     __tcp_select_window(sk) >= tp->rcv_wnd)) ||
L
Linus Torvalds 已提交
5093
	    /* We ACK each frame or... */
5094
	    tcp_in_quickack_mode(sk) ||
L
Linus Torvalds 已提交
5095
	    /* We have out of order data. */
5096
	    (ofo_possible && !RB_EMPTY_ROOT(&tp->out_of_order_queue))) {
L
Linus Torvalds 已提交
5097 5098 5099 5100 5101 5102 5103 5104
		/* Then ack it now */
		tcp_send_ack(sk);
	} else {
		/* Else, send delayed ack. */
		tcp_send_delayed_ack(sk);
	}
}

S
Stephen Hemminger 已提交
5105
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5106
{
5107
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
5108 5109 5110 5111 5112 5113 5114 5115
		/* 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 已提交
5116
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
5117 5118 5119 5120 5121 5122
 *	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).
 */
5123

5124
static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
L
Linus Torvalds 已提交
5125 5126 5127 5128
{
	struct tcp_sock *tp = tcp_sk(sk);
	u32 ptr = ntohs(th->urg_ptr);

5129
	if (ptr && !sock_net(sk)->ipv4.sysctl_tcp_stdurg)
L
Linus Torvalds 已提交
5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155 5156 5157 5158 5159 5160
		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 已提交
5161
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172
	 *
	 * 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 &&
5173
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
5174 5175 5176
		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 已提交
5177
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
5178 5179 5180 5181
			__kfree_skb(skb);
		}
	}

5182 5183
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
5184 5185 5186

	/* Disable header prediction. */
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
5187 5188 5189
}

/* This is the 'fast' part of urgent handling. */
5190
static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
L
Linus Torvalds 已提交
5191 5192 5193 5194 5195
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
5196
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
5197 5198 5199 5200 5201 5202

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

5203
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
5204 5205 5206 5207 5208 5209
		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))
5210
				sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
5211 5212 5213 5214
		}
	}
}

5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226 5227 5228 5229 5230 5231
/* 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));
}

5232 5233 5234
/* Does PAWS and seqno based validation of an incoming segment, flags will
 * play significant role here.
 */
E
Eric Dumazet 已提交
5235 5236
static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
				  const struct tcphdr *th, int syn_inerr)
5237 5238
{
	struct tcp_sock *tp = tcp_sk(sk);
5239
	bool rst_seq_match = false;
5240 5241

	/* RFC1323: H1. Apply PAWS check first. */
5242 5243
	if (tcp_fast_parse_options(sock_net(sk), skb, th, tp) &&
	    tp->rx_opt.saw_tstamp &&
5244 5245
	    tcp_paws_discard(sk, skb)) {
		if (!th->rst) {
5246
			NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
5247 5248 5249 5250
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDPAWS,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261 5262 5263
			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)".
		 */
5264 5265 5266
		if (!th->rst) {
			if (th->syn)
				goto syn_challenge;
5267 5268 5269 5270
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDSEQ,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5271 5272
		} else if (tcp_reset_check(sk, skb)) {
			tcp_reset(sk);
5273
		}
5274 5275 5276 5277 5278
		goto discard;
	}

	/* Step 2: check RST bit */
	if (th->rst) {
5279 5280 5281 5282
		/* 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,
5283
		 * then
E
Eric Dumazet 已提交
5284 5285 5286 5287
		 *     RESET the connection
		 * else
		 *     Send a challenge ACK
		 */
5288 5289
		if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt ||
		    tcp_reset_check(sk, skb)) {
5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307
			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 已提交
5308
			tcp_reset(sk);
5309 5310 5311 5312 5313 5314 5315
		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)
5316
				tcp_fastopen_active_disable(sk);
5317
			tcp_send_challenge_ack(sk, skb);
5318
		}
5319 5320 5321 5322 5323
		goto discard;
	}

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

E
Eric Dumazet 已提交
5324
	/* step 4: Check for a SYN
5325
	 * RFC 5961 4.2 : Send a challenge ack
E
Eric Dumazet 已提交
5326 5327
	 */
	if (th->syn) {
5328
syn_challenge:
5329
		if (syn_inerr)
5330 5331
			TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
5332
		tcp_send_challenge_ack(sk, skb);
E
Eric Dumazet 已提交
5333
		goto discard;
5334 5335
	}

E
Eric Dumazet 已提交
5336
	return true;
5337 5338

discard:
5339
	tcp_drop(sk, skb);
E
Eric Dumazet 已提交
5340
	return false;
5341 5342
}

L
Linus Torvalds 已提交
5343
/*
5344
 *	TCP receive function for the ESTABLISHED state.
5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364
 *
 *	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 已提交
5365
 */
5366
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
5367
			 const struct tcphdr *th)
L
Linus Torvalds 已提交
5368
{
5369
	unsigned int len = skb->len;
L
Linus Torvalds 已提交
5370 5371
	struct tcp_sock *tp = tcp_sk(sk);

5372 5373 5374
	/* TCP congestion window tracking */
	trace_tcp_probe(sk, skb);

5375
	tcp_mstamp_refresh(tp);
5376
	if (unlikely(!sk->sk_rx_dst))
E
Eric Dumazet 已提交
5377
		inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391
	/*
	 *	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 已提交
5392 5393 5394

	tp->rx_opt.saw_tstamp = 0;

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 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494
	/*	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);
5495
			tcp_data_ready(sk);
5496 5497 5498 5499 5500
			return;
		}
	}

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

5504
	if (!th->ack && !th->rst && !th->syn)
5505 5506
		goto discard;

5507 5508 5509 5510
	/*
	 *	Standard slow path.
	 */

E
Eric Dumazet 已提交
5511
	if (!tcp_validate_incoming(sk, skb, th, 1))
5512
		return;
L
Linus Torvalds 已提交
5513

5514 5515
step5:
	if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
5516
		goto discard;
L
Linus Torvalds 已提交
5517

5518
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5519 5520 5521 5522 5523 5524 5525

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

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

5526
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5527
	tcp_ack_snd_check(sk);
5528
	return;
L
Linus Torvalds 已提交
5529 5530

csum_error:
5531 5532
	TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
	TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5533 5534

discard:
5535
	tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5536
}
E
Eric Dumazet 已提交
5537
EXPORT_SYMBOL(tcp_rcv_established);
L
Linus Torvalds 已提交
5538

P
Pavel Emelyanov 已提交
5539 5540 5541 5542 5543 5544
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);
5545
	icsk->icsk_ack.lrcvtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5546

5547
	if (skb) {
E
Eric Dumazet 已提交
5548
		icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
P
Pavel Emelyanov 已提交
5549
		security_inet_conn_established(sk, skb);
D
David S. Miller 已提交
5550
	}
P
Pavel Emelyanov 已提交
5551

5552
	tcp_init_transfer(sk, BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB);
P
Pavel Emelyanov 已提交
5553 5554 5555 5556

	/* Prevent spurious tcp_cwnd_restart() on first data
	 * packet.
	 */
5557
	tp->lsndtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5558 5559 5560

	if (sock_flag(sk, SOCK_KEEPOPEN))
		inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
5561 5562 5563 5564 5565

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

5568 5569 5570 5571
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);
5572
	struct sk_buff *data = tp->syn_data ? tcp_rtx_queue_head(sk) : NULL;
5573 5574
	u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
	bool syn_drop = false;
5575 5576 5577 5578 5579 5580 5581

	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;
5582
		tcp_parse_options(sock_net(sk), synack, &opt, 0, NULL);
5583 5584 5585
		mss = opt.mss_clamp;
	}

5586 5587
	if (!tp->syn_fastopen) {
		/* Ignore an unsolicited cookie */
5588
		cookie->len = -1;
5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600 5601 5602
	} 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;
	}
5603

5604
	tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
5605 5606

	if (data) { /* Retransmit unacked data in SYN */
5607 5608
		skb_rbtree_walk_from(data) {
			if (__tcp_retransmit_skb(sk, data, 1))
5609 5610
				break;
		}
5611
		tcp_rearm_rto(sk);
5612
		NET_INC_STATS(sock_net(sk),
5613
				LINUX_MIB_TCPFASTOPENACTIVEFAIL);
5614 5615
		return true;
	}
Y
Yuchung Cheng 已提交
5616
	tp->syn_data_acked = tp->syn_data;
5617 5618 5619 5620 5621 5622
	if (tp->syn_data_acked) {
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENACTIVE);
		/* SYN-data is counted as two separate packets in tcp_ack() */
		if (tp->delivered > 1)
			--tp->delivered;
	}
5623 5624 5625

	tcp_fastopen_add_skb(sk, synack);

5626 5627 5628
	return false;
}

5629 5630 5631 5632 5633 5634 5635 5636 5637 5638
static void smc_check_reset_syn(struct tcp_sock *tp)
{
#if IS_ENABLED(CONFIG_SMC)
	if (static_branch_unlikely(&tcp_have_smc)) {
		if (tp->syn_smc && !tp->rx_opt.smc_ok)
			tp->syn_smc = 0;
	}
#endif
}

L
Linus Torvalds 已提交
5639
static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
5640
					 const struct tcphdr *th)
L
Linus Torvalds 已提交
5641
{
5642
	struct inet_connection_sock *icsk = inet_csk(sk);
5643
	struct tcp_sock *tp = tcp_sk(sk);
5644
	struct tcp_fastopen_cookie foc = { .len = -1 };
5645
	int saved_clamp = tp->rx_opt.mss_clamp;
5646
	bool fastopen_fail;
L
Linus Torvalds 已提交
5647

5648
	tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc);
5649
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
5650
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;
L
Linus Torvalds 已提交
5651 5652 5653 5654 5655 5656 5657 5658 5659 5660

	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)"
		 */
5661 5662
		if (!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
		    after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt))
L
Linus Torvalds 已提交
5663 5664 5665 5666
			goto reset_and_undo;

		if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
		    !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp,
5667
			     tcp_time_stamp(tp))) {
5668
			NET_INC_STATS(sock_net(sk),
5669
					LINUX_MIB_PAWSACTIVEREJECTED);
L
Linus Torvalds 已提交
5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702
			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..."
		 */

5703
		tcp_ecn_rcv_synack(tp, th);
L
Linus Torvalds 已提交
5704

5705
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
5706
		tcp_ack(sk, skb, FLAG_SLOWPATH);
L
Linus Torvalds 已提交
5707 5708 5709 5710 5711 5712 5713 5714 5715 5716 5717 5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733

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

5734
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5735 5736 5737 5738 5739 5740
		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;
5741

5742 5743
		smc_check_reset_syn(tp);

R
Ralf Baechle 已提交
5744
		smp_mb();
L
Linus Torvalds 已提交
5745

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

5748 5749
		fastopen_fail = (tp->syn_fastopen || tp->syn_data) &&
				tcp_rcv_fastopen_synack(sk, skb, &foc);
5750

5751 5752 5753 5754 5755 5756
		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;
5757 5758 5759
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
5760 5761 5762 5763 5764 5765 5766
			/* 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
			 */
5767 5768
			inet_csk_schedule_ack(sk);
			tcp_enter_quickack_mode(sk);
5769 5770
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
5771 5772

discard:
5773
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793
			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. */
5794
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
I
Ilpo Järvinen 已提交
5795
	    tcp_paws_reject(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809 5810 5811 5812 5813 5814
		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;
5815
		tp->copied_seq = tp->rcv_nxt;
L
Linus Torvalds 已提交
5816 5817 5818 5819 5820 5821 5822 5823 5824
		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;

5825
		tcp_ecn_rcv_syn(tp, th);
L
Linus Torvalds 已提交
5826

J
John Heffner 已提交
5827
		tcp_mtup_init(sk);
5828
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5829 5830 5831 5832 5833
		tcp_initialize_rcv_mss(sk);

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
5834 5835 5836
		 * 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 已提交
5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848 5849 5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865
		 *
		 * 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
5866
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5867 5868 5869
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5870

5871
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
5872 5873
{
	struct tcp_sock *tp = tcp_sk(sk);
5874
	struct inet_connection_sock *icsk = inet_csk(sk);
5875
	const struct tcphdr *th = tcp_hdr(skb);
5876
	struct request_sock *req;
L
Linus Torvalds 已提交
5877
	int queued = 0;
5878
	bool acceptable;
L
Linus Torvalds 已提交
5879 5880 5881 5882 5883 5884

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

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5885
		if (th->ack)
L
Linus Torvalds 已提交
5886 5887
			return 1;

S
Stephen Hemminger 已提交
5888
		if (th->rst)
L
Linus Torvalds 已提交
5889 5890
			goto discard;

S
Stephen Hemminger 已提交
5891
		if (th->syn) {
E
Eric Dumazet 已提交
5892 5893
			if (th->fin)
				goto discard;
5894 5895 5896 5897 5898 5899
			/* 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 已提交
5900

5901 5902
			if (!acceptable)
				return 1;
5903
			consume_skb(skb);
5904
			return 0;
L
Linus Torvalds 已提交
5905 5906 5907 5908
		}
		goto discard;

	case TCP_SYN_SENT:
5909
		tp->rx_opt.saw_tstamp = 0;
5910
		tcp_mstamp_refresh(tp);
5911
		queued = tcp_rcv_synsent_state_process(sk, skb, th);
L
Linus Torvalds 已提交
5912 5913 5914 5915 5916 5917
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
5918
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5919 5920 5921
		return 0;
	}

5922
	tcp_mstamp_refresh(tp);
5923
	tp->rx_opt.saw_tstamp = 0;
5924
	req = tp->fastopen_rsk;
5925
	if (req) {
5926 5927
		bool req_stolen;

5928
		WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
5929 5930
		    sk->sk_state != TCP_FIN_WAIT1);

5931
		if (!tcp_check_req(sk, skb, req, true, &req_stolen))
5932
			goto discard;
5933
	}
5934

5935
	if (!th->ack && !th->rst && !th->syn)
5936 5937
		goto discard;

5938
	if (!tcp_validate_incoming(sk, skb, th, 0))
E
Eric Dumazet 已提交
5939
		return 0;
L
Linus Torvalds 已提交
5940 5941

	/* step 5: check the ACK field */
5942 5943
	acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
				      FLAG_UPDATE_TS_RECENT |
5944
				      FLAG_NO_CHALLENGE_ACK) > 0;
5945

5946 5947 5948 5949 5950 5951
	if (!acceptable) {
		if (sk->sk_state == TCP_SYN_RECV)
			return 1;	/* send one RST */
		tcp_send_challenge_ack(sk, skb);
		goto discard;
	}
5952 5953
	switch (sk->sk_state) {
	case TCP_SYN_RECV:
5954
		tp->delivered++; /* SYN-ACK delivery isn't tracked in tcp_ack */
Y
Yuchung Cheng 已提交
5955 5956 5957
		if (!tp->srtt_us)
			tcp_synack_rtt_meas(sk, req);

5958 5959 5960 5961
		/* Once we leave TCP_SYN_RECV, we no longer need req
		 * so release it.
		 */
		if (req) {
5962
			inet_csk(sk)->icsk_retransmits = 0;
5963
			reqsk_fastopen_remove(sk, req, false);
5964 5965 5966 5967 5968 5969 5970 5971 5972
			/* 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.
			 */
			tcp_rearm_rto(sk);
5973
		} else {
5974
			tcp_init_transfer(sk, BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB);
5975 5976 5977 5978 5979
			tp->copied_seq = tp->rcv_nxt;
		}
		smp_mb();
		tcp_set_state(sk, TCP_ESTABLISHED);
		sk->sk_state_change(sk);
L
Linus Torvalds 已提交
5980

5981 5982 5983 5984 5985 5986 5987 5988 5989 5990 5991 5992 5993 5994
		/* 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;

5995 5996
		if (!inet_csk(sk)->icsk_ca_ops->cong_control)
			tcp_update_pacing_rate(sk);
5997

5998
		/* Prevent spurious tcp_cwnd_restart() on first data packet */
5999
		tp->lsndtime = tcp_jiffies32;
6000 6001

		tcp_initialize_rcv_mss(sk);
6002
		tcp_fast_path_on(tp);
6003 6004
		break;

6005 6006 6007
	case TCP_FIN_WAIT1: {
		int tmo;

6008 6009 6010 6011 6012
		/* 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.
		 */
6013
		if (req) {
6014 6015 6016 6017
			/* We no longer need the request sock. */
			reqsk_fastopen_remove(sk, req, false);
			tcp_rearm_rto(sk);
		}
6018 6019
		if (tp->snd_una != tp->write_seq)
			break;
6020

6021 6022
		tcp_set_state(sk, TCP_FIN_WAIT2);
		sk->sk_shutdown |= SEND_SHUTDOWN;
6023

6024
		sk_dst_confirm(sk);
6025

6026 6027 6028 6029 6030
		if (!sock_flag(sk, SOCK_DEAD)) {
			/* Wake up lingering close() */
			sk->sk_state_change(sk);
			break;
		}
L
Linus Torvalds 已提交
6031

6032 6033 6034 6035 6036 6037 6038 6039 6040
		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)
6041
				tcp_fastopen_active_disable(sk);
6042
			tcp_done(sk);
6043
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
6044 6045 6046 6047 6048 6049 6050 6051 6052 6053 6054 6055 6056 6057 6058 6059 6060
			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;
6061 6062
		}
		break;
6063
	}
L
Linus Torvalds 已提交
6064

6065 6066 6067 6068 6069 6070
	case TCP_CLOSING:
		if (tp->snd_una == tp->write_seq) {
			tcp_time_wait(sk, TCP_TIME_WAIT, 0);
			goto discard;
		}
		break;
L
Linus Torvalds 已提交
6071

6072 6073 6074 6075 6076
	case TCP_LAST_ACK:
		if (tp->snd_una == tp->write_seq) {
			tcp_update_metrics(sk);
			tcp_done(sk);
			goto discard;
L
Linus Torvalds 已提交
6077
		}
6078
		break;
6079
	}
L
Linus Torvalds 已提交
6080 6081 6082 6083 6084 6085 6086 6087 6088 6089 6090

	/* 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;
6091
		/* fall through */
L
Linus Torvalds 已提交
6092 6093 6094
	case TCP_FIN_WAIT1:
	case TCP_FIN_WAIT2:
		/* RFC 793 says to queue data in these states,
6095
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
6096 6097 6098 6099 6100
		 * 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)) {
6101
				NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
6102 6103 6104 6105 6106
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
6107
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
6108 6109 6110 6111 6112 6113 6114
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
6115
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
6116 6117 6118
		tcp_ack_snd_check(sk);
	}

6119
	if (!queued) {
L
Linus Torvalds 已提交
6120
discard:
6121
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
6122 6123 6124 6125
	}
	return 0;
}
EXPORT_SYMBOL(tcp_rcv_state_process);
O
Octavian Purdila 已提交
6126 6127 6128 6129 6130 6131

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)
6132 6133
		net_dbg_ratelimited("drop open request from %pI4/%u\n",
				    &ireq->ir_rmt_addr, port);
6134 6135
#if IS_ENABLED(CONFIG_IPV6)
	else if (family == AF_INET6)
6136 6137
		net_dbg_ratelimited("drop open request from %pI6/%u\n",
				    &ireq->ir_v6_rmt_addr, port);
6138
#endif
O
Octavian Purdila 已提交
6139 6140
}

6141 6142 6143 6144 6145
/* 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 已提交
6146
 * TCP ECN negotiation.
6147 6148
 *
 * Exception: tcp_ca wants ECN. This is required for DCTCP
6149 6150 6151
 * congestion control: Linux DCTCP asserts ECT on all packets,
 * including SYN, which is most optimal solution; however,
 * others, such as FreeBSD do not.
6152 6153 6154
 */
static void tcp_ecn_create_request(struct request_sock *req,
				   const struct sk_buff *skb,
6155 6156
				   const struct sock *listen_sk,
				   const struct dst_entry *dst)
6157 6158 6159 6160
{
	const struct tcphdr *th = tcp_hdr(skb);
	const struct net *net = sock_net(listen_sk);
	bool th_ecn = th->ece && th->cwr;
6161
	bool ect, ecn_ok;
6162
	u32 ecn_ok_dst;
6163 6164 6165 6166 6167

	if (!th_ecn)
		return;

	ect = !INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield);
6168 6169
	ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
	ecn_ok = net->ipv4.sysctl_tcp_ecn || ecn_ok_dst;
6170

6171
	if ((!ect && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
6172 6173
	    (ecn_ok_dst & DST_FEATURE_ECN_CA) ||
	    tcp_bpf_ca_needs_ecn((struct sock *)req))
6174 6175 6176
		inet_rsk(req)->ecn_ok = 1;
}

6177 6178 6179 6180 6181 6182
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);

6183
	req->rsk_rcv_wnd = 0;		/* So that tcp_send_synack() knows! */
6184 6185 6186
	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;
6187
	tcp_rsk(req)->snt_synack = tcp_clock_us();
6188 6189 6190 6191 6192 6193 6194 6195 6196 6197 6198 6199
	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);
6200 6201 6202
#if IS_ENABLED(CONFIG_SMC)
	ireq->smc_ok = rx_opt->smc_ok;
#endif
6203 6204
}

E
Eric Dumazet 已提交
6205
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
6206 6207
				      struct sock *sk_listener,
				      bool attach_listener)
E
Eric Dumazet 已提交
6208
{
6209 6210
	struct request_sock *req = reqsk_alloc(ops, sk_listener,
					       attach_listener);
E
Eric Dumazet 已提交
6211 6212 6213 6214

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

E
Eric Dumazet 已提交
6215
		ireq->ireq_opt = NULL;
6216 6217 6218
#if IS_ENABLED(CONFIG_IPV6)
		ireq->pktopts = NULL;
#endif
6219
		atomic64_set(&ireq->ir_cookie, 0);
E
Eric Dumazet 已提交
6220 6221
		ireq->ireq_state = TCP_NEW_SYN_RECV;
		write_pnet(&ireq->ireq_net, sock_net(sk_listener));
6222
		ireq->ireq_family = sk_listener->sk_family;
E
Eric Dumazet 已提交
6223 6224 6225 6226 6227 6228
	}

	return req;
}
EXPORT_SYMBOL(inet_reqsk_alloc);

6229 6230 6231
/*
 * Return true if a syncookie should be sent
 */
6232
static bool tcp_syn_flood_action(const struct sock *sk,
6233 6234 6235
				 const struct sk_buff *skb,
				 const char *proto)
{
6236
	struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
6237 6238
	const char *msg = "Dropping request";
	bool want_cookie = false;
6239
	struct net *net = sock_net(sk);
6240 6241

#ifdef CONFIG_SYN_COOKIES
6242
	if (net->ipv4.sysctl_tcp_syncookies) {
6243 6244
		msg = "Sending cookies";
		want_cookie = true;
6245
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
6246 6247
	} else
#endif
6248
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
6249

6250
	if (!queue->synflood_warned &&
6251
	    net->ipv4.sysctl_tcp_syncookies != 2 &&
6252
	    xchg(&queue->synflood_warned, 1) == 0)
6253 6254
		pr_info("%s: Possible SYN flooding on port %d. %s.  Check SNMP counters.\n",
			proto, ntohs(tcp_hdr(skb)->dest), msg);
6255

6256 6257 6258
	return want_cookie;
}

6259 6260 6261 6262 6263 6264 6265 6266 6267 6268 6269 6270 6271 6272 6273 6274 6275
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 已提交
6276 6277 6278 6279
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)
{
6280 6281
	struct tcp_fastopen_cookie foc = { .len = -1 };
	__u32 isn = TCP_SKB_CB(skb)->tcp_tw_isn;
O
Octavian Purdila 已提交
6282 6283
	struct tcp_options_received tmp_opt;
	struct tcp_sock *tp = tcp_sk(sk);
6284
	struct net *net = sock_net(sk);
6285 6286 6287
	struct sock *fastopen_sk = NULL;
	struct request_sock *req;
	bool want_cookie = false;
6288
	struct dst_entry *dst;
O
Octavian Purdila 已提交
6289 6290 6291 6292 6293 6294
	struct flowi fl;

	/* TW buckets are converted to open requests without
	 * limitations, they conserve resources and peer is
	 * evidently real one.
	 */
6295
	if ((net->ipv4.sysctl_tcp_syncookies == 2 ||
O
Octavian Purdila 已提交
6296 6297 6298 6299 6300 6301
	     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;
	}

6302
	if (sk_acceptq_is_full(sk)) {
6303
		NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
O
Octavian Purdila 已提交
6304 6305 6306
		goto drop;
	}

6307
	req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
O
Octavian Purdila 已提交
6308 6309 6310 6311
	if (!req)
		goto drop;

	tcp_rsk(req)->af_specific = af_ops;
6312
	tcp_rsk(req)->ts_off = 0;
O
Octavian Purdila 已提交
6313 6314 6315 6316

	tcp_clear_options(&tmp_opt);
	tmp_opt.mss_clamp = af_ops->mss_clamp;
	tmp_opt.user_mss  = tp->rx_opt.user_mss;
6317 6318
	tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0,
			  want_cookie ? NULL : &foc);
O
Octavian Purdila 已提交
6319 6320 6321 6322

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

6323 6324 6325
	if (IS_ENABLED(CONFIG_SMC) && want_cookie)
		tmp_opt.smc_ok = 0;

O
Octavian Purdila 已提交
6326 6327
	tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
	tcp_openreq_init(req, &tmp_opt, skb, sk);
6328
	inet_rsk(req)->no_srccheck = inet_sk(sk)->transparent;
O
Octavian Purdila 已提交
6329

6330
	/* Note: tcp_v6_init_req() might override ir_iif for link locals */
6331
	inet_rsk(req)->ir_iif = inet_request_bound_dev_if(sk, skb);
6332

O
Octavian Purdila 已提交
6333 6334 6335 6336 6337
	af_ops->init_req(req, sk, skb);

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

6338
	if (tmp_opt.tstamp_ok)
6339
		tcp_rsk(req)->ts_off = af_ops->init_ts_off(net, skb);
6340

6341 6342 6343 6344
	dst = af_ops->route_req(sk, &fl, req);
	if (!dst)
		goto drop_and_free;

6345
	if (!want_cookie && !isn) {
O
Octavian Purdila 已提交
6346
		/* Kill the following clause, if you dislike this way. */
6347 6348 6349 6350
		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 已提交
6351 6352 6353 6354 6355 6356 6357 6358 6359 6360 6361 6362
			/* 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;
		}

6363
		isn = af_ops->init_seq(skb);
O
Octavian Purdila 已提交
6364 6365
	}

6366 6367 6368 6369 6370 6371 6372 6373 6374
	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 已提交
6375
	tcp_rsk(req)->snt_isn = isn;
6376
	tcp_rsk(req)->txhash = net_tx_rndhash();
O
Octavian Purdila 已提交
6377
	tcp_openreq_init_rwin(req, sk, dst);
6378 6379
	if (!want_cookie) {
		tcp_reqsk_record_syn(sk, req, skb);
6380
		fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc, dst);
6381
	}
6382
	if (fastopen_sk) {
6383
		af_ops->send_synack(fastopen_sk, dst, &fl, req,
6384
				    &foc, TCP_SYNACK_FASTOPEN);
6385 6386 6387 6388
		/* 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);
6389 6390
		sock_put(fastopen_sk);
	} else {
6391
		tcp_rsk(req)->tfo_listener = false;
6392
		if (!want_cookie)
6393 6394
			inet_csk_reqsk_queue_hash_add(sk, req,
				tcp_timeout_init((struct sock *)req));
6395 6396 6397
		af_ops->send_synack(sk, dst, &fl, req, &foc,
				    !want_cookie ? TCP_SYNACK_NORMAL :
						   TCP_SYNACK_COOKIE);
6398 6399 6400 6401
		if (want_cookie) {
			reqsk_free(req);
			return 0;
		}
O
Octavian Purdila 已提交
6402
	}
6403
	reqsk_put(req);
O
Octavian Purdila 已提交
6404 6405 6406 6407 6408 6409 6410
	return 0;

drop_and_release:
	dst_release(dst);
drop_and_free:
	reqsk_free(req);
drop:
6411
	tcp_listendrop(sk);
O
Octavian Purdila 已提交
6412 6413 6414
	return 0;
}
EXPORT_SYMBOL(tcp_conn_request);