tcp_input.c 185.6 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>
81
#include <net/busy_poll.h>
L
Linus Torvalds 已提交
82

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

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

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

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

111 112 113 114
#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 已提交
115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133
#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

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

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

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

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

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

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

219
void tcp_enter_quickack_mode(struct sock *sk, unsigned int max_quickacks)
L
Linus Torvalds 已提交
220
{
221
	struct inet_connection_sock *icsk = inet_csk(sk);
222 223

	tcp_incr_quickack(sk, max_quickacks);
224 225
	icsk->icsk_ack.pingpong = 0;
	icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
226
}
227
EXPORT_SYMBOL(tcp_enter_quickack_mode);
L
Linus Torvalds 已提交
228 229 230 231 232

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

233
static bool tcp_in_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
234
{
235
	const struct inet_connection_sock *icsk = inet_csk(sk);
236
	const struct dst_entry *dst = __sk_dst_get(sk);
E
Eric Dumazet 已提交
237

238 239
	return (dst && dst_metric(dst, RTAX_QUICKACK)) ||
		(icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong);
L
Linus Torvalds 已提交
240 241
}

242
static void tcp_ecn_queue_cwr(struct tcp_sock *tp)
243
{
244
	if (tp->ecn_flags & TCP_ECN_OK)
245 246 247
		tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}

248
static void tcp_ecn_accept_cwr(struct tcp_sock *tp, const struct sk_buff *skb)
249 250 251 252 253
{
	if (tcp_hdr(skb)->cwr)
		tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

254
static void tcp_ecn_withdraw_cwr(struct tcp_sock *tp)
255 256 257 258
{
	tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

259
static void __tcp_ecn_check_ce(struct sock *sk, const struct sk_buff *skb)
260
{
261 262
	struct tcp_sock *tp = tcp_sk(sk);

263
	switch (TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK) {
264
	case INET_ECN_NOT_ECT:
265
		/* Funny extension: if ECT is not set on a segment,
266 267 268 269
		 * and we already seen ECT on a previous segment,
		 * it is probably a retransmit.
		 */
		if (tp->ecn_flags & TCP_ECN_SEEN)
270
			tcp_enter_quickack_mode(sk, 2);
271 272
		break;
	case INET_ECN_CE:
273 274
		if (tcp_ca_needs_ecn(sk))
			tcp_ca_event(sk, CA_EVENT_ECN_IS_CE);
275

276 277
		if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR)) {
			/* Better not delay acks, sender can have a very low cwnd */
278
			tcp_enter_quickack_mode(sk, 2);
279 280
			tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
		}
281 282
		tp->ecn_flags |= TCP_ECN_SEEN;
		break;
283
	default:
284 285
		if (tcp_ca_needs_ecn(sk))
			tcp_ca_event(sk, CA_EVENT_ECN_NO_CE);
286
		tp->ecn_flags |= TCP_ECN_SEEN;
287
		break;
288 289 290
	}
}

291
static void tcp_ecn_check_ce(struct sock *sk, const struct sk_buff *skb)
292
{
293 294
	if (tcp_sk(sk)->ecn_flags & TCP_ECN_OK)
		__tcp_ecn_check_ce(sk, skb);
295 296 297
}

static void tcp_ecn_rcv_synack(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 void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
304
{
305
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
306 307 308
		tp->ecn_flags &= ~TCP_ECN_OK;
}

309
static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
310
{
311
	if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
E
Eric Dumazet 已提交
312 313
		return true;
	return false;
314 315
}

L
Linus Torvalds 已提交
316 317 318 319 320
/* Buffer size and advertised window tuning.
 *
 * 1. Tuning sk->sk_sndbuf, when connection enters established state.
 */

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

348
	if (sk->sk_sndbuf < sndmem)
349
		sk->sk_sndbuf = min(sndmem, sock_net(sk)->ipv4.sysctl_tcp_wmem[2]);
L
Linus Torvalds 已提交
350 351 352 353 354 355 356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372
}

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

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

	while (tp->rcv_ssthresh <= window) {
		if (truesize <= skb->len)
387
			return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
L
Linus Torvalds 已提交
388 389 390 391 392 393 394

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

395
static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
396
{
397 398
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
399 400 401
	/* Check #1 */
	if (tp->rcv_ssthresh < tp->window_clamp &&
	    (int)tp->rcv_ssthresh < tcp_space(sk) &&
402
	    !tcp_under_memory_pressure(sk)) {
L
Linus Torvalds 已提交
403 404 405 406 407
		int incr;

		/* Check #2. Increase window, if skb with such overhead
		 * will fit to rcvbuf in future.
		 */
408
		if (tcp_win_from_space(sk, skb->truesize) <= skb->len)
409
			incr = 2 * tp->advmss;
L
Linus Torvalds 已提交
410
		else
411
			incr = __tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
412 413

		if (incr) {
414
			incr = max_t(int, incr, 2 * skb->len);
415 416
			tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr,
					       tp->window_clamp);
417
			inet_csk(sk)->icsk_ack.quick |= 1;
L
Linus Torvalds 已提交
418 419 420 421 422 423 424
		}
	}
}

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

428 429
	rcvmem = 2 * SKB_TRUESIZE(mss + MAX_TCP_HEADER) *
		 tcp_default_init_rwnd(mss);
430

E
Eric Dumazet 已提交
431 432 433
	/* Dynamic Right Sizing (DRS) has 2 to 3 RTT latency
	 * Allow enough cushion so that sender is not limited by our window
	 */
434
	if (sock_net(sk)->ipv4.sysctl_tcp_moderate_rcvbuf)
E
Eric Dumazet 已提交
435 436
		rcvmem <<= 2;

437
	if (sk->sk_rcvbuf < rcvmem)
438
		sk->sk_rcvbuf = min(rcvmem, sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
439 440
}

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

	tp->rcvq_space.space = tp->rcv_wnd;
456
	tcp_mstamp_refresh(tp);
457
	tp->rcvq_space.time = tp->tcp_mstamp;
E
Eric Dumazet 已提交
458
	tp->rcvq_space.seq = tp->copied_seq;
L
Linus Torvalds 已提交
459 460 461 462 463 464

	maxwin = tcp_full_space(sk);

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

465
		if (tcp_app_win && maxwin > 4 * tp->advmss)
L
Linus Torvalds 已提交
466
			tp->window_clamp = max(maxwin -
467
					       (maxwin >> tcp_app_win),
L
Linus Torvalds 已提交
468 469 470 471
					       4 * tp->advmss);
	}

	/* Force reservation of one segment. */
472
	if (tcp_app_win &&
L
Linus Torvalds 已提交
473 474 475 476 477
	    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);
478
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
479 480 481
}

/* 5. Recalculate window clamp after socket hit its memory bounds. */
482
static void tcp_clamp_window(struct sock *sk)
L
Linus Torvalds 已提交
483
{
484
	struct tcp_sock *tp = tcp_sk(sk);
485
	struct inet_connection_sock *icsk = inet_csk(sk);
486
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
487

488
	icsk->icsk_ack.quick = 0;
L
Linus Torvalds 已提交
489

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

S
Stephen Hemminger 已提交
501 502 503 504 505 506 507 508 509
/* 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)
{
510
	const struct tcp_sock *tp = tcp_sk(sk);
S
Stephen Hemminger 已提交
511 512
	unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);

513
	hint = min(hint, tp->rcv_wnd / 2);
514
	hint = min(hint, TCP_MSS_DEFAULT);
S
Stephen Hemminger 已提交
515 516 517 518
	hint = max(hint, TCP_MIN_MSS);

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

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

561
	tp->rcv_rtt_est.rtt_us = new_sample;
L
Linus Torvalds 已提交
562 563 564 565
}

static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
{
566 567
	u32 delta_us;

568
	if (tp->rcv_rtt_est.time == 0)
L
Linus Torvalds 已提交
569 570 571
		goto new_measure;
	if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
		return;
572
	delta_us = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcv_rtt_est.time);
573 574
	if (!delta_us)
		delta_us = 1;
575
	tcp_rcv_rtt_update(tp, delta_us, 1);
L
Linus Torvalds 已提交
576 577 578

new_measure:
	tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
579
	tp->rcv_rtt_est.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
580 581
}

582 583
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
584
{
585
	struct tcp_sock *tp = tcp_sk(sk);
586

587 588 589 590 591 592
	if (tp->rx_opt.rcv_tsecr == tp->rcv_rtt_last_tsecr)
		return;
	tp->rcv_rtt_last_tsecr = tp->rx_opt.rcv_tsecr;

	if (TCP_SKB_CB(skb)->end_seq -
	    TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss) {
593
		u32 delta = tcp_time_stamp(tp) - tp->rx_opt.rcv_tsecr;
594
		u32 delta_us;
595

596 597 598
		if (!delta)
			delta = 1;
		delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ);
599 600
		tcp_rcv_rtt_update(tp, delta_us, 0);
	}
L
Linus Torvalds 已提交
601 602 603 604 605 606 607 608 609
}

/*
 * 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);
610
	u32 copied;
L
Linus Torvalds 已提交
611
	int time;
612

613 614
	trace_tcp_rcv_space_adjust(sk);

615
	tcp_mstamp_refresh(tp);
616
	time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time);
617
	if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0)
L
Linus Torvalds 已提交
618
		return;
619

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

634
	if (sock_net(sk)->ipv4.sysctl_tcp_moderate_rcvbuf &&
E
Eric Dumazet 已提交
635
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
636
		int rcvmem, rcvbuf;
E
Eric Dumazet 已提交
637
		u64 rcvwin, grow;
L
Linus Torvalds 已提交
638

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

E
Eric Dumazet 已提交
644 645 646 647
		/* 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 已提交
648

E
Eric Dumazet 已提交
649
		rcvmem = SKB_TRUESIZE(tp->advmss + MAX_TCP_HEADER);
650
		while (tcp_win_from_space(sk, rcvmem) < tp->advmss)
E
Eric Dumazet 已提交
651
			rcvmem += 128;
L
Linus Torvalds 已提交
652

653 654 655
		do_div(rcvwin, tp->advmss);
		rcvbuf = min_t(u64, rcvwin * rcvmem,
			       sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
E
Eric Dumazet 已提交
656 657
		if (rcvbuf > sk->sk_rcvbuf) {
			sk->sk_rcvbuf = rcvbuf;
L
Linus Torvalds 已提交
658

E
Eric Dumazet 已提交
659
			/* Make the window clamp follow along.  */
660
			tp->window_clamp = tcp_win_from_space(sk, rcvbuf);
L
Linus Torvalds 已提交
661 662
		}
	}
E
Eric Dumazet 已提交
663
	tp->rcvq_space.space = copied;
664

L
Linus Torvalds 已提交
665 666
new_measure:
	tp->rcvq_space.seq = tp->copied_seq;
667
	tp->rcvq_space.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
668 669 670 671 672 673 674 675 676 677 678 679
}

/* 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
 */
680
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
681
{
682
	struct tcp_sock *tp = tcp_sk(sk);
683
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
684 685
	u32 now;

686
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
687

688
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
689 690

	tcp_rcv_rtt_measure(tp);
691

692
	now = tcp_jiffies32;
L
Linus Torvalds 已提交
693

694
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
695 696 697
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
698
		tcp_incr_quickack(sk, TCP_MAX_QUICKACKS);
699
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
700
	} else {
701
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
702

703
		if (m <= TCP_ATO_MIN / 2) {
L
Linus Torvalds 已提交
704
			/* The fastest case is the first. */
705 706 707 708 709 710
			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 已提交
711
			/* Too long gap. Apparently sender failed to
L
Linus Torvalds 已提交
712 713
			 * restart window, so that we send ACKs quickly.
			 */
714
			tcp_incr_quickack(sk, TCP_MAX_QUICKACKS);
715
			sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
716 717
		}
	}
718
	icsk->icsk_ack.lrcvtime = now;
L
Linus Torvalds 已提交
719

720
	tcp_ecn_check_ce(sk, skb);
L
Linus Torvalds 已提交
721 722

	if (skb->len >= 128)
723
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
724 725 726 727 728 729 730 731 732 733 734
}

/* 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
 */
735
static void tcp_rtt_estimator(struct sock *sk, long mrtt_us)
L
Linus Torvalds 已提交
736
{
737
	struct tcp_sock *tp = tcp_sk(sk);
738 739
	long m = mrtt_us; /* RTT */
	u32 srtt = tp->srtt_us;
L
Linus Torvalds 已提交
740 741 742 743

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

E
Eric Dumazet 已提交
799 800 801 802 803 804
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) */
805 806 807 808 809 810 811 812 813 814 815
	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)
816
		rate *= sock_net(sk)->ipv4.sysctl_tcp_pacing_ss_ratio;
817
	else
818
		rate *= sock_net(sk)->ipv4.sysctl_tcp_pacing_ca_ratio;
E
Eric Dumazet 已提交
819 820 821

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

822 823
	if (likely(tp->srtt_us))
		do_div(rate, tp->srtt_us);
E
Eric Dumazet 已提交
824

825
	/* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate
826 827 828
	 * without any lock. We want to make sure compiler wont store
	 * intermediate values in this location.
	 */
829 830
	WRITE_ONCE(sk->sk_pacing_rate, min_t(u64, rate,
					     sk->sk_max_pacing_rate));
E
Eric Dumazet 已提交
831 832
}

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

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

857 858 859
	/* NOTE: clamping at TCP_RTO_MIN is not required, current algo
	 * guarantees that rto is higher.
	 */
860
	tcp_bound_rto(sk);
L
Linus Torvalds 已提交
861 862
}

863
__u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst)
L
Linus Torvalds 已提交
864 865 866
{
	__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

867
	if (!cwnd)
868
		cwnd = TCP_INIT_CWND;
L
Linus Torvalds 已提交
869 870 871
	return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
}

872
/* Take a notice that peer is sending D-SACKs */
873 874
static void tcp_dsack_seen(struct tcp_sock *tp)
{
875
	tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
876
	tp->rack.dsack_seen = 1;
W
Wei Wang 已提交
877
	tp->dsack_dups++;
878 879
}

880 881 882 883 884 885
/* 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 已提交
886
{
887
	struct tcp_sock *tp = tcp_sk(sk);
888 889
	const u32 mss = tp->mss_cache;
	u32 fack, metric;
890

891 892
	fack = tcp_highest_sack_seq(tp);
	if (!before(low_seq, fack))
893 894
		return;

895 896
	metric = fack - low_seq;
	if ((metric > tp->reordering * mss) && mss) {
L
Linus Torvalds 已提交
897
#if FASTRETRANS_DEBUG > 1
898 899 900
		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,
901
			 0,
902 903
			 tp->sacked_out,
			 tp->undo_marker ? tp->undo_retrans : 0);
L
Linus Torvalds 已提交
904
#endif
905 906
		tp->reordering = min_t(u32, (metric + mss - 1) / mss,
				       sock_net(sk)->ipv4.sysctl_tcp_max_reordering);
L
Linus Torvalds 已提交
907
	}
Y
Yuchung Cheng 已提交
908

Y
Yuchung Cheng 已提交
909
	tp->rack.reord = 1;
910
	/* This exciting event is worth to be remembered. 8) */
911 912
	NET_INC_STATS(sock_net(sk),
		      ts ? LINUX_MIB_TCPTSREORDER : LINUX_MIB_TCPSACKREORDER);
L
Linus Torvalds 已提交
913 914
}

915
/* This must be called before lost_out is incremented */
916 917
static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
{
918
	if (!tp->retransmit_skb_hint ||
919 920
	    before(TCP_SKB_CB(skb)->seq,
		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
921
		tp->retransmit_skb_hint = skb;
922 923
}

924 925 926 927 928 929 930 931 932 933 934 935 936 937 938 939
/* 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);
}

940 941 942 943 944 945
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);
946
		tcp_sum_lost(tp, skb);
947 948 949 950
		TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
	}
}

Y
Yuchung Cheng 已提交
951
void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb)
952 953 954
{
	tcp_verify_retransmit_hint(tp, skb);

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

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

1066
	/* In outstanding window? ...This is valid exit for D-SACKs too.
I
Ilpo Järvinen 已提交
1067 1068 1069
	 * start_seq == snd_una is non-sensical (see comments above)
	 */
	if (after(start_seq, tp->snd_una))
E
Eric Dumazet 已提交
1070
		return true;
I
Ilpo Järvinen 已提交
1071 1072

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

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

	if (!before(start_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1080
		return true;
I
Ilpo Järvinen 已提交
1081 1082 1083

	/* Too old */
	if (!after(end_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1084
		return false;
I
Ilpo Järvinen 已提交
1085 1086 1087 1088 1089 1090 1091

	/* 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 已提交
1092 1093 1094
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)
1095
{
1096
	struct tcp_sock *tp = tcp_sk(sk);
1097 1098
	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 已提交
1099
	bool dup_sack = false;
1100 1101

	if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
E
Eric Dumazet 已提交
1102
		dup_sack = true;
1103
		tcp_dsack_seen(tp);
1104
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
1105
	} else if (num_sacks > 1) {
1106 1107
		u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
		u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
1108 1109 1110

		if (!after(end_seq_0, end_seq_1) &&
		    !before(start_seq_0, start_seq_1)) {
E
Eric Dumazet 已提交
1111
			dup_sack = true;
1112
			tcp_dsack_seen(tp);
1113
			NET_INC_STATS(sock_net(sk),
1114
					LINUX_MIB_TCPDSACKOFORECV);
1115 1116 1117 1118
		}
	}

	/* D-SACK for already forgotten data... Do dumb counting. */
Y
Yuchung Cheng 已提交
1119
	if (dup_sack && tp->undo_marker && tp->undo_retrans > 0 &&
1120 1121 1122 1123 1124 1125 1126
	    !after(end_seq_0, prior_snd_una) &&
	    after(end_seq_0, tp->undo_marker))
		tp->undo_retrans--;

	return dup_sack;
}

1127
struct tcp_sacktag_state {
1128
	u32	reord;
1129 1130 1131 1132
	/* 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.
	 */
1133 1134
	u64	first_sackt;
	u64	last_sackt;
1135
	struct rate_sample *rate;
1136
	int	flag;
1137
	unsigned int mss_now;
1138 1139
};

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

	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)) {
1161
		mss = tcp_skb_mss(skb);
1162 1163
		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);

1164
		if (!in_sack) {
1165
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1166 1167 1168
			if (pkt_len < mss)
				pkt_len = mss;
		} else {
1169
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1170 1171 1172 1173 1174 1175 1176 1177 1178
			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;
1179
			if (!in_sack && new_len < pkt_len)
1180 1181 1182
				new_len += mss;
			pkt_len = new_len;
		}
1183 1184 1185 1186

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

1187 1188
		err = tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
				   pkt_len, mss, GFP_ATOMIC);
1189 1190 1191 1192 1193 1194 1195
		if (err < 0)
			return err;
	}

	return in_sack;
}

1196 1197 1198 1199
/* 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,
1200
			  int dup_sack, int pcount,
1201
			  u64 xmit_time)
1202
{
1203
	struct tcp_sock *tp = tcp_sk(sk);
1204 1205 1206

	/* Account D-SACK for retransmitted packet. */
	if (dup_sack && (sacked & TCPCB_RETRANS)) {
Y
Yuchung Cheng 已提交
1207
		if (tp->undo_marker && tp->undo_retrans > 0 &&
1208
		    after(end_seq, tp->undo_marker))
1209
			tp->undo_retrans--;
1210 1211 1212
		if ((sacked & TCPCB_SACKED_ACKED) &&
		    before(start_seq, state->reord))
				state->reord = start_seq;
1213 1214 1215
	}

	/* Nothing to do; acked frame is about to be dropped (was ACKed). */
1216
	if (!after(end_seq, tp->snd_una))
1217
		return sacked;
1218 1219

	if (!(sacked & TCPCB_SACKED_ACKED)) {
1220
		tcp_rack_advance(tp, sacked, end_seq, xmit_time);
1221

1222 1223 1224 1225 1226 1227
		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) {
1228
				sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
1229 1230
				tp->lost_out -= pcount;
				tp->retrans_out -= pcount;
1231 1232 1233 1234 1235 1236
			}
		} else {
			if (!(sacked & TCPCB_RETRANS)) {
				/* New sack for not retransmitted frame,
				 * which was in hole. It is reordering.
				 */
1237
				if (before(start_seq,
1238 1239 1240 1241
					   tcp_highest_sack_seq(tp)) &&
				    before(start_seq, state->reord))
					state->reord = start_seq;

Y
Yuchung Cheng 已提交
1242 1243
				if (!after(end_seq, tp->high_seq))
					state->flag |= FLAG_ORIG_SACK_ACKED;
1244 1245 1246
				if (state->first_sackt == 0)
					state->first_sackt = xmit_time;
				state->last_sackt = xmit_time;
1247 1248 1249
			}

			if (sacked & TCPCB_LOST) {
1250
				sacked &= ~TCPCB_LOST;
1251
				tp->lost_out -= pcount;
1252 1253 1254
			}
		}

1255 1256
		sacked |= TCPCB_SACKED_ACKED;
		state->flag |= FLAG_DATA_SACKED;
1257
		tp->sacked_out += pcount;
Y
Yuchung Cheng 已提交
1258
		tp->delivered += pcount;  /* Out-of-order packets delivered */
1259 1260

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
Y
Yuchung Cheng 已提交
1261
		if (tp->lost_skb_hint &&
1262
		    before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
1263
			tp->lost_cnt_hint += pcount;
1264 1265 1266 1267 1268 1269
	}

	/* 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.
	 */
1270 1271
	if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
		sacked &= ~TCPCB_SACKED_RETRANS;
1272
		tp->retrans_out -= pcount;
1273 1274
	}

1275
	return sacked;
1276 1277
}

1278 1279 1280
/* Shift newly-SACKed bytes from this skb to the immediately previous
 * already-SACKed sk_buff. Mark the newly-SACKed bytes as such.
 */
1281 1282
static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *prev,
			    struct sk_buff *skb,
E
Eric Dumazet 已提交
1283 1284 1285
			    struct tcp_sacktag_state *state,
			    unsigned int pcount, int shifted, int mss,
			    bool dup_sack)
1286 1287
{
	struct tcp_sock *tp = tcp_sk(sk);
1288 1289
	u32 start_seq = TCP_SKB_CB(skb)->seq;	/* start of newly-SACKed */
	u32 end_seq = start_seq + shifted;	/* end of newly-SACKed */
1290 1291 1292

	BUG_ON(!pcount);

1293 1294 1295 1296 1297 1298 1299
	/* 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 已提交
1300
			start_seq, end_seq, dup_sack, pcount,
1301
			skb->skb_mstamp);
1302
	tcp_rate_skb_delivered(sk, skb, state->rate);
1303 1304

	if (skb == tp->lost_skb_hint)
1305 1306
		tp->lost_cnt_hint += pcount;

1307 1308 1309
	TCP_SKB_CB(prev)->end_seq += shifted;
	TCP_SKB_CB(skb)->seq += shifted;

1310 1311 1312
	tcp_skb_pcount_add(prev, pcount);
	BUG_ON(tcp_skb_pcount(skb) < pcount);
	tcp_skb_pcount_add(skb, -pcount);
1313 1314 1315 1316 1317 1318

	/* 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.
	 */
1319 1320
	if (!TCP_SKB_CB(prev)->tcp_gso_size)
		TCP_SKB_CB(prev)->tcp_gso_size = mss;
1321 1322

	/* CHECKME: To clear or not to clear? Mimics normal skb currently */
1323
	if (tcp_skb_pcount(skb) <= 1)
1324
		TCP_SKB_CB(skb)->tcp_gso_size = 0;
1325 1326 1327 1328 1329 1330

	/* 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));
1331
		NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTED);
E
Eric Dumazet 已提交
1332
		return false;
1333 1334 1335 1336
	}

	/* Whole SKB was eaten :-) */

1337 1338 1339 1340 1341 1342 1343
	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);
	}

1344
	TCP_SKB_CB(prev)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
1345
	TCP_SKB_CB(prev)->eor = TCP_SKB_CB(skb)->eor;
1346 1347 1348
	if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
		TCP_SKB_CB(prev)->end_seq++;

1349 1350 1351
	if (skb == tcp_highest_sack(sk))
		tcp_advance_highest_sack(sk, skb);

1352
	tcp_skb_collapse_tstamp(prev, skb);
1353 1354
	if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp))
		TCP_SKB_CB(prev)->tx.delivered_mstamp = 0;
1355

1356
	tcp_rtx_queue_unlink_and_free(skb, sk);
1357

1358
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
1359

E
Eric Dumazet 已提交
1360
	return true;
1361 1362 1363 1364 1365
}

/* I wish gso_size would have a bit more sane initialization than
 * something-or-zero which complicates things
 */
1366
static int tcp_skb_seglen(const struct sk_buff *skb)
1367
{
1368
	return tcp_skb_pcount(skb) == 1 ? skb->len : tcp_skb_mss(skb);
1369 1370 1371
}

/* Shifting pages past head area doesn't work */
1372
static int skb_can_shift(const struct sk_buff *skb)
1373 1374 1375 1376 1377 1378 1379 1380
{
	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,
1381
					  struct tcp_sacktag_state *state,
1382
					  u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1383
					  bool dup_sack)
1384 1385 1386 1387 1388 1389 1390 1391 1392 1393
{
	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 &&
1394
	    (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1395 1396 1397 1398 1399 1400 1401 1402
		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 */
1403 1404
	prev = skb_rb_prev(skb);
	if (!prev)
1405 1406 1407 1408 1409
		goto fallback;

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

1410 1411 1412
	if (!tcp_skb_can_collapse_to(prev))
		goto fallback;

1413 1414 1415 1416 1417 1418
	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);
1419
		mss = tcp_skb_seglen(skb);
1420 1421 1422 1423

		/* TODO: Fix DSACKs to not fragment already SACKed and we can
		 * drop this restriction as unnecessary
		 */
1424
		if (mss != tcp_skb_seglen(prev))
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 1455 1456 1457 1458 1459 1460 1461 1462 1463 1464
			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
		 */
1465
		if (mss != tcp_skb_seglen(prev))
1466 1467 1468 1469 1470 1471 1472 1473 1474 1475 1476 1477
			goto fallback;

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

1478 1479 1480 1481
	/* tcp_sacktag_one() won't SACK-tag ranges below snd_una */
	if (!after(TCP_SKB_CB(skb)->seq + len, tp->snd_una))
		goto fallback;

1482 1483
	if (!skb_shift(prev, skb, len))
		goto fallback;
1484
	if (!tcp_shifted_skb(sk, prev, skb, state, pcount, len, mss, dup_sack))
1485 1486 1487 1488 1489
		goto out;

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

1494 1495
	if (!skb_can_shift(skb) ||
	    ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1496
	    (mss != tcp_skb_seglen(skb)))
1497 1498 1499 1500 1501
		goto out;

	len = skb->len;
	if (skb_shift(prev, skb, len)) {
		pcount += tcp_skb_pcount(skb);
1502 1503
		tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb),
				len, mss, 0);
1504 1505 1506 1507 1508 1509 1510 1511 1512
	}

out:
	return prev;

noop:
	return skb;

fallback:
1513
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1514 1515 1516
	return NULL;
}

1517 1518
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
1519
					struct tcp_sacktag_state *state,
1520
					u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1521
					bool dup_sack_in)
1522
{
1523 1524 1525
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *tmp;

1526
	skb_rbtree_walk_from(skb) {
1527
		int in_sack = 0;
E
Eric Dumazet 已提交
1528
		bool dup_sack = dup_sack_in;
1529 1530 1531 1532 1533

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

1534
		if (next_dup  &&
1535 1536 1537 1538 1539
		    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 已提交
1540
				dup_sack = true;
1541 1542
		}

1543 1544 1545 1546 1547
		/* 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) {
1548 1549
			tmp = tcp_shift_skb_data(sk, skb, state,
						 start_seq, end_seq, dup_sack);
1550
			if (tmp) {
1551 1552 1553 1554 1555 1556 1557 1558 1559 1560 1561 1562 1563
				if (tmp != skb) {
					skb = tmp;
					continue;
				}

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

1564 1565 1566
		if (unlikely(in_sack < 0))
			break;

1567
		if (in_sack) {
1568 1569 1570 1571 1572 1573 1574
			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 已提交
1575
						tcp_skb_pcount(skb),
1576
						skb->skb_mstamp);
1577
			tcp_rate_skb_delivered(sk, skb, state->rate);
1578 1579
			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
				list_del_init(&skb->tcp_tsorted_anchor);
1580

1581 1582 1583 1584
			if (!before(TCP_SKB_CB(skb)->seq,
				    tcp_highest_sack_seq(tp)))
				tcp_advance_highest_sack(sk, skb);
		}
1585 1586 1587 1588
	}
	return skb;
}

1589 1590 1591 1592 1593 1594 1595 1596 1597 1598 1599 1600 1601 1602 1603 1604 1605 1606 1607 1608 1609 1610 1611
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;
}

1612
static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,
1613 1614
					struct tcp_sacktag_state *state,
					u32 skip_to_seq)
1615
{
1616 1617
	if (skb && after(TCP_SKB_CB(skb)->seq, skip_to_seq))
		return skb;
1618

1619
	return tcp_sacktag_bsearch(sk, state, skip_to_seq);
1620 1621 1622 1623 1624
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
1625 1626
						struct tcp_sacktag_state *state,
						u32 skip_to_seq)
1627
{
1628
	if (!next_dup)
1629 1630 1631
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1632 1633 1634 1635
		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);
1636 1637 1638 1639 1640
	}

	return skb;
}

1641
static int tcp_sack_cache_ok(const struct tcp_sock *tp, const struct tcp_sack_block *cache)
1642 1643 1644 1645
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

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

1663
	state->flag = 0;
1664
	state->reord = tp->snd_nxt;
1665

1666
	if (!tp->sacked_out)
1667
		tcp_highest_sack_reset(sk);
L
Linus Torvalds 已提交
1668

1669
	found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,
1670
					 num_sacks, prior_snd_una);
1671
	if (found_dup_sack) {
1672
		state->flag |= FLAG_DSACKING_ACK;
1673 1674
		tp->delivered++; /* A spurious retransmission is delivered */
	}
1675 1676 1677 1678 1679 1680 1681 1682

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

1683 1684 1685
	if (!tp->packets_out)
		goto out;

1686 1687 1688
	used_sacks = 0;
	first_sack_index = 0;
	for (i = 0; i < num_sacks; i++) {
E
Eric Dumazet 已提交
1689
		bool dup_sack = !i && found_dup_sack;
1690

1691 1692
		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);
1693 1694 1695 1696

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

1699 1700
			if (dup_sack) {
				if (!tp->undo_marker)
1701
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;
1702
				else
1703
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;
1704 1705 1706 1707 1708
			} 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;
1709
				mib_idx = LINUX_MIB_TCPSACKDISCARD;
1710
			}
1711

1712
			NET_INC_STATS(sock_net(sk), mib_idx);
1713 1714 1715 1716 1717 1718 1719 1720 1721 1722 1723 1724
			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++;
	}

1725 1726
	/* order SACK blocks to allow in order walk of the retrans queue */
	for (i = used_sacks - 1; i > 0; i--) {
1727 1728
		for (j = 0; j < i; j++) {
			if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1729
				swap(sp[j], sp[j + 1]);
1730

1731 1732
				/* Track where the first SACK block goes to */
				if (j == first_sack_index)
1733
					first_sack_index = j + 1;
1734 1735 1736 1737
			}
		}
	}

1738 1739
	state->mss_now = tcp_current_mss(sk);
	skb = NULL;
1740 1741 1742 1743 1744 1745 1746 1747 1748 1749 1750
	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++;
1751 1752
	}

1753
	while (i < used_sacks) {
1754 1755
		u32 start_seq = sp[i].start_seq;
		u32 end_seq = sp[i].end_seq;
E
Eric Dumazet 已提交
1756
		bool dup_sack = (found_dup_sack && (i == first_sack_index));
1757
		struct tcp_sack_block *next_dup = NULL;
1758

1759 1760
		if (found_dup_sack && ((i + 1) == first_sack_index))
			next_dup = &sp[i + 1];
L
Linus Torvalds 已提交
1761

1762 1763 1764 1765 1766 1767 1768 1769 1770 1771 1772
		/* 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)) {
1773
				skb = tcp_sacktag_skip(skb, sk, state,
1774
						       start_seq);
1775
				skb = tcp_sacktag_walk(skb, sk, next_dup,
1776
						       state,
1777 1778
						       start_seq,
						       cache->start_seq,
1779
						       dup_sack);
1780
			}
1781

1782
			/* Rest of the block already fully processed? */
1783
			if (!after(end_seq, cache->end_seq))
1784
				goto advance_sp;
1785

1786
			skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
1787
						       state,
1788
						       cache->end_seq);
1789

1790
			/* ...tail remains todo... */
1791
			if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1792
				/* ...but better entrypoint exists! */
1793
				skb = tcp_highest_sack(sk);
1794
				if (!skb)
1795
					break;
1796 1797
				cache++;
				goto walk;
1798 1799
			}

1800
			skb = tcp_sacktag_skip(skb, sk, state, cache->end_seq);
1801 1802 1803 1804
			/* Check overlap against next cached too (past this one already) */
			cache++;
			continue;
		}
L
Linus Torvalds 已提交
1805

1806 1807
		if (!before(start_seq, tcp_highest_sack_seq(tp))) {
			skb = tcp_highest_sack(sk);
1808
			if (!skb)
1809
				break;
L
Linus Torvalds 已提交
1810
		}
1811
		skb = tcp_sacktag_skip(skb, sk, state, start_seq);
1812 1813

walk:
1814
		skb = tcp_sacktag_walk(skb, sk, next_dup, state,
1815
				       start_seq, end_seq, dup_sack);
1816

1817 1818
advance_sp:
		i++;
L
Linus Torvalds 已提交
1819 1820
	}

1821 1822 1823 1824 1825 1826 1827 1828
	/* 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];

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

1832
	tcp_verify_left_out(tp);
1833 1834
out:

L
Linus Torvalds 已提交
1835
#if FASTRETRANS_DEBUG > 0
1836 1837 1838 1839
	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 已提交
1840
#endif
1841
	return state->flag;
L
Linus Torvalds 已提交
1842 1843
}

1844
/* Limits sacked_out so that sum with lost_out isn't ever larger than
E
Eric Dumazet 已提交
1845
 * packets_out. Returns false if sacked_out adjustement wasn't necessary.
1846
 */
E
Eric Dumazet 已提交
1847
static bool tcp_limit_reno_sacked(struct tcp_sock *tp)
1848 1849 1850 1851 1852 1853 1854 1855
{
	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 已提交
1856
		return true;
1857
	}
E
Eric Dumazet 已提交
1858
	return false;
1859 1860 1861 1862 1863 1864 1865 1866 1867
}

/* 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);
1868 1869 1870 1871 1872 1873 1874

	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);
1875 1876 1877 1878 1879 1880 1881
}

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

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

/* 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 已提交
1899
		tp->delivered += max_t(int, acked - tp->sacked_out, 1);
1900
		if (acked - 1 >= tp->sacked_out)
1901 1902
			tp->sacked_out = 0;
		else
1903
			tp->sacked_out -= acked - 1;
1904 1905
	}
	tcp_check_reno_reordering(sk, acked);
1906
	tcp_verify_left_out(tp);
1907 1908 1909 1910 1911 1912 1913
}

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

Y
Yuchung Cheng 已提交
1914
void tcp_clear_retrans(struct tcp_sock *tp)
L
Linus Torvalds 已提交
1915 1916 1917 1918
{
	tp->retrans_out = 0;
	tp->lost_out = 0;
	tp->undo_marker = 0;
Y
Yuchung Cheng 已提交
1919
	tp->undo_retrans = -1;
Y
Yuchung Cheng 已提交
1920
	tp->sacked_out = 0;
L
Linus Torvalds 已提交
1921 1922
}

Y
Yuchung Cheng 已提交
1923
static inline void tcp_init_undo(struct tcp_sock *tp)
1924
{
Y
Yuchung Cheng 已提交
1925 1926 1927
	tp->undo_marker = tp->snd_una;
	/* Retransmission still in flight may cause DSACKs later. */
	tp->undo_retrans = tp->retrans_out ? : -1;
1928 1929
}

1930 1931 1932 1933 1934
static bool tcp_is_rack(const struct sock *sk)
{
	return sock_net(sk)->ipv4.sysctl_tcp_recovery & TCP_RACK_LOSS_DETECTION;
}

1935
/* If we detect SACK reneging, forget all SACK information
L
Linus Torvalds 已提交
1936 1937 1938
 * and reset tags completely, otherwise preserve SACKs. If receiver
 * dropped its ofo queue, we will know this due to reneging detection.
 */
1939 1940 1941
static void tcp_timeout_mark_lost(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
1942
	struct sk_buff *skb, *head;
1943 1944
	bool is_reneg;			/* is receiver reneging on SACKs? */

1945 1946
	head = tcp_rtx_queue_head(sk);
	is_reneg = head && (TCP_SKB_CB(head)->sacked & TCPCB_SACKED_ACKED);
1947 1948 1949 1950 1951 1952 1953 1954 1955
	if (is_reneg) {
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
		tp->sacked_out = 0;
		/* Mark SACK reneging until we recover from this loss event. */
		tp->is_sack_reneg = 1;
	} else if (tcp_is_reno(tp)) {
		tcp_reset_reno_sack(tp);
	}

1956
	skb = head;
1957 1958 1959
	skb_rbtree_walk_from(skb) {
		if (is_reneg)
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
1960 1961 1962
		else if (tcp_is_rack(sk) && skb != head &&
			 tcp_rack_skb_timeout(tp, skb, 0) > 0)
			continue; /* Don't mark recently sent ones lost yet */
1963 1964 1965 1966 1967 1968 1969
		tcp_mark_skb_lost(sk, skb);
	}
	tcp_verify_left_out(tp);
	tcp_clear_all_retrans_hints(tp);
}

/* Enter Loss state. */
1970
void tcp_enter_loss(struct sock *sk)
L
Linus Torvalds 已提交
1971
{
1972
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1973
	struct tcp_sock *tp = tcp_sk(sk);
1974
	struct net *net = sock_net(sk);
1975
	bool new_recovery = icsk->icsk_ca_state < TCP_CA_Recovery;
L
Linus Torvalds 已提交
1976

1977 1978
	tcp_timeout_mark_lost(sk);

L
Linus Torvalds 已提交
1979
	/* Reduce ssthresh if it has not yet been made inside this window. */
Y
Yuchung Cheng 已提交
1980 1981
	if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
	    !after(tp->high_seq, tp->snd_una) ||
1982 1983
	    (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
1984
		tp->prior_cwnd = tp->snd_cwnd;
1985 1986
		tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		tcp_ca_event(sk, CA_EVENT_LOSS);
Y
Yuchung Cheng 已提交
1987
		tcp_init_undo(tp);
L
Linus Torvalds 已提交
1988
	}
1989
	tp->snd_cwnd	   = tcp_packets_in_flight(tp) + 1;
L
Linus Torvalds 已提交
1990
	tp->snd_cwnd_cnt   = 0;
1991
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
1992

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

2004 2005 2006
	/* 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 已提交
2007
	 */
E
Eric Dumazet 已提交
2008
	tp->frto = net->ipv4.sysctl_tcp_frto &&
2009 2010
		   (new_recovery || icsk->icsk_retransmits) &&
		   !inet_csk(sk)->icsk_mtup.probe_size;
L
Linus Torvalds 已提交
2011 2012
}

2013 2014 2015 2016
/* 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).
 *
2017 2018 2019 2020 2021
 * 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.
2022
 */
E
Eric Dumazet 已提交
2023
static bool tcp_check_sack_reneging(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2024
{
2025
	if (flag & FLAG_SACK_RENEGING) {
2026 2027 2028
		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 已提交
2029

2030
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2031
					  delay, TCP_RTO_MAX);
E
Eric Dumazet 已提交
2032
		return true;
L
Linus Torvalds 已提交
2033
	}
E
Eric Dumazet 已提交
2034
	return false;
L
Linus Torvalds 已提交
2035 2036
}

2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047
/* 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.
 */
2048
static inline int tcp_dupack_heuristics(const struct tcp_sock *tp)
2049
{
Y
Yuchung Cheng 已提交
2050
	return tp->sacked_out + 1;
2051 2052
}

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

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

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

E
Eric Dumazet 已提交
2162
	return false;
L
Linus Torvalds 已提交
2163 2164
}

2165
/* Detect loss in event "A" above by marking head of queue up as lost.
Y
Yuchung Cheng 已提交
2166
 * For non-SACK(Reno) senders, the first "packets" number of segments
2167 2168 2169
 * 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.
2170
 */
I
Ilpo Järvinen 已提交
2171
static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
L
Linus Torvalds 已提交
2172
{
2173
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2174
	struct sk_buff *skb;
2175
	int cnt, oldcnt, lost;
2176
	unsigned int mss;
2177 2178
	/* 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 已提交
2179

2180
	WARN_ON(packets > tp->packets_out);
2181 2182
	skb = tp->lost_skb_hint;
	if (skb) {
I
Ilpo Järvinen 已提交
2183
		/* Head already handled? */
2184
		if (mark_head && after(TCP_SKB_CB(skb)->seq, tp->snd_una))
I
Ilpo Järvinen 已提交
2185
			return;
2186
		cnt = tp->lost_cnt_hint;
2187
	} else {
2188
		skb = tcp_rtx_queue_head(sk);
2189 2190
		cnt = 0;
	}
L
Linus Torvalds 已提交
2191

2192
	skb_rbtree_walk_from(skb) {
2193 2194 2195 2196
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2197

2198
		if (after(TCP_SKB_CB(skb)->end_seq, loss_high))
2199 2200 2201
			break;

		oldcnt = cnt;
Y
Yuchung Cheng 已提交
2202
		if (tcp_is_reno(tp) ||
2203 2204 2205
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

2206
		if (cnt > packets) {
Y
Yuchung Cheng 已提交
2207
			if (tcp_is_sack(tp) ||
2208
			    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
2209
			    (oldcnt >= packets))
2210 2211
				break;

2212
			mss = tcp_skb_mss(skb);
2213 2214 2215
			/* If needed, chop off the prefix to mark as lost. */
			lost = (packets - oldcnt) * mss;
			if (lost < skb->len &&
2216 2217
			    tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
					 lost, mss, GFP_ATOMIC) < 0)
2218 2219 2220 2221
				break;
			cnt = packets;
		}

2222
		tcp_skb_mark_lost(tp, skb);
I
Ilpo Järvinen 已提交
2223 2224 2225

		if (mark_head)
			break;
L
Linus Torvalds 已提交
2226
	}
2227
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2228 2229 2230 2231
}

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

2232
static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
L
Linus Torvalds 已提交
2233
{
2234 2235
	struct tcp_sock *tp = tcp_sk(sk);

2236
	if (tcp_is_sack(tp)) {
2237
		int sacked_upto = tp->sacked_out - tp->reordering;
I
Ilpo Järvinen 已提交
2238 2239 2240 2241
		if (sacked_upto >= 0)
			tcp_mark_head_lost(sk, sacked_upto, 0);
		else if (fast_rexmit)
			tcp_mark_head_lost(sk, 1, 1);
L
Linus Torvalds 已提交
2242 2243 2244
	}
}

2245 2246 2247 2248 2249 2250
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);
}

2251 2252 2253 2254 2255 2256 2257 2258 2259 2260
/* 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 已提交
2261 2262 2263
/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
2264
static inline bool tcp_packet_delayed(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2265 2266
{
	return !tp->retrans_stamp ||
2267
	       tcp_tsopt_ecr_before(tp, tp->retrans_stamp);
L
Linus Torvalds 已提交
2268 2269 2270 2271
}

/* Undo procedures. */

2272 2273 2274 2275 2276 2277 2278 2279 2280 2281 2282 2283 2284 2285 2286 2287 2288 2289 2290 2291 2292 2293
/* 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;

2294
	skb = tcp_rtx_queue_head(sk);
2295 2296 2297 2298 2299 2300
	if (unlikely(skb && TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS))
		return true;

	return false;
}

2301
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2302
{
J
Joe Perches 已提交
2303
#if FASTRETRANS_DEBUG > 1
2304
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2305
	struct inet_sock *inet = inet_sk(sk);
2306

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

2328
static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
L
Linus Torvalds 已提交
2329
{
2330 2331
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2332 2333 2334
	if (unmark_loss) {
		struct sk_buff *skb;

2335
		skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
Y
Yuchung Cheng 已提交
2336 2337 2338 2339 2340 2341
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
		}
		tp->lost_out = 0;
		tcp_clear_all_retrans_hints(tp);
	}

L
Linus Torvalds 已提交
2342
	if (tp->prior_ssthresh) {
2343 2344
		const struct inet_connection_sock *icsk = inet_csk(sk);

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

2347
		if (tp->prior_ssthresh > tp->snd_ssthresh) {
L
Linus Torvalds 已提交
2348
			tp->snd_ssthresh = tp->prior_ssthresh;
2349
			tcp_ecn_withdraw_cwr(tp);
L
Linus Torvalds 已提交
2350 2351
		}
	}
2352
	tp->snd_cwnd_stamp = tcp_jiffies32;
2353
	tp->undo_marker = 0;
2354
	tp->rack.advanced = 1; /* Force RACK to re-exam losses */
L
Linus Torvalds 已提交
2355 2356
}

2357
static inline bool tcp_may_undo(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2358
{
2359
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2360 2361 2362
}

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

L
Linus Torvalds 已提交
2367
	if (tcp_may_undo(tp)) {
2368 2369
		int mib_idx;

L
Linus Torvalds 已提交
2370 2371 2372
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2373
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2374
		tcp_undo_cwnd_reduction(sk, false);
2375
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2376
			mib_idx = LINUX_MIB_TCPLOSSUNDO;
L
Linus Torvalds 已提交
2377
		else
2378 2379
			mib_idx = LINUX_MIB_TCPFULLUNDO;

2380
		NET_INC_STATS(sock_net(sk), mib_idx);
2381 2382
	} else if (tp->rack.reo_wnd_persist) {
		tp->rack.reo_wnd_persist--;
L
Linus Torvalds 已提交
2383
	}
2384
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2385 2386 2387
		/* 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. */
2388 2389
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;
E
Eric Dumazet 已提交
2390
		return true;
L
Linus Torvalds 已提交
2391
	}
2392
	tcp_set_ca_state(sk, TCP_CA_Open);
2393
	tp->is_sack_reneg = 0;
E
Eric Dumazet 已提交
2394
	return false;
L
Linus Torvalds 已提交
2395 2396 2397
}

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

L
Linus Torvalds 已提交
2402
	if (tp->undo_marker && !tp->undo_retrans) {
2403 2404
		tp->rack.reo_wnd_persist = min(TCP_RACK_RECOVERY_THRESH,
					       tp->rack.reo_wnd_persist + 1);
2405
		DBGUNDO(sk, "D-SACK");
2406
		tcp_undo_cwnd_reduction(sk, false);
2407
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
2408
		return true;
L
Linus Torvalds 已提交
2409
	}
2410
	return false;
L
Linus Torvalds 已提交
2411 2412
}

Y
Yuchung Cheng 已提交
2413 2414
/* 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 已提交
2415
{
2416 2417
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2418
	if (frto_undo || tcp_may_undo(tp)) {
2419
		tcp_undo_cwnd_reduction(sk, true);
2420

2421
		DBGUNDO(sk, "partial loss");
2422
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
Y
Yuchung Cheng 已提交
2423
		if (frto_undo)
2424
			NET_INC_STATS(sock_net(sk),
2425
					LINUX_MIB_TCPSPURIOUSRTOS);
2426
		inet_csk(sk)->icsk_retransmits = 0;
2427
		if (frto_undo || tcp_is_sack(tp)) {
2428
			tcp_set_ca_state(sk, TCP_CA_Open);
2429 2430
			tp->is_sack_reneg = 0;
		}
E
Eric Dumazet 已提交
2431
		return true;
L
Linus Torvalds 已提交
2432
	}
E
Eric Dumazet 已提交
2433
	return false;
L
Linus Torvalds 已提交
2434 2435
}

2436
/* The cwnd reduction in CWR and Recovery uses the PRR algorithm in RFC 6937.
2437 2438 2439 2440
 * 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.
2441 2442 2443
 *   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.
2444
 */
2445
static void tcp_init_cwnd_reduction(struct sock *sk)
2446 2447 2448 2449
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->high_seq = tp->snd_nxt;
N
Nandita Dukkipati 已提交
2450
	tp->tlp_high_seq = 0;
2451 2452 2453 2454
	tp->snd_cwnd_cnt = 0;
	tp->prior_cwnd = tp->snd_cwnd;
	tp->prr_delivered = 0;
	tp->prr_out = 0;
2455
	tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);
2456
	tcp_ecn_queue_cwr(tp);
2457 2458
}

2459
void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int flag)
2460 2461 2462 2463 2464
{
	struct tcp_sock *tp = tcp_sk(sk);
	int sndcnt = 0;
	int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);

2465 2466 2467
	if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))
		return;

2468
	tp->prr_delivered += newly_acked_sacked;
2469
	if (delta < 0) {
2470 2471 2472
		u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
			       tp->prior_cwnd - 1;
		sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;
2473 2474
	} else if ((flag & FLAG_RETRANS_DATA_ACKED) &&
		   !(flag & FLAG_LOST_RETRANS)) {
2475 2476 2477
		sndcnt = min_t(int, delta,
			       max_t(int, tp->prr_delivered - tp->prr_out,
				     newly_acked_sacked) + 1);
2478 2479
	} else {
		sndcnt = min(delta, newly_acked_sacked);
2480
	}
2481 2482
	/* Force a fast retransmit upon entering fast recovery */
	sndcnt = max(sndcnt, (tp->prr_out ? 0 : 1));
2483 2484 2485
	tp->snd_cwnd = tcp_packets_in_flight(tp) + sndcnt;
}

2486
static inline void tcp_end_cwnd_reduction(struct sock *sk)
L
Linus Torvalds 已提交
2487
{
2488
	struct tcp_sock *tp = tcp_sk(sk);
2489

2490 2491 2492
	if (inet_csk(sk)->icsk_ca_ops->cong_control)
		return;

2493
	/* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
2494 2495
	if (tp->snd_ssthresh < TCP_INFINITE_SSTHRESH &&
	    (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR || tp->undo_marker)) {
2496
		tp->snd_cwnd = tp->snd_ssthresh;
2497
		tp->snd_cwnd_stamp = tcp_jiffies32;
2498
	}
2499
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2500 2501
}

2502
/* Enter CWR state. Disable cwnd undo since congestion is proven with ECN */
2503
void tcp_enter_cwr(struct sock *sk)
Y
Yuchung Cheng 已提交
2504 2505 2506 2507
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->prior_ssthresh = 0;
2508
	if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
Y
Yuchung Cheng 已提交
2509
		tp->undo_marker = 0;
2510
		tcp_init_cwnd_reduction(sk);
Y
Yuchung Cheng 已提交
2511 2512 2513
		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}
2514
EXPORT_SYMBOL(tcp_enter_cwr);
Y
Yuchung Cheng 已提交
2515

2516 2517 2518 2519 2520
static void tcp_try_keep_open(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int state = TCP_CA_Open;

2521
	if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
2522 2523 2524 2525 2526 2527 2528 2529
		state = TCP_CA_Disorder;

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

2530
static void tcp_try_to_open(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2531
{
2532 2533
	struct tcp_sock *tp = tcp_sk(sk);

2534 2535
	tcp_verify_left_out(tp);

Y
Yuchung Cheng 已提交
2536
	if (!tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2537 2538
		tp->retrans_stamp = 0;

2539
	if (flag & FLAG_ECE)
2540
		tcp_enter_cwr(sk);
L
Linus Torvalds 已提交
2541

2542
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2543
		tcp_try_keep_open(sk);
L
Linus Torvalds 已提交
2544 2545 2546
	}
}

J
John Heffner 已提交
2547 2548 2549 2550 2551 2552
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;
2553
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
J
John Heffner 已提交
2554 2555
}

2556
static void tcp_mtup_probe_success(struct sock *sk)
J
John Heffner 已提交
2557 2558 2559 2560 2561 2562 2563 2564 2565 2566
{
	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;
2567
	tp->snd_cwnd_stamp = tcp_jiffies32;
2568
	tp->snd_ssthresh = tcp_current_ssthresh(sk);
J
John Heffner 已提交
2569 2570 2571 2572

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

2576 2577 2578 2579 2580 2581 2582 2583 2584
/* 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 已提交
2585
	unsigned int mss = tcp_current_mss(sk);
2586

2587
	skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
2588
		if (tcp_skb_seglen(skb) > mss &&
2589 2590 2591 2592 2593 2594 2595 2596 2597 2598 2599
		    !(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);

2600
	if (!tp->lost_out)
2601 2602 2603 2604 2605 2606 2607 2608 2609 2610 2611 2612 2613 2614 2615 2616 2617 2618 2619 2620 2621
		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 已提交
2622
EXPORT_SYMBOL(tcp_simple_retransmit);
2623

2624
void tcp_enter_recovery(struct sock *sk, bool ece_ack)
2625 2626 2627 2628 2629 2630 2631 2632 2633
{
	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;

2634
	NET_INC_STATS(sock_net(sk), mib_idx);
2635 2636

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

2639
	if (!tcp_in_cwnd_reduction(sk)) {
2640 2641
		if (!ece_ack)
			tp->prior_ssthresh = tcp_current_ssthresh(sk);
2642
		tcp_init_cwnd_reduction(sk);
2643 2644 2645 2646
	}
	tcp_set_ca_state(sk, TCP_CA_Recovery);
}

2647 2648 2649
/* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
 * recovered or spurious. Otherwise retransmits more on partial ACKs.
 */
2650 2651
static void tcp_process_loss(struct sock *sk, int flag, bool is_dupack,
			     int *rexmit)
2652 2653
{
	struct tcp_sock *tp = tcp_sk(sk);
Y
Yuchung Cheng 已提交
2654
	bool recovered = !before(tp->snd_una, tp->high_seq);
2655

2656 2657 2658 2659
	if ((flag & FLAG_SND_UNA_ADVANCED) &&
	    tcp_try_undo_loss(sk, false))
		return;

2660
	if (tp->frto) { /* F-RTO RFC5682 sec 3.1 (sack enhanced version). */
2661 2662 2663 2664 2665 2666 2667
		/* 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;

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

	if (recovered) {
		/* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
2688 2689 2690
		tcp_try_undo_recovery(sk);
		return;
	}
Y
Yuchung Cheng 已提交
2691 2692 2693 2694 2695 2696 2697 2698 2699
	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);
	}
2700
	*rexmit = REXMIT_LOST;
2701 2702
}

Y
Yuchung Cheng 已提交
2703
/* Undo during fast recovery after partial ACK. */
2704
static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una)
Y
Yuchung Cheng 已提交
2705 2706 2707
{
	struct tcp_sock *tp = tcp_sk(sk);

2708
	if (tp->undo_marker && tcp_packet_delayed(tp)) {
Y
Yuchung Cheng 已提交
2709
		/* Plain luck! Hole if filled with delayed
2710
		 * packet, rather than with a retransmit. Check reordering.
Y
Yuchung Cheng 已提交
2711
		 */
2712
		tcp_check_sack_reordering(sk, prior_snd_una, 1);
2713 2714 2715 2716 2717 2718

		/* 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.
		 */
2719
		if (tp->retrans_out)
2720 2721
			return true;

Y
Yuchung Cheng 已提交
2722 2723 2724
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;

2725 2726
		DBGUNDO(sk, "partial recovery");
		tcp_undo_cwnd_reduction(sk, true);
2727
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
2728 2729
		tcp_try_keep_open(sk);
		return true;
Y
Yuchung Cheng 已提交
2730
	}
2731
	return false;
Y
Yuchung Cheng 已提交
2732 2733
}

2734
static void tcp_identify_packet_loss(struct sock *sk, int *ack_flag)
2735 2736 2737
{
	struct tcp_sock *tp = tcp_sk(sk);

2738 2739 2740 2741 2742 2743
	if (tcp_rtx_queue_empty(sk))
		return;

	if (unlikely(tcp_is_reno(tp))) {
		tcp_newreno_mark_lost(sk, *ack_flag & FLAG_SND_UNA_ADVANCED);
	} else if (tcp_is_rack(sk)) {
2744 2745
		u32 prior_retrans = tp->retrans_out;

2746
		tcp_rack_mark_lost(sk);
2747 2748 2749 2750 2751
		if (prior_retrans > tp->retrans_out)
			*ack_flag |= FLAG_LOST_RETRANS;
	}
}

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

2781
	if (!tp->packets_out && tp->sacked_out)
L
Linus Torvalds 已提交
2782 2783
		tp->sacked_out = 0;

2784
	/* Now state machine starts.
L
Linus Torvalds 已提交
2785
	 * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
2786
	if (flag & FLAG_ECE)
L
Linus Torvalds 已提交
2787 2788 2789
		tp->prior_ssthresh = 0;

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

2793
	/* C. Check consistency of the current state. */
2794
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2795

2796
	/* D. Check state exit conditions. State can be terminated
L
Linus Torvalds 已提交
2797
	 *    when high_seq is ACKed. */
2798
	if (icsk->icsk_ca_state == TCP_CA_Open) {
2799
		WARN_ON(tp->retrans_out != 0);
L
Linus Torvalds 已提交
2800 2801
		tp->retrans_stamp = 0;
	} else if (!before(tp->snd_una, tp->high_seq)) {
2802
		switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2803 2804 2805 2806
		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) {
2807
				tcp_end_cwnd_reduction(sk);
2808
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2809 2810 2811 2812
			}
			break;

		case TCP_CA_Recovery:
2813
			if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
2814
				tcp_reset_reno_sack(tp);
2815
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
2816
				return;
2817
			tcp_end_cwnd_reduction(sk);
L
Linus Torvalds 已提交
2818 2819 2820 2821
			break;
		}
	}

2822
	/* E. Process state. */
2823
	switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2824
	case TCP_CA_Recovery:
2825
		if (!(flag & FLAG_SND_UNA_ADVANCED)) {
2826
			if (tcp_is_reno(tp) && is_dupack)
2827
				tcp_add_reno_sack(sk);
2828
		} else {
2829
			if (tcp_try_undo_partial(sk, prior_snd_una))
2830 2831 2832
				return;
			/* Partial ACK arrived. Force fast retransmit. */
			do_lost = tcp_is_reno(tp) ||
2833
				  tcp_force_fast_retransmit(sk);
2834
		}
2835 2836 2837 2838
		if (tcp_try_undo_dsack(sk)) {
			tcp_try_keep_open(sk);
			return;
		}
2839
		tcp_identify_packet_loss(sk, ack_flag);
L
Linus Torvalds 已提交
2840 2841
		break;
	case TCP_CA_Loss:
2842
		tcp_process_loss(sk, flag, is_dupack, rexmit);
2843
		tcp_identify_packet_loss(sk, ack_flag);
2844 2845
		if (!(icsk->icsk_ca_state == TCP_CA_Open ||
		      (*ack_flag & FLAG_LOST_RETRANS)))
L
Linus Torvalds 已提交
2846
			return;
2847
		/* Change state if cwnd is undone or retransmits are lost */
2848
		/* fall through */
L
Linus Torvalds 已提交
2849
	default:
2850
		if (tcp_is_reno(tp)) {
2851
			if (flag & FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
2852 2853
				tcp_reset_reno_sack(tp);
			if (is_dupack)
2854
				tcp_add_reno_sack(sk);
L
Linus Torvalds 已提交
2855 2856
		}

2857
		if (icsk->icsk_ca_state <= TCP_CA_Disorder)
2858
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2859

2860
		tcp_identify_packet_loss(sk, ack_flag);
2861
		if (!tcp_time_to_recover(sk, flag)) {
2862
			tcp_try_to_open(sk, flag);
L
Linus Torvalds 已提交
2863 2864 2865
			return;
		}

J
John Heffner 已提交
2866 2867 2868
		/* MTU probe failure: don't reduce cwnd */
		if (icsk->icsk_ca_state < TCP_CA_CWR &&
		    icsk->icsk_mtup.probe_size &&
2869
		    tp->snd_una == tp->mtu_probe.probe_seq_start) {
J
John Heffner 已提交
2870 2871 2872 2873 2874 2875 2876
			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 已提交
2877
		/* Otherwise enter Recovery state */
2878
		tcp_enter_recovery(sk, (flag & FLAG_ECE));
2879
		fast_rexmit = 1;
L
Linus Torvalds 已提交
2880 2881
	}

2882
	if (!tcp_is_rack(sk) && do_lost)
2883
		tcp_update_scoreboard(sk, fast_rexmit);
2884
	*rexmit = REXMIT_LOST;
L
Linus Torvalds 已提交
2885 2886
}

2887
static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us, const int flag)
2888
{
2889
	u32 wlen = sock_net(sk)->ipv4.sysctl_tcp_min_rtt_wlen * HZ;
2890 2891
	struct tcp_sock *tp = tcp_sk(sk);

2892 2893 2894 2895 2896 2897 2898
	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;
	}
2899
	minmax_running_min(&tp->rtt_min, wlen, tcp_jiffies32,
2900
			   rtt_us ? : jiffies_to_usecs(1));
2901 2902
}

2903 2904 2905
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)
2906
{
2907 2908 2909 2910 2911 2912 2913
	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).
	 */
2914 2915
	if (seq_rtt_us < 0)
		seq_rtt_us = sack_rtt_us;
Y
Yuchung Cheng 已提交
2916

L
Linus Torvalds 已提交
2917 2918 2919 2920 2921 2922
	/* 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.
	 */
2923
	if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2924 2925 2926 2927 2928 2929
	    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;
	}
2930
	rs->rtt_us = ca_rtt_us; /* RTT of last (S)ACKed packet (or -1) */
2931
	if (seq_rtt_us < 0)
Y
Yuchung Cheng 已提交
2932
		return false;
L
Linus Torvalds 已提交
2933

2934 2935 2936 2937
	/* 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.
	 */
2938
	tcp_update_rtt_min(sk, ca_rtt_us, flag);
2939
	tcp_rtt_estimator(sk, seq_rtt_us);
2940
	tcp_set_rto(sk);
L
Linus Torvalds 已提交
2941

2942 2943
	/* RFC6298: only reset backoff on valid RTT measurement. */
	inet_csk(sk)->icsk_backoff = 0;
Y
Yuchung Cheng 已提交
2944
	return true;
L
Linus Torvalds 已提交
2945 2946
}

2947
/* Compute time elapsed between (last) SYNACK and the ACK completing 3WHS. */
Y
Yuchung Cheng 已提交
2948
void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
2949
{
2950
	struct rate_sample rs;
Y
Yuchung Cheng 已提交
2951
	long rtt_us = -1L;
2952

2953 2954
	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 已提交
2955

2956
	tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us, &rs);
2957 2958
}

Y
Yuchung Cheng 已提交
2959

2960
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
L
Linus Torvalds 已提交
2961
{
2962
	const struct inet_connection_sock *icsk = inet_csk(sk);
2963 2964

	icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
2965
	tcp_sk(sk)->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
2966 2967 2968 2969 2970
}

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

2976 2977 2978 2979 2980 2981
	/* 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 已提交
2982
	if (!tp->packets_out) {
2983
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
2984
	} else {
2985 2986
		u32 rto = inet_csk(sk)->icsk_rto;
		/* Offset the time elapsed after installing regular RTO */
Y
Yuchung Cheng 已提交
2987
		if (icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
N
Nandita Dukkipati 已提交
2988
		    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
2989
			s64 delta_us = tcp_rto_delta_us(sk);
E
Eric Dumazet 已提交
2990
			/* delta_us may not be positive if the socket is locked
N
Nandita Dukkipati 已提交
2991
			 * when the retrans timer fires and is rescheduled.
2992
			 */
2993
			rto = usecs_to_jiffies(max_t(int, delta_us, 1));
2994 2995 2996
		}
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, rto,
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
2997
	}
2998 2999
}

3000 3001 3002
/* Try to schedule a loss probe; if that doesn't work, then schedule an RTO. */
static void tcp_set_xmit_timer(struct sock *sk)
{
3003
	if (!tcp_schedule_loss_probe(sk, true))
3004 3005 3006
		tcp_rearm_rto(sk);
}

3007
/* If we get here, the whole TSO packet has not been acked. */
3008
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
3009 3010
{
	struct tcp_sock *tp = tcp_sk(sk);
3011
	u32 packets_acked;
L
Linus Torvalds 已提交
3012

3013
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
3014 3015

	packets_acked = tcp_skb_pcount(skb);
3016
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
3017 3018 3019 3020 3021
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

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

3025
	return packets_acked;
L
Linus Torvalds 已提交
3026 3027
}

3028 3029 3030 3031 3032 3033
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 */
3034
	if (likely(!TCP_SKB_CB(skb)->txstamp_ack))
3035 3036 3037
		return;

	shinfo = skb_shinfo(skb);
3038
	if (!before(shinfo->tskey, prior_snd_una) &&
3039 3040 3041 3042 3043
	    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);
	}
3044 3045
}

3046 3047 3048 3049
/* 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.
 */
3050 3051
static int tcp_clean_rtx_queue(struct sock *sk, u32 prior_fack,
			       u32 prior_snd_una,
3052
			       struct tcp_sacktag_state *sack)
L
Linus Torvalds 已提交
3053
{
3054
	const struct inet_connection_sock *icsk = inet_csk(sk);
3055
	u64 first_ackt, last_ackt;
3056 3057
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_sacked = tp->sacked_out;
3058
	u32 reord = tp->snd_nxt; /* lowest acked un-retx un-sacked seq */
3059
	struct sk_buff *skb, *next;
3060
	bool fully_acked = true;
3061
	long sack_rtt_us = -1L;
3062
	long seq_rtt_us = -1L;
3063
	long ca_rtt_us = -1L;
3064
	u32 pkts_acked = 0;
3065
	u32 last_in_flight = 0;
3066
	bool rtt_update;
3067 3068
	int flag = 0;

3069
	first_ackt = 0;
L
Linus Torvalds 已提交
3070

3071
	for (skb = skb_rb_first(&sk->tcp_rtx_queue); skb; skb = next) {
3072
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3073
		const u32 start_seq = scb->seq;
3074
		u8 sacked = scb->sacked;
3075
		u32 acked_pcount;
L
Linus Torvalds 已提交
3076

3077
		tcp_ack_tstamp(sk, skb, prior_snd_una);
3078

3079
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
3080
		if (after(scb->end_seq, tp->snd_una)) {
3081 3082 3083 3084
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

3085 3086
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
3087
				break;
E
Eric Dumazet 已提交
3088
			fully_acked = false;
3089
		} else {
3090
			acked_pcount = tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
3091 3092
		}

3093
		if (unlikely(sacked & TCPCB_RETRANS)) {
3094
			if (sacked & TCPCB_SACKED_RETRANS)
3095
				tp->retrans_out -= acked_pcount;
3096
			flag |= FLAG_RETRANS_DATA_ACKED;
3097
		} else if (!(sacked & TCPCB_SACKED_ACKED)) {
3098
			last_ackt = skb->skb_mstamp;
3099 3100
			WARN_ON_ONCE(last_ackt == 0);
			if (!first_ackt)
3101 3102
				first_ackt = last_ackt;

3103
			last_in_flight = TCP_SKB_CB(skb)->tx.in_flight;
3104 3105
			if (before(start_seq, reord))
				reord = start_seq;
3106 3107
			if (!after(scb->end_seq, tp->high_seq))
				flag |= FLAG_ORIG_SACK_ACKED;
3108
		}
3109

Y
Yuchung Cheng 已提交
3110
		if (sacked & TCPCB_SACKED_ACKED) {
3111
			tp->sacked_out -= acked_pcount;
Y
Yuchung Cheng 已提交
3112 3113 3114
		} else if (tcp_is_sack(tp)) {
			tp->delivered += acked_pcount;
			if (!tcp_skb_spurious_retrans(tp, skb))
3115
				tcp_rack_advance(tp, sacked, scb->end_seq,
3116
						 skb->skb_mstamp);
Y
Yuchung Cheng 已提交
3117
		}
3118
		if (sacked & TCPCB_LOST)
3119
			tp->lost_out -= acked_pcount;
3120

3121 3122
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
3123
		tcp_rate_skb_delivered(sk, skb, sack->rate);
3124

3125 3126 3127 3128 3129 3130 3131
		/* 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.
		 */
3132
		if (likely(!(scb->tcp_flags & TCPHDR_SYN))) {
3133 3134 3135 3136 3137 3138
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

3139 3140 3141
		if (!fully_acked)
			break;

3142
		next = skb_rb_next(skb);
3143
		if (unlikely(skb == tp->retransmit_skb_hint))
3144
			tp->retransmit_skb_hint = NULL;
3145
		if (unlikely(skb == tp->lost_skb_hint))
3146
			tp->lost_skb_hint = NULL;
3147
		tcp_rtx_queue_unlink_and_free(skb, sk);
L
Linus Torvalds 已提交
3148 3149
	}

3150 3151 3152
	if (!skb)
		tcp_chrono_stop(sk, TCP_CHRONO_BUSY);

I
Ilpo Järvinen 已提交
3153 3154 3155
	if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
		tp->snd_up = tp->snd_una;

3156 3157 3158
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

3159 3160 3161
	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);
3162 3163 3164 3165 3166 3167 3168 3169 3170 3171 3172

		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;
		}
3173
	}
3174 3175 3176
	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);
3177
	}
3178
	rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
3179
					ca_rtt_us, sack->rate);
Y
Yuchung Cheng 已提交
3180

3181
	if (flag & FLAG_ACKED) {
3182
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
3183 3184 3185 3186 3187
		if (unlikely(icsk->icsk_mtup.probe_size &&
			     !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
			tcp_mtup_probe_success(sk);
		}

3188 3189
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
3190 3191 3192 3193 3194 3195 3196 3197 3198

			/* If any of the cumulatively ACKed segments was
			 * retransmitted, non-SACK case cannot confirm that
			 * progress was due to original transmission due to
			 * lack of TCPCB_SACKED_ACKED bits even if some of
			 * the packets may have been never retransmitted.
			 */
			if (flag & FLAG_RETRANS_DATA_ACKED)
				flag &= ~FLAG_ORIG_SACK_ACKED;
3199
		} else {
3200 3201
			int delta;

3202
			/* Non-retransmitted hole got filled? That's reordering */
3203 3204
			if (before(reord, prior_fack))
				tcp_check_sack_reordering(sk, reord, 0);
3205

Y
Yuchung Cheng 已提交
3206
			delta = prior_sacked - tp->sacked_out;
3207
			tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3208
		}
3209
	} else if (skb && rtt_update && sack_rtt_us >= 0 &&
3210
		   sack_rtt_us > tcp_stamp_us_delta(tp->tcp_mstamp, skb->skb_mstamp)) {
3211 3212 3213 3214
		/* 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.
		 */
3215
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
L
Linus Torvalds 已提交
3216 3217
	}

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

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

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

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

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

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

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

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

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

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

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

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

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

3333 3334 3335 3336 3337
/* If we update tp->snd_una, also update tp->bytes_acked */
static void tcp_snd_una_update(struct tcp_sock *tp, u32 ack)
{
	u32 delta = ack - tp->snd_una;

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

3343 3344 3345 3346 3347
/* If we update tp->rcv_nxt, also update tp->bytes_received */
static void tcp_rcv_nxt_update(struct tcp_sock *tp, u32 seq)
{
	u32 delta = seq - tp->rcv_nxt;

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

L
Linus Torvalds 已提交
3353 3354 3355 3356 3357
/* Update our send window.
 *
 * Window update algorithm, described in RFC793/RFC1122 (used in linux-2.2
 * and in FreeBSD. NetBSD's one is even worse.) is wrong.
 */
3358
static int tcp_ack_update_window(struct sock *sk, const struct sk_buff *skb, u32 ack,
3359
				 u32 ack_seq)
L
Linus Torvalds 已提交
3360
{
3361
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3362
	int flag = 0;
3363
	u32 nwin = ntohs(tcp_hdr(skb)->window);
L
Linus Torvalds 已提交
3364

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

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

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

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

3381
			if (!tcp_write_queue_empty(sk))
3382 3383
				tcp_slow_start_after_idle_check(sk);

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

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

	return flag;
}

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

3402
		if (0 <= elapsed && elapsed < net->ipv4.sysctl_tcp_invalid_ratelimit) {
3403 3404 3405 3406 3407
			NET_INC_STATS(net, mib_idx);
			return true;	/* rate-limited: don't send yet! */
		}
	}

3408
	*last_oow_ack_time = tcp_jiffies32;
3409 3410 3411 3412

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

3413 3414 3415 3416 3417 3418 3419 3420 3421 3422 3423 3424 3425
/* Return true if we're currently rate-limiting out-of-window ACKs and
 * thus shouldn't send a dupack right now. We rate-limit dupacks in
 * response to out-of-window SYNs or ACKs to mitigate ACK loops or DoS
 * attacks that send repeated SYNs or ACKs for the same connection. To
 * do this, we do not send a duplicate SYNACK or ACK if the remote
 * endpoint is sending out-of-window SYNs or pure ACKs at a high rate.
 */
bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,
			  int mib_idx, u32 *last_oow_ack_time)
{
	/* Data packets without SYNs are not likely part of an ACK loop. */
	if ((TCP_SKB_CB(skb)->seq != TCP_SKB_CB(skb)->end_seq) &&
	    !tcp_hdr(skb)->syn)
3426
		return false;
3427

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

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

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

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

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

3464 3465 3466
static void tcp_store_ts_recent(struct tcp_sock *tp)
{
	tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
3467
	tp->rx_opt.ts_recent_stamp = ktime_get_seconds();
3468 3469 3470 3471 3472 3473 3474 3475 3476 3477 3478 3479 3480 3481 3482 3483 3484
}

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 已提交
3485
/* This routine deals with acks during a TLP episode.
3486 3487
 * We mark the end of a TLP episode on receiving TLP dupack or when
 * ack is after tlp_high_seq.
N
Nandita Dukkipati 已提交
3488 3489 3490 3491 3492 3493
 * 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);

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

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

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

3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536 3537 3538 3539 3540 3541 3542 3543 3544 3545
/* 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);
}

3546 3547 3548
/* 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)
{
3549
	const struct net *net = sock_net(sk);
3550 3551 3552 3553
	struct tcp_sock *tp = tcp_sk(sk);
	u32 delivered;

	delivered = tp->delivered - prior_delivered;
3554 3555
	NET_ADD_STATS(net, LINUX_MIB_TCPDELIVERED, delivered);
	if (flag & FLAG_ECE) {
3556
		tp->delivered_ce += delivered;
3557 3558
		NET_ADD_STATS(net, LINUX_MIB_TCPDELIVEREDCE, delivered);
	}
3559 3560 3561
	return delivered;
}

L
Linus Torvalds 已提交
3562
/* This routine deals with incoming acks, but not outgoing ones. */
3563
static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
L
Linus Torvalds 已提交
3564
{
3565
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3566
	struct tcp_sock *tp = tcp_sk(sk);
3567
	struct tcp_sacktag_state sack_state;
3568
	struct rate_sample rs = { .prior_delivered = 0 };
L
Linus Torvalds 已提交
3569
	u32 prior_snd_una = tp->snd_una;
3570
	bool is_sack_reneg = tp->is_sack_reneg;
L
Linus Torvalds 已提交
3571 3572
	u32 ack_seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;
3573
	bool is_dupack = false;
3574
	int prior_packets = tp->packets_out;
3575 3576
	u32 delivered = tp->delivered;
	u32 lost = tp->lost;
3577
	int rexmit = REXMIT_NONE; /* Flag to (re)transmit to recover losses */
3578
	u32 prior_fack;
3579

3580
	sack_state.first_sackt = 0;
3581
	sack_state.rate = &rs;
L
Linus Torvalds 已提交
3582

3583 3584
	/* We very likely will need to access rtx queue. */
	prefetch(sk->tcp_rtx_queue.rb_node);
3585

3586
	/* If the ack is older than previous acks
L
Linus Torvalds 已提交
3587 3588
	 * then we can probably ignore it.
	 */
3589 3590 3591
	if (before(ack, prior_snd_una)) {
		/* RFC 5961 5.2 [Blind Data Injection Attack].[Mitigation] */
		if (before(ack, prior_snd_una - tp->max_window)) {
3592 3593
			if (!(flag & FLAG_NO_CHALLENGE_ACK))
				tcp_send_challenge_ack(sk, skb);
3594 3595
			return -1;
		}
L
Linus Torvalds 已提交
3596
		goto old_ack;
3597
	}
L
Linus Torvalds 已提交
3598

3599 3600 3601 3602 3603 3604
	/* 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;

3605
	if (after(ack, prior_snd_una)) {
3606
		flag |= FLAG_SND_UNA_ADVANCED;
3607
		icsk->icsk_retransmits = 0;
I
Ilya Lesokhin 已提交
3608 3609 3610 3611 3612 3613

#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
3614
	}
3615

E
Eric Dumazet 已提交
3616
	prior_fack = tcp_is_sack(tp) ? tcp_highest_sack_seq(tp) : tp->snd_una;
3617
	rs.prior_in_flight = tcp_packets_in_flight(tp);
3618

3619 3620 3621 3622 3623 3624
	/* 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);

3625 3626 3627 3628 3629 3630 3631 3632 3633 3634 3635 3636 3637
	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 {
3638
		u32 ack_ev_flags = CA_ACK_SLOWPATH;
L
Linus Torvalds 已提交
3639

3640 3641 3642 3643
		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 已提交
3644

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

3647 3648 3649
		if (TCP_SKB_CB(skb)->sacked)
			flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
							&sack_state);
3650

3651 3652 3653 3654 3655 3656 3657
		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 已提交
3658

3659 3660
		tcp_in_ack_event(sk, ack_ev_flags);
	}
L
Linus Torvalds 已提交
3661 3662 3663 3664 3665

	/* We passed data and got it acked, remove any soft error
	 * log. Something worked...
	 */
	sk->sk_err_soft = 0;
3666
	icsk->icsk_probes_out = 0;
3667
	tp->rcv_tstamp = tcp_jiffies32;
L
Linus Torvalds 已提交
3668 3669 3670 3671
	if (!prior_packets)
		goto no_queue;

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

3674
	tcp_rack_update_reo_wnd(sk, &rs);
3675

3676 3677 3678 3679 3680 3681
	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);

3682
	if (tcp_ack_is_dubious(sk, flag)) {
3683
		is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
3684 3685
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
L
Linus Torvalds 已提交
3686
	}
N
Nandita Dukkipati 已提交
3687

3688 3689
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
		sk_dst_confirm(sk);
N
Nandita Dukkipati 已提交
3690

3691
	delivered = tcp_newly_delivered(sk, delivered, flag);
3692
	lost = tp->lost - lost;			/* freshly marked lost */
3693
	rs.is_ack_delayed = !!(flag & FLAG_ACK_MAYBE_DELAYED);
3694
	tcp_rate_gen(sk, delivered, lost, is_sack_reneg, sack_state.rate);
3695
	tcp_cong_control(sk, ack, delivered, flag, sack_state.rate);
3696
	tcp_xmit_recovery(sk, rexmit);
L
Linus Torvalds 已提交
3697 3698 3699
	return 1;

no_queue:
3700
	/* If data was DSACKed, see if we can undo a cwnd reduction. */
3701
	if (flag & FLAG_DSACKING_ACK) {
3702 3703
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
3704 3705
		tcp_newly_delivered(sk, delivered, flag);
	}
L
Linus Torvalds 已提交
3706 3707 3708 3709
	/* 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.
	 */
3710
	tcp_ack_probe(sk);
N
Nandita Dukkipati 已提交
3711 3712 3713

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

3716 3717 3718 3719
invalid_ack:
	SOCK_DEBUG(sk, "Ack %u after %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
	return -1;

L
Linus Torvalds 已提交
3720
old_ack:
3721 3722 3723
	/* 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.
	 */
3724
	if (TCP_SKB_CB(skb)->sacked) {
Y
Yuchung Cheng 已提交
3725
		flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
3726
						&sack_state);
3727 3728
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
3729
		tcp_newly_delivered(sk, delivered, flag);
3730
		tcp_xmit_recovery(sk, rexmit);
3731
	}
L
Linus Torvalds 已提交
3732

3733
	SOCK_DEBUG(sk, "Ack %u before %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
L
Linus Torvalds 已提交
3734 3735 3736
	return 0;
}

3737 3738 3739 3740 3741 3742 3743 3744 3745 3746 3747 3748 3749 3750 3751 3752 3753
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;
}

3754 3755 3756 3757 3758 3759 3760 3761 3762 3763 3764 3765 3766 3767 3768
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 已提交
3769 3770 3771 3772
/* 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.
 */
3773 3774
void tcp_parse_options(const struct net *net,
		       const struct sk_buff *skb,
C
Christoph Paasch 已提交
3775
		       struct tcp_options_received *opt_rx, int estab,
Y
Yuchung Cheng 已提交
3776
		       struct tcp_fastopen_cookie *foc)
L
Linus Torvalds 已提交
3777
{
3778 3779
	const unsigned char *ptr;
	const struct tcphdr *th = tcp_hdr(skb);
3780
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3781

3782
	ptr = (const unsigned char *)(th + 1);
L
Linus Torvalds 已提交
3783 3784
	opt_rx->saw_tstamp = 0;

S
Stephen Hemminger 已提交
3785
	while (length > 0) {
3786
		int opcode = *ptr++;
L
Linus Torvalds 已提交
3787 3788 3789
		int opsize;

		switch (opcode) {
3790 3791 3792 3793 3794 3795 3796 3797
		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 已提交
3798
				return;
3799 3800 3801 3802 3803
			if (opsize > length)
				return;	/* don't parse partial options */
			switch (opcode) {
			case TCPOPT_MSS:
				if (opsize == TCPOLEN_MSS && th->syn && !estab) {
3804
					u16 in_mss = get_unaligned_be16(ptr);
3805 3806 3807 3808 3809
					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 已提交
3810
					}
3811 3812 3813 3814
				}
				break;
			case TCPOPT_WINDOW:
				if (opsize == TCPOLEN_WINDOW && th->syn &&
3815
				    !estab && net->ipv4.sysctl_tcp_window_scaling) {
3816 3817
					__u8 snd_wscale = *(__u8 *)ptr;
					opt_rx->wscale_ok = 1;
3818 3819
					if (snd_wscale > TCP_MAX_WSCALE) {
						net_info_ratelimited("%s: Illegal window scaling value %d > %u received\n",
3820
								     __func__,
3821 3822 3823
								     snd_wscale,
								     TCP_MAX_WSCALE);
						snd_wscale = TCP_MAX_WSCALE;
L
Linus Torvalds 已提交
3824
					}
3825 3826 3827 3828 3829 3830
					opt_rx->snd_wscale = snd_wscale;
				}
				break;
			case TCPOPT_TIMESTAMP:
				if ((opsize == TCPOLEN_TIMESTAMP) &&
				    ((estab && opt_rx->tstamp_ok) ||
3831
				     (!estab && net->ipv4.sysctl_tcp_timestamps))) {
3832
					opt_rx->saw_tstamp = 1;
3833 3834
					opt_rx->rcv_tsval = get_unaligned_be32(ptr);
					opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
3835 3836 3837 3838
				}
				break;
			case TCPOPT_SACK_PERM:
				if (opsize == TCPOLEN_SACK_PERM && th->syn &&
E
Eric Dumazet 已提交
3839
				    !estab && net->ipv4.sysctl_tcp_sack) {
3840
					opt_rx->sack_ok = TCP_SACK_SEEN;
3841 3842 3843
					tcp_sack_reset(opt_rx);
				}
				break;
L
Linus Torvalds 已提交
3844

3845 3846 3847 3848 3849 3850 3851
			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;
3852
#ifdef CONFIG_TCP_MD5SIG
3853 3854 3855 3856 3857 3858
			case TCPOPT_MD5SIG:
				/*
				 * The MD5 Hash has already been
				 * checked (see tcp_v{4,6}_do_rcv()).
				 */
				break;
3859
#endif
3860 3861 3862 3863 3864 3865
			case TCPOPT_FASTOPEN:
				tcp_parse_fastopen_option(
					opsize - TCPOLEN_FASTOPEN_BASE,
					ptr, th->syn, foc, false);
				break;

Y
Yuchung Cheng 已提交
3866 3867
			case TCPOPT_EXP:
				/* Fast Open option shares code 254 using a
3868
				 * 16 bits magic number.
Y
Yuchung Cheng 已提交
3869
				 */
3870 3871 3872 3873 3874 3875
				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);
3876 3877 3878
				else
					smc_parse_options(th, opt_rx, ptr,
							  opsize);
Y
Yuchung Cheng 已提交
3879 3880 3881
				break;

			}
3882 3883
			ptr += opsize-2;
			length -= opsize;
3884
		}
L
Linus Torvalds 已提交
3885 3886
	}
}
E
Eric Dumazet 已提交
3887
EXPORT_SYMBOL(tcp_parse_options);
L
Linus Torvalds 已提交
3888

E
Eric Dumazet 已提交
3889
static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
3890
{
3891
	const __be32 *ptr = (const __be32 *)(th + 1);
3892 3893 3894 3895 3896 3897 3898

	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;
3899 3900 3901 3902
		if (*ptr)
			tp->rx_opt.rcv_tsecr = ntohl(*ptr) - tp->tsoffset;
		else
			tp->rx_opt.rcv_tsecr = 0;
E
Eric Dumazet 已提交
3903
		return true;
3904
	}
E
Eric Dumazet 已提交
3905
	return false;
3906 3907
}

L
Linus Torvalds 已提交
3908 3909 3910
/* Fast parse options. This hopes to only see timestamps.
 * If it is wrong it falls back on tcp_parse_options().
 */
3911 3912
static bool tcp_fast_parse_options(const struct net *net,
				   const struct sk_buff *skb,
C
Christoph Paasch 已提交
3913
				   const struct tcphdr *th, struct tcp_sock *tp)
L
Linus Torvalds 已提交
3914
{
3915 3916 3917 3918
	/* 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 已提交
3919
		tp->rx_opt.saw_tstamp = 0;
E
Eric Dumazet 已提交
3920
		return false;
L
Linus Torvalds 已提交
3921
	} else if (tp->rx_opt.tstamp_ok &&
3922
		   th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
3923
		if (tcp_parse_aligned_timestamp(tp, th))
E
Eric Dumazet 已提交
3924
			return true;
L
Linus Torvalds 已提交
3925
	}
3926

3927
	tcp_parse_options(net, skb, &tp->rx_opt, 1, NULL);
3928
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
3929 3930
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;

E
Eric Dumazet 已提交
3931
	return true;
L
Linus Torvalds 已提交
3932 3933
}

3934 3935 3936 3937
#ifdef CONFIG_TCP_MD5SIG
/*
 * Parse MD5 Signature option
 */
3938
const u8 *tcp_parse_md5sig_option(const struct tcphdr *th)
3939
{
3940 3941
	int length = (th->doff << 2) - sizeof(*th);
	const u8 *ptr = (const u8 *)(th + 1);
3942

J
Jann Horn 已提交
3943 3944
	/* If not enough data remaining, we can short cut */
	while (length >= TCPOLEN_MD5SIG) {
3945 3946 3947
		int opcode = *ptr++;
		int opsize;

W
Weilong Chen 已提交
3948
		switch (opcode) {
3949 3950 3951 3952 3953 3954 3955 3956 3957 3958
		case TCPOPT_EOL:
			return NULL;
		case TCPOPT_NOP:
			length--;
			continue;
		default:
			opsize = *ptr++;
			if (opsize < 2 || opsize > length)
				return NULL;
			if (opcode == TCPOPT_MD5SIG)
3959
				return opsize == TCPOLEN_MD5SIG ? ptr : NULL;
3960 3961 3962 3963 3964 3965
		}
		ptr += opsize - 2;
		length -= opsize;
	}
	return NULL;
}
E
Eric Dumazet 已提交
3966
EXPORT_SYMBOL(tcp_parse_md5sig_option);
3967 3968
#endif

L
Linus Torvalds 已提交
3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991
/* 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) ]
 */

3992
static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
3993
{
3994 3995
	const struct tcp_sock *tp = tcp_sk(sk);
	const struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
3996 3997 3998 3999 4000 4001 4002 4003 4004 4005 4006 4007 4008
	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. */
4009
		(s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (inet_csk(sk)->icsk_rto * 1024) / HZ);
L
Linus Torvalds 已提交
4010 4011
}

4012
static inline bool tcp_paws_discard(const struct sock *sk,
4013
				   const struct sk_buff *skb)
L
Linus Torvalds 已提交
4014
{
4015
	const struct tcp_sock *tp = tcp_sk(sk);
I
Ilpo Järvinen 已提交
4016 4017 4018

	return !tcp_paws_check(&tp->rx_opt, TCP_PAWS_WINDOW) &&
	       !tcp_disordered_ack(sk, skb);
L
Linus Torvalds 已提交
4019 4020 4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033
}

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

4034
static inline bool tcp_sequence(const struct tcp_sock *tp, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4035 4036 4037 4038 4039 4040
{
	return	!before(end_seq, tp->rcv_wup) &&
		!after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

/* When we get a reset we do this. */
4041
void tcp_reset(struct sock *sk)
L
Linus Torvalds 已提交
4042
{
4043 4044
	trace_tcp_receive_reset(sk);

L
Linus Torvalds 已提交
4045 4046
	/* We want the right error as BSD sees it (and indeed as we do). */
	switch (sk->sk_state) {
4047 4048 4049 4050 4051 4052 4053 4054 4055 4056
	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 已提交
4057
	}
T
Tom Marshall 已提交
4058 4059
	/* This barrier is coupled with smp_rmb() in tcp_poll() */
	smp_wmb();
L
Linus Torvalds 已提交
4060

4061
	tcp_write_queue_purge(sk);
4062 4063
	tcp_done(sk);

L
Linus Torvalds 已提交
4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081
	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.
 */
4082
void tcp_fin(struct sock *sk)
L
Linus Torvalds 已提交
4083 4084 4085
{
	struct tcp_sock *tp = tcp_sk(sk);

4086
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4087 4088 4089 4090 4091

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

	switch (sk->sk_state) {
4092 4093 4094 4095
	case TCP_SYN_RECV:
	case TCP_ESTABLISHED:
		/* Move to CLOSE_WAIT */
		tcp_set_state(sk, TCP_CLOSE_WAIT);
4096
		inet_csk(sk)->icsk_ack.pingpong = 1;
4097
		break;
L
Linus Torvalds 已提交
4098

4099 4100 4101 4102 4103 4104 4105 4106 4107
	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 已提交
4108

4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125
	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 已提交
4126
		pr_err("%s: Impossible, sk->sk_state=%d\n",
4127
		       __func__, sk->sk_state);
4128
		break;
4129
	}
L
Linus Torvalds 已提交
4130 4131 4132 4133

	/* It _is_ possible, that we have something out-of-order _after_ FIN.
	 * Probably, we should reset in this case. For now drop them.
	 */
4134
	skb_rbtree_purge(&tp->out_of_order_queue);
4135
	if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4136
		tcp_sack_reset(&tp->rx_opt);
4137
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4138 4139 4140 4141 4142 4143 4144

	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)
4145
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP);
L
Linus Torvalds 已提交
4146
		else
4147
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
L
Linus Torvalds 已提交
4148 4149 4150
	}
}

E
Eric Dumazet 已提交
4151
static inline bool tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
4152
				  u32 end_seq)
L
Linus Torvalds 已提交
4153 4154 4155 4156 4157 4158
{
	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 已提交
4159
		return true;
L
Linus Torvalds 已提交
4160
	}
E
Eric Dumazet 已提交
4161
	return false;
L
Linus Torvalds 已提交
4162 4163
}

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

E
Eric Dumazet 已提交
4168
	if (tcp_is_sack(tp) && sock_net(sk)->ipv4.sysctl_tcp_dsack) {
4169 4170
		int mib_idx;

L
Linus Torvalds 已提交
4171
		if (before(seq, tp->rcv_nxt))
4172
			mib_idx = LINUX_MIB_TCPDSACKOLDSENT;
L
Linus Torvalds 已提交
4173
		else
4174 4175
			mib_idx = LINUX_MIB_TCPDSACKOFOSENT;

4176
		NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
4177 4178 4179 4180 4181 4182 4183

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

4184
static void tcp_dsack_extend(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4185
{
4186 4187
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
4188
	if (!tp->rx_opt.dsack)
4189
		tcp_dsack_set(sk, seq, end_seq);
L
Linus Torvalds 已提交
4190 4191 4192 4193
	else
		tcp_sack_extend(tp->duplicate_sack, seq, end_seq);
}

4194
static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
4195 4196 4197 4198 4199
{
	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)) {
4200
		NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4201
		tcp_enter_quickack_mode(sk, TCP_MAX_QUICKACKS);
L
Linus Torvalds 已提交
4202

E
Eric Dumazet 已提交
4203
		if (tcp_is_sack(tp) && sock_net(sk)->ipv4.sysctl_tcp_dsack) {
L
Linus Torvalds 已提交
4204 4205 4206 4207
			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;
4208
			tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, end_seq);
L
Linus Torvalds 已提交
4209 4210 4211 4212 4213 4214 4215 4216 4217 4218 4219 4220 4221
		}
	}

	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];
4222
	struct tcp_sack_block *swalk = sp + 1;
L
Linus Torvalds 已提交
4223 4224 4225 4226

	/* See if the recent change to the first SACK eats into
	 * or hits the sequence space of other SACK blocks, if so coalesce.
	 */
4227
	for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;) {
L
Linus Torvalds 已提交
4228 4229 4230 4231 4232 4233 4234
		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--;
4235 4236
			for (i = this_sack; i < tp->rx_opt.num_sacks; i++)
				sp[i] = sp[i + 1];
L
Linus Torvalds 已提交
4237 4238 4239 4240 4241 4242 4243 4244 4245 4246 4247 4248 4249 4250 4251 4252
			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;

4253
	for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
L
Linus Torvalds 已提交
4254 4255
		if (tcp_sack_extend(sp, seq, end_seq)) {
			/* Rotate this_sack to the first one. */
4256
			for (; this_sack > 0; this_sack--, sp--)
4257
				swap(*sp, *(sp - 1));
L
Linus Torvalds 已提交
4258 4259 4260 4261 4262 4263 4264 4265 4266 4267 4268 4269
			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.
	 */
4270
	if (this_sack >= TCP_NUM_SACKS) {
E
Eric Dumazet 已提交
4271 4272
		if (tp->compressed_ack)
			tcp_send_ack(sk);
L
Linus Torvalds 已提交
4273 4274 4275 4276
		this_sack--;
		tp->rx_opt.num_sacks--;
		sp--;
	}
S
Stephen Hemminger 已提交
4277
	for (; this_sack > 0; this_sack--, sp--)
4278
		*sp = *(sp - 1);
L
Linus Torvalds 已提交
4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289 4290 4291 4292 4293 4294 4295

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. */
4296
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4297 4298 4299 4300
		tp->rx_opt.num_sacks = 0;
		return;
	}

4301
	for (this_sack = 0; this_sack < num_sacks;) {
L
Linus Torvalds 已提交
4302 4303 4304 4305 4306
		/* 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! */
4307
			WARN_ON(before(tp->rcv_nxt, sp->end_seq));
L
Linus Torvalds 已提交
4308 4309

			/* Zap this SACK, by moving forward any other SACKS. */
W
Weilong Chen 已提交
4310
			for (i = this_sack+1; i < num_sacks; i++)
L
Linus Torvalds 已提交
4311 4312 4313 4314 4315 4316 4317
				tp->selective_acks[i-1] = tp->selective_acks[i];
			num_sacks--;
			continue;
		}
		this_sack++;
		sp++;
	}
4318
	tp->rx_opt.num_sacks = num_sacks;
L
Linus Torvalds 已提交
4319 4320
}

4321 4322 4323
/**
 * tcp_try_coalesce - try to merge skb to prior one
 * @sk: socket
4324
 * @dest: destination queue
4325 4326 4327 4328 4329 4330 4331 4332 4333 4334 4335 4336 4337 4338 4339 4340 4341 4342 4343 4344 4345 4346 4347
 * @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;

4348 4349 4350 4351 4352
#ifdef CONFIG_TLS_DEVICE
	if (from->decrypted != to->decrypted)
		return false;
#endif

4353 4354 4355 4356 4357
	if (!skb_try_coalesce(to, from, fragstolen, &delta))
		return false;

	atomic_add(delta, &sk->sk_rmem_alloc);
	sk_mem_charge(sk, delta);
4358
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
4359 4360 4361
	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;
4362 4363 4364

	if (TCP_SKB_CB(from)->has_rxtstamp) {
		TCP_SKB_CB(to)->has_rxtstamp = true;
E
Eric Dumazet 已提交
4365
		to->tstamp = from->tstamp;
4366 4367
	}

4368 4369 4370
	return true;
}

4371 4372 4373 4374 4375 4376 4377 4378 4379 4380 4381 4382 4383 4384 4385 4386 4387
static bool tcp_ooo_try_coalesce(struct sock *sk,
			     struct sk_buff *to,
			     struct sk_buff *from,
			     bool *fragstolen)
{
	bool res = tcp_try_coalesce(sk, to, from, fragstolen);

	/* In case tcp_drop() is called later, update to->gso_segs */
	if (res) {
		u32 gso_segs = max_t(u16, 1, skb_shinfo(to)->gso_segs) +
			       max_t(u16, 1, skb_shinfo(from)->gso_segs);

		skb_shinfo(to)->gso_segs = min_t(u32, gso_segs, 0xFFFF);
	}
	return res;
}

4388 4389 4390 4391 4392 4393
static void tcp_drop(struct sock *sk, struct sk_buff *skb)
{
	sk_drops_add(sk, skb);
	__kfree_skb(skb);
}

L
Linus Torvalds 已提交
4394 4395 4396 4397 4398 4399 4400
/* 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;
4401
	bool fin, fragstolen, eaten;
4402
	struct sk_buff *skb, *tail;
4403
	struct rb_node *p;
L
Linus Torvalds 已提交
4404

4405 4406
	p = rb_first(&tp->out_of_order_queue);
	while (p) {
4407
		skb = rb_to_skb(p);
L
Linus Torvalds 已提交
4408 4409 4410 4411 4412 4413 4414
		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;
4415
			tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);
L
Linus Torvalds 已提交
4416
		}
4417 4418
		p = rb_next(p);
		rb_erase(&skb->rbnode, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
4419

4420
		if (unlikely(!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))) {
4421
			SOCK_DEBUG(sk, "ofo packet was already received\n");
4422
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4423 4424 4425 4426 4427 4428
			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);

4429
		tail = skb_peek_tail(&sk->sk_receive_queue);
E
Eric Dumazet 已提交
4430
		eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
4431
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
4432
		fin = TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN;
4433 4434
		if (!eaten)
			__skb_queue_tail(&sk->sk_receive_queue, skb);
4435
		else
4436
			kfree_skb_partial(skb, fragstolen);
4437 4438 4439 4440 4441 4442 4443 4444

		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 已提交
4445 4446 4447
	}
}

E
Eric Dumazet 已提交
4448
static bool tcp_prune_ofo_queue(struct sock *sk);
L
Linus Torvalds 已提交
4449 4450
static int tcp_prune_queue(struct sock *sk);

4451 4452
static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb,
				 unsigned int size)
4453 4454
{
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
4455
	    !sk_rmem_schedule(sk, skb, size)) {
4456 4457 4458 4459

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

4460
		while (!sk_rmem_schedule(sk, skb, size)) {
4461 4462
			if (!tcp_prune_ofo_queue(sk))
				return -1;
4463 4464 4465 4466 4467
		}
	}
	return 0;
}

E
Eric Dumazet 已提交
4468 4469 4470
static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
4471
	struct rb_node **p, *parent;
E
Eric Dumazet 已提交
4472 4473
	struct sk_buff *skb1;
	u32 seq, end_seq;
4474
	bool fragstolen;
E
Eric Dumazet 已提交
4475

4476
	tcp_ecn_check_ce(sk, skb);
E
Eric Dumazet 已提交
4477

4478
	if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
4479
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
4480
		tcp_drop(sk, skb);
E
Eric Dumazet 已提交
4481 4482 4483
		return;
	}

4484 4485
	/* Disable header prediction. */
	tp->pred_flags = 0;
E
Eric Dumazet 已提交
4486 4487
	inet_csk_schedule_ack(sk);

4488
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
4489 4490
	seq = TCP_SKB_CB(skb)->seq;
	end_seq = TCP_SKB_CB(skb)->end_seq;
E
Eric Dumazet 已提交
4491
	SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
4492
		   tp->rcv_nxt, seq, end_seq);
E
Eric Dumazet 已提交
4493

4494 4495
	p = &tp->out_of_order_queue.rb_node;
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
E
Eric Dumazet 已提交
4496 4497 4498
		/* Initial out of order segment, build 1 SACK. */
		if (tcp_is_sack(tp)) {
			tp->rx_opt.num_sacks = 1;
4499 4500
			tp->selective_acks[0].start_seq = seq;
			tp->selective_acks[0].end_seq = end_seq;
E
Eric Dumazet 已提交
4501
		}
4502 4503 4504
		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 已提交
4505 4506 4507
		goto end;
	}

4508 4509 4510
	/* 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.
	 */
4511 4512
	if (tcp_ooo_try_coalesce(sk, tp->ooo_last_skb,
				 skb, &fragstolen)) {
4513 4514 4515 4516 4517 4518
coalesce_done:
		tcp_grow_window(sk, skb);
		kfree_skb_partial(skb, fragstolen);
		skb = NULL;
		goto add_sack;
	}
4519 4520 4521 4522 4523 4524
	/* 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;
	}
4525 4526 4527 4528 4529

	/* Find place to insert this segment. Handle overlaps on the way. */
	parent = NULL;
	while (*p) {
		parent = *p;
4530
		skb1 = rb_to_skb(parent);
4531 4532 4533
		if (before(seq, TCP_SKB_CB(skb1)->seq)) {
			p = &parent->rb_left;
			continue;
E
Eric Dumazet 已提交
4534
		}
4535 4536 4537 4538 4539
		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);
4540
				tcp_drop(sk, skb);
4541 4542 4543 4544 4545 4546 4547 4548 4549 4550 4551 4552 4553 4554 4555 4556 4557 4558
				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);
4559
				tcp_drop(sk, skb1);
4560
				goto merge_right;
4561
			}
4562 4563
		} else if (tcp_ooo_try_coalesce(sk, skb1,
						skb, &fragstolen)) {
4564
			goto coalesce_done;
E
Eric Dumazet 已提交
4565
		}
4566
		p = &parent->rb_right;
E
Eric Dumazet 已提交
4567
	}
4568
insert:
4569 4570 4571
	/* 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 已提交
4572

4573
merge_right:
4574
	/* Remove other segments covered by skb. */
4575
	while ((skb1 = skb_rb_next(skb)) != NULL) {
E
Eric Dumazet 已提交
4576 4577 4578 4579 4580 4581 4582
		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;
		}
4583
		rb_erase(&skb1->rbnode, &tp->out_of_order_queue);
E
Eric Dumazet 已提交
4584 4585
		tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
				 TCP_SKB_CB(skb1)->end_seq);
4586
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
4587
		tcp_drop(sk, skb1);
E
Eric Dumazet 已提交
4588
	}
4589
	/* If there is no skb after us, we are the last_skb ! */
4590
	if (!skb1)
4591
		tp->ooo_last_skb = skb;
E
Eric Dumazet 已提交
4592 4593 4594 4595 4596

add_sack:
	if (tcp_is_sack(tp))
		tcp_sack_new_ofo_skb(sk, seq, end_seq);
end:
4597 4598
	if (skb) {
		tcp_grow_window(sk, skb);
4599
		skb_condense(skb);
E
Eric Dumazet 已提交
4600
		skb_set_owner_r(skb, sk);
4601
	}
E
Eric Dumazet 已提交
4602 4603
}

4604
static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen,
4605 4606 4607 4608 4609 4610 4611
		  bool *fragstolen)
{
	int eaten;
	struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue);

	__skb_pull(skb, hdrlen);
	eaten = (tail &&
E
Eric Dumazet 已提交
4612
		 tcp_try_coalesce(sk, tail,
4613
				  skb, fragstolen)) ? 1 : 0;
4614
	tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
4615 4616 4617 4618 4619 4620
	if (!eaten) {
		__skb_queue_tail(&sk->sk_receive_queue, skb);
		skb_set_owner_r(skb, sk);
	}
	return eaten;
}
E
Eric Dumazet 已提交
4621

4622 4623
int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size)
{
4624
	struct sk_buff *skb;
4625 4626
	int err = -ENOMEM;
	int data_len = 0;
4627 4628
	bool fragstolen;

4629 4630 4631
	if (size == 0)
		return 0;

4632 4633 4634 4635 4636 4637 4638 4639 4640
	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);
4641 4642 4643
	if (!skb)
		goto err;

4644 4645 4646 4647
	skb_put(skb, size - data_len);
	skb->data_len = data_len;
	skb->len = size;

4648 4649
	if (tcp_try_rmem_schedule(sk, skb, skb->truesize)) {
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVQDROP);
4650
		goto err_free;
4651
	}
4652

4653 4654
	err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
	if (err)
4655 4656 4657 4658 4659 4660
		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;

4661
	if (tcp_queue_rcv(sk, skb, 0, &fragstolen)) {
4662 4663 4664 4665 4666 4667 4668 4669
		WARN_ON_ONCE(fragstolen); /* should not happen */
		__kfree_skb(skb);
	}
	return size;

err_free:
	kfree_skb(skb);
err:
4670 4671
	return err;

4672 4673
}

4674 4675 4676 4677 4678 4679 4680 4681 4682 4683 4684
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 已提交
4685 4686 4687
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
E
Eric Dumazet 已提交
4688 4689
	bool fragstolen;
	int eaten;
L
Linus Torvalds 已提交
4690

4691 4692 4693 4694
	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
		__kfree_skb(skb);
		return;
	}
E
Eric Dumazet 已提交
4695
	skb_dst_drop(skb);
4696
	__skb_pull(skb, tcp_hdr(skb)->doff * 4);
L
Linus Torvalds 已提交
4697

4698
	tcp_ecn_accept_cwr(tp, skb);
L
Linus Torvalds 已提交
4699

4700
	tp->rx_opt.dsack = 0;
L
Linus Torvalds 已提交
4701 4702 4703 4704 4705 4706

	/*  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) {
4707 4708
		if (tcp_receive_window(tp) == 0) {
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPZEROWINDOWDROP);
L
Linus Torvalds 已提交
4709
			goto out_of_window;
4710
		}
L
Linus Torvalds 已提交
4711 4712 4713

		/* Ok. In sequence. In window. */
queue_and_out:
E
Eric Dumazet 已提交
4714 4715
		if (skb_queue_len(&sk->sk_receive_queue) == 0)
			sk_forced_mem_schedule(sk, skb->truesize);
4716 4717
		else if (tcp_try_rmem_schedule(sk, skb, skb->truesize)) {
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVQDROP);
E
Eric Dumazet 已提交
4718
			goto drop;
4719
		}
E
Eric Dumazet 已提交
4720

4721
		eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);
S
Stephen Hemminger 已提交
4722
		if (skb->len)
4723
			tcp_event_data_recv(sk, skb);
4724
		if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
4725
			tcp_fin(sk);
L
Linus Torvalds 已提交
4726

4727
		if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4728 4729 4730 4731 4732
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
4733
			if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4734
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
4735 4736 4737 4738 4739
		}

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

4740 4741
		tcp_fast_path_check(sk);

4742 4743
		if (eaten > 0)
			kfree_skb_partial(skb, fragstolen);
4744
		if (!sock_flag(sk, SOCK_DEAD))
4745
			tcp_data_ready(sk);
L
Linus Torvalds 已提交
4746 4747 4748 4749 4750
		return;
	}

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

out_of_window:
4755
		tcp_enter_quickack_mode(sk, TCP_MAX_QUICKACKS);
4756
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4757
drop:
4758
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4759 4760 4761 4762 4763 4764 4765 4766 4767 4768 4769 4770 4771
		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;

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

4772
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
4773

L
Linus Torvalds 已提交
4774 4775 4776
		/* If window is closed, drop tail of packet. But after
		 * remembering D-SACK for its head made in previous line.
		 */
4777 4778
		if (!tcp_receive_window(tp)) {
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPZEROWINDOWDROP);
L
Linus Torvalds 已提交
4779
			goto out_of_window;
4780
		}
L
Linus Torvalds 已提交
4781 4782 4783
		goto queue_and_out;
	}

E
Eric Dumazet 已提交
4784
	tcp_data_queue_ofo(sk, skb);
L
Linus Torvalds 已提交
4785 4786
}

4787 4788 4789 4790 4791
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;

4792
	return skb_rb_next(skb);
4793 4794
}

4795
static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
4796 4797
					struct sk_buff_head *list,
					struct rb_root *root)
4798
{
4799
	struct sk_buff *next = tcp_skb_next(skb, list);
4800

4801 4802 4803 4804
	if (list)
		__skb_unlink(skb, list);
	else
		rb_erase(&skb->rbnode, root);
4805 4806

	__kfree_skb(skb);
4807
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
4808 4809 4810 4811

	return next;
}

4812
/* Insert skb into rb tree, ordered by TCP_SKB_CB(skb)->seq */
4813
void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb)
4814 4815 4816 4817 4818 4819 4820
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct sk_buff *skb1;

	while (*p) {
		parent = *p;
4821
		skb1 = rb_to_skb(parent);
4822 4823 4824 4825 4826 4827 4828 4829 4830
		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 已提交
4831 4832
/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
4833
 *
4834
 * If tail is NULL, this means until the end of the queue.
4835
 *
L
Linus Torvalds 已提交
4836 4837 4838 4839
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
4840 4841
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 已提交
4842
{
4843 4844
	struct sk_buff *skb = head, *n;
	struct sk_buff_head tmp;
4845
	bool end_of_skbs;
L
Linus Torvalds 已提交
4846

S
Stephen Hemminger 已提交
4847
	/* First, check that queue is collapsible and find
4848 4849
	 * the point where collapsing can be useful.
	 */
4850
restart:
4851 4852 4853
	for (end_of_skbs = true; skb != NULL && skb != tail; skb = n) {
		n = tcp_skb_next(skb, list);

L
Linus Torvalds 已提交
4854 4855
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
4856
			skb = tcp_collapse_one(sk, skb, list, root);
4857 4858 4859
			if (!skb)
				break;
			goto restart;
L
Linus Torvalds 已提交
4860 4861 4862 4863 4864 4865 4866
		}

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

4874 4875 4876 4877
		if (n && n != tail &&
		    TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(n)->seq) {
			end_of_skbs = false;
			break;
4878
		}
L
Linus Torvalds 已提交
4879 4880 4881 4882

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

4887 4888
	__skb_queue_head_init(&tmp);

L
Linus Torvalds 已提交
4889
	while (before(start, end)) {
4890
		int copy = min_t(int, SKB_MAX_ORDER(0, 0), end - start);
L
Linus Torvalds 已提交
4891 4892
		struct sk_buff *nskb;

4893
		nskb = alloc_skb(copy, GFP_ATOMIC);
L
Linus Torvalds 已提交
4894
		if (!nskb)
4895
			break;
4896

L
Linus Torvalds 已提交
4897
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
4898 4899 4900
#ifdef CONFIG_TLS_DEVICE
		nskb->decrypted = skb->decrypted;
#endif
L
Linus Torvalds 已提交
4901
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
4902 4903 4904 4905
		if (list)
			__skb_queue_before(list, skb, nskb);
		else
			__skb_queue_tail(&tmp, nskb); /* defer rbtree insertion */
4906
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4907 4908 4909 4910 4911 4912

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

4913
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4914 4915 4916 4917 4918 4919 4920 4921 4922
			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)) {
4923
				skb = tcp_collapse_one(sk, skb, list, root);
4924 4925
				if (!skb ||
				    skb == tail ||
4926
				    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
4927
					goto end;
4928 4929 4930 4931
#ifdef CONFIG_TLS_DEVICE
				if (skb->decrypted != nskb->decrypted)
					goto end;
#endif
L
Linus Torvalds 已提交
4932 4933 4934
			}
		}
	}
4935 4936 4937
end:
	skb_queue_walk_safe(&tmp, skb, n)
		tcp_rbtree_insert(root, skb);
L
Linus Torvalds 已提交
4938 4939 4940 4941 4942 4943 4944 4945
}

/* 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);
4946
	u32 range_truesize, sum_tiny = 0;
4947
	struct sk_buff *skb, *head;
L
Linus Torvalds 已提交
4948 4949
	u32 start, end;

4950
	skb = skb_rb_first(&tp->out_of_order_queue);
4951 4952
new_range:
	if (!skb) {
4953
		tp->ooo_last_skb = skb_rb_last(&tp->out_of_order_queue);
L
Linus Torvalds 已提交
4954
		return;
4955
	}
L
Linus Torvalds 已提交
4956 4957
	start = TCP_SKB_CB(skb)->seq;
	end = TCP_SKB_CB(skb)->end_seq;
4958
	range_truesize = skb->truesize;
4959

4960
	for (head = skb;;) {
4961
		skb = skb_rb_next(skb);
L
Linus Torvalds 已提交
4962

4963 4964 4965
		/* Range is terminated when we see a gap or when
		 * we are at the queue end.
		 */
4966
		if (!skb ||
L
Linus Torvalds 已提交
4967 4968
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
4969 4970 4971 4972 4973 4974 4975 4976 4977 4978
			/* Do not attempt collapsing tiny skbs */
			if (range_truesize != head->truesize ||
			    end - start >= SKB_WITH_OVERHEAD(SK_MEM_QUANTUM)) {
				tcp_collapse(sk, NULL, &tp->out_of_order_queue,
					     head, skb, start, end);
			} else {
				sum_tiny += range_truesize;
				if (sum_tiny > sk->sk_rcvbuf >> 3)
					return;
			}
4979 4980 4981
			goto new_range;
		}

4982
		range_truesize += skb->truesize;
4983
		if (unlikely(before(TCP_SKB_CB(skb)->seq, start)))
L
Linus Torvalds 已提交
4984
			start = TCP_SKB_CB(skb)->seq;
4985
		if (after(TCP_SKB_CB(skb)->end_seq, end))
L
Linus Torvalds 已提交
4986 4987 4988 4989
			end = TCP_SKB_CB(skb)->end_seq;
	}
}

4990
/*
4991 4992 4993 4994 4995 4996
 * 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)
4997
 * 3) Drop at least 12.5 % of sk_rcvbuf to avoid malicious attacks.
4998 4999
 *
 * Return true if queue has shrunk.
5000
 */
E
Eric Dumazet 已提交
5001
static bool tcp_prune_ofo_queue(struct sock *sk)
5002 5003
{
	struct tcp_sock *tp = tcp_sk(sk);
5004
	struct rb_node *node, *prev;
5005
	int goal;
5006

5007
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
5008
		return false;
5009

5010
	NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
5011
	goal = sk->sk_rcvbuf >> 3;
5012 5013 5014 5015
	node = &tp->ooo_last_skb->rbnode;
	do {
		prev = rb_prev(node);
		rb_erase(node, &tp->out_of_order_queue);
5016
		goal -= rb_to_skb(node)->truesize;
5017
		tcp_drop(sk, rb_to_skb(node));
5018 5019 5020 5021 5022 5023 5024
		if (!prev || goal <= 0) {
			sk_mem_reclaim(sk);
			if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
			    !tcp_under_memory_pressure(sk))
				break;
			goal = sk->sk_rcvbuf >> 3;
		}
5025 5026
		node = prev;
	} while (node);
5027
	tp->ooo_last_skb = rb_to_skb(prev);
5028 5029 5030 5031 5032 5033 5034 5035 5036

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

L
Linus Torvalds 已提交
5039 5040 5041 5042 5043 5044 5045 5046 5047
/* 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)
{
5048
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
5049 5050 5051

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

5052
	NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
L
Linus Torvalds 已提交
5053 5054

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
5055
		tcp_clamp_window(sk);
5056
	else if (tcp_under_memory_pressure(sk))
L
Linus Torvalds 已提交
5057 5058
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

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

L
Linus Torvalds 已提交
5062
	tcp_collapse_ofo_queue(sk);
5063
	if (!skb_queue_empty(&sk->sk_receive_queue))
5064
		tcp_collapse(sk, &sk->sk_receive_queue, NULL,
5065 5066 5067
			     skb_peek(&sk->sk_receive_queue),
			     NULL,
			     tp->copied_seq, tp->rcv_nxt);
5068
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
5069 5070 5071 5072 5073 5074 5075

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

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

5076
	tcp_prune_ofo_queue(sk);
L
Linus Torvalds 已提交
5077 5078 5079 5080 5081 5082 5083 5084

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

	/* Massive buffer overcommit. */
5088
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
5089 5090 5091
	return -1;
}

E
Eric Dumazet 已提交
5092
static bool tcp_should_expand_sndbuf(const struct sock *sk)
5093
{
5094
	const struct tcp_sock *tp = tcp_sk(sk);
5095

5096 5097 5098 5099
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
E
Eric Dumazet 已提交
5100
		return false;
5101 5102

	/* If we are under global TCP memory pressure, do not expand.  */
5103
	if (tcp_under_memory_pressure(sk))
E
Eric Dumazet 已提交
5104
		return false;
5105 5106

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

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

E
Eric Dumazet 已提交
5114
	return true;
5115
}
L
Linus Torvalds 已提交
5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126

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

5127
	if (tcp_should_expand_sndbuf(sk)) {
E
Eric Dumazet 已提交
5128
		tcp_sndbuf_expand(sk);
5129
		tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
5130 5131 5132 5133 5134
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
5135
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
5136 5137 5138
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
5139
		/* pairs with tcp_poll() */
5140
		smp_mb();
L
Linus Torvalds 已提交
5141
		if (sk->sk_socket &&
5142
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
L
Linus Torvalds 已提交
5143
			tcp_new_space(sk);
5144 5145 5146
			if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
				tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
		}
L
Linus Torvalds 已提交
5147 5148 5149
	}
}

5150
static inline void tcp_data_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5151
{
5152
	tcp_push_pending_frames(sk);
L
Linus Torvalds 已提交
5153 5154 5155 5156 5157 5158 5159 5160 5161
	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);
E
Eric Dumazet 已提交
5162
	unsigned long rtt, delay;
L
Linus Torvalds 已提交
5163 5164

	    /* More than one full frame received... */
5165
	if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss &&
L
Linus Torvalds 已提交
5166
	     /* ... and right edge of window advances far enough.
5167 5168 5169
	      * (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 已提交
5170
	      */
5171 5172
	    (tp->rcv_nxt - tp->copied_seq < sk->sk_rcvlowat ||
	     __tcp_select_window(sk) >= tp->rcv_wnd)) ||
L
Linus Torvalds 已提交
5173
	    /* We ACK each frame or... */
E
Eric Dumazet 已提交
5174 5175
	    tcp_in_quickack_mode(sk)) {
send_now:
L
Linus Torvalds 已提交
5176
		tcp_send_ack(sk);
E
Eric Dumazet 已提交
5177 5178 5179 5180
		return;
	}

	if (!ofo_possible || RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
5181
		tcp_send_delayed_ack(sk);
E
Eric Dumazet 已提交
5182
		return;
L
Linus Torvalds 已提交
5183
	}
E
Eric Dumazet 已提交
5184

E
Eric Dumazet 已提交
5185 5186
	if (!tcp_is_sack(tp) ||
	    tp->compressed_ack >= sock_net(sk)->ipv4.sysctl_tcp_comp_sack_nr)
E
Eric Dumazet 已提交
5187 5188 5189 5190 5191 5192
		goto send_now;
	tp->compressed_ack++;

	if (hrtimer_is_queued(&tp->compressed_ack_timer))
		return;

5193
	/* compress ack timer : 5 % of rtt, but no more than tcp_comp_sack_delay_ns */
E
Eric Dumazet 已提交
5194 5195 5196 5197 5198

	rtt = tp->rcv_rtt_est.rtt_us;
	if (tp->srtt_us && tp->srtt_us < rtt)
		rtt = tp->srtt_us;

5199
	delay = min_t(unsigned long, sock_net(sk)->ipv4.sysctl_tcp_comp_sack_delay_ns,
E
Eric Dumazet 已提交
5200 5201 5202 5203
		      rtt * (NSEC_PER_USEC >> 3)/20);
	sock_hold(sk);
	hrtimer_start(&tp->compressed_ack_timer, ns_to_ktime(delay),
		      HRTIMER_MODE_REL_PINNED_SOFT);
L
Linus Torvalds 已提交
5204 5205
}

S
Stephen Hemminger 已提交
5206
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5207
{
5208
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
5209 5210 5211 5212 5213 5214 5215 5216
		/* 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 已提交
5217
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
5218 5219 5220 5221 5222 5223
 *	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).
 */
5224

5225
static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
L
Linus Torvalds 已提交
5226 5227 5228 5229
{
	struct tcp_sock *tp = tcp_sk(sk);
	u32 ptr = ntohs(th->urg_ptr);

5230
	if (ptr && !sock_net(sk)->ipv4.sysctl_tcp_stdurg)
L
Linus Torvalds 已提交
5231 5232 5233 5234 5235 5236 5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254 5255 5256 5257 5258 5259 5260 5261
		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 已提交
5262
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
5263 5264 5265 5266 5267 5268 5269 5270 5271 5272 5273
	 *
	 * 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 &&
5274
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
5275 5276 5277
		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 已提交
5278
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
5279 5280 5281 5282
			__kfree_skb(skb);
		}
	}

5283 5284
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
5285 5286 5287

	/* Disable header prediction. */
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
5288 5289 5290
}

/* This is the 'fast' part of urgent handling. */
5291
static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
L
Linus Torvalds 已提交
5292 5293 5294 5295 5296
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
5297
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
5298 5299 5300 5301 5302 5303

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

5304
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
5305 5306 5307 5308 5309 5310
		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))
5311
				sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
5312 5313 5314 5315
		}
	}
}

5316 5317 5318 5319 5320 5321 5322 5323 5324 5325 5326 5327 5328 5329 5330 5331 5332
/* 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));
}

5333 5334 5335
/* Does PAWS and seqno based validation of an incoming segment, flags will
 * play significant role here.
 */
E
Eric Dumazet 已提交
5336 5337
static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
				  const struct tcphdr *th, int syn_inerr)
5338 5339
{
	struct tcp_sock *tp = tcp_sk(sk);
5340
	bool rst_seq_match = false;
5341 5342

	/* RFC1323: H1. Apply PAWS check first. */
5343 5344
	if (tcp_fast_parse_options(sock_net(sk), skb, th, tp) &&
	    tp->rx_opt.saw_tstamp &&
5345 5346
	    tcp_paws_discard(sk, skb)) {
		if (!th->rst) {
5347
			NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
5348 5349 5350 5351
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDPAWS,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364
			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)".
		 */
5365 5366 5367
		if (!th->rst) {
			if (th->syn)
				goto syn_challenge;
5368 5369 5370 5371
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDSEQ,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5372 5373
		} else if (tcp_reset_check(sk, skb)) {
			tcp_reset(sk);
5374
		}
5375 5376 5377 5378 5379
		goto discard;
	}

	/* Step 2: check RST bit */
	if (th->rst) {
5380 5381 5382 5383
		/* 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,
5384
		 * then
E
Eric Dumazet 已提交
5385 5386 5387 5388
		 *     RESET the connection
		 * else
		 *     Send a challenge ACK
		 */
5389 5390
		if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt ||
		    tcp_reset_check(sk, skb)) {
5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408
			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 已提交
5409
			tcp_reset(sk);
5410 5411 5412 5413 5414 5415 5416
		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)
5417
				tcp_fastopen_active_disable(sk);
5418
			tcp_send_challenge_ack(sk, skb);
5419
		}
5420 5421 5422 5423 5424
		goto discard;
	}

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

E
Eric Dumazet 已提交
5425
	/* step 4: Check for a SYN
5426
	 * RFC 5961 4.2 : Send a challenge ack
E
Eric Dumazet 已提交
5427 5428
	 */
	if (th->syn) {
5429
syn_challenge:
5430
		if (syn_inerr)
5431 5432
			TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
5433
		tcp_send_challenge_ack(sk, skb);
E
Eric Dumazet 已提交
5434
		goto discard;
5435 5436
	}

E
Eric Dumazet 已提交
5437
	return true;
5438 5439

discard:
5440
	tcp_drop(sk, skb);
E
Eric Dumazet 已提交
5441
	return false;
5442 5443
}

L
Linus Torvalds 已提交
5444
/*
5445
 *	TCP receive function for the ESTABLISHED state.
5446 5447 5448 5449 5450 5451 5452 5453 5454 5455 5456 5457 5458 5459 5460 5461 5462 5463 5464 5465
 *
 *	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 已提交
5466
 */
5467
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
5468
{
5469
	const struct tcphdr *th = (const struct tcphdr *)skb->data;
L
Linus Torvalds 已提交
5470
	struct tcp_sock *tp = tcp_sk(sk);
5471
	unsigned int len = skb->len;
L
Linus Torvalds 已提交
5472

5473 5474 5475
	/* TCP congestion window tracking */
	trace_tcp_probe(sk, skb);

5476
	tcp_mstamp_refresh(tp);
5477
	if (unlikely(!sk->sk_rx_dst))
E
Eric Dumazet 已提交
5478
		inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
5479 5480 5481 5482 5483 5484 5485 5486 5487 5488 5489 5490 5491 5492
	/*
	 *	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 已提交
5493 5494 5495

	tp->rx_opt.saw_tstamp = 0;

5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530 5531 5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549
	/*	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);
5550 5551 5552 5553 5554
				/* When receiving pure ack in fast path, update
				 * last ts ecr directly instead of calling
				 * tcp_rcv_rtt_measure_ts()
				 */
				tp->rcv_rtt_last_tsecr = tp->rx_opt.rcv_tsecr;
5555 5556 5557 5558 5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593 5594 5595 5596 5597 5598 5599 5600
				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);
5601
			tcp_data_ready(sk);
5602 5603 5604 5605 5606
			return;
		}
	}

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

5610
	if (!th->ack && !th->rst && !th->syn)
5611 5612
		goto discard;

5613 5614 5615 5616
	/*
	 *	Standard slow path.
	 */

E
Eric Dumazet 已提交
5617
	if (!tcp_validate_incoming(sk, skb, th, 1))
5618
		return;
L
Linus Torvalds 已提交
5619

5620 5621
step5:
	if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
5622
		goto discard;
L
Linus Torvalds 已提交
5623

5624
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5625 5626 5627 5628 5629 5630 5631

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

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

5632
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5633
	tcp_ack_snd_check(sk);
5634
	return;
L
Linus Torvalds 已提交
5635 5636

csum_error:
5637 5638
	TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
	TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5639 5640

discard:
5641
	tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5642
}
E
Eric Dumazet 已提交
5643
EXPORT_SYMBOL(tcp_rcv_established);
L
Linus Torvalds 已提交
5644

P
Pavel Emelyanov 已提交
5645 5646 5647 5648 5649 5650
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);
5651
	icsk->icsk_ack.lrcvtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5652

5653
	if (skb) {
E
Eric Dumazet 已提交
5654
		icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
P
Pavel Emelyanov 已提交
5655
		security_inet_conn_established(sk, skb);
5656
		sk_mark_napi_id(sk, skb);
D
David S. Miller 已提交
5657
	}
P
Pavel Emelyanov 已提交
5658

5659
	tcp_init_transfer(sk, BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB);
P
Pavel Emelyanov 已提交
5660 5661 5662 5663

	/* Prevent spurious tcp_cwnd_restart() on first data
	 * packet.
	 */
5664
	tp->lsndtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5665 5666 5667

	if (sock_flag(sk, SOCK_KEEPOPEN))
		inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
5668 5669 5670 5671 5672

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

5675 5676 5677 5678
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);
5679
	struct sk_buff *data = tp->syn_data ? tcp_rtx_queue_head(sk) : NULL;
5680 5681
	u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
	bool syn_drop = false;
5682 5683 5684 5685 5686 5687 5688

	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;
5689
		tcp_parse_options(sock_net(sk), synack, &opt, 0, NULL);
5690 5691 5692
		mss = opt.mss_clamp;
	}

5693 5694
	if (!tp->syn_fastopen) {
		/* Ignore an unsolicited cookie */
5695
		cookie->len = -1;
5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709
	} 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;
	}
5710

5711
	tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
5712 5713

	if (data) { /* Retransmit unacked data in SYN */
5714 5715
		skb_rbtree_walk_from(data) {
			if (__tcp_retransmit_skb(sk, data, 1))
5716 5717
				break;
		}
5718
		tcp_rearm_rto(sk);
5719
		NET_INC_STATS(sock_net(sk),
5720
				LINUX_MIB_TCPFASTOPENACTIVEFAIL);
5721 5722
		return true;
	}
Y
Yuchung Cheng 已提交
5723
	tp->syn_data_acked = tp->syn_data;
5724 5725 5726 5727 5728 5729
	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;
	}
5730 5731 5732

	tcp_fastopen_add_skb(sk, synack);

5733 5734 5735
	return false;
}

5736 5737 5738 5739 5740 5741 5742 5743 5744 5745
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 已提交
5746
static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
5747
					 const struct tcphdr *th)
L
Linus Torvalds 已提交
5748
{
5749
	struct inet_connection_sock *icsk = inet_csk(sk);
5750
	struct tcp_sock *tp = tcp_sk(sk);
5751
	struct tcp_fastopen_cookie foc = { .len = -1 };
5752
	int saved_clamp = tp->rx_opt.mss_clamp;
5753
	bool fastopen_fail;
L
Linus Torvalds 已提交
5754

5755
	tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc);
5756
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
5757
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;
L
Linus Torvalds 已提交
5758 5759 5760 5761 5762 5763 5764 5765 5766 5767

	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)"
		 */
5768 5769
		if (!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
		    after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt))
L
Linus Torvalds 已提交
5770 5771 5772 5773
			goto reset_and_undo;

		if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
		    !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp,
5774
			     tcp_time_stamp(tp))) {
5775
			NET_INC_STATS(sock_net(sk),
5776
					LINUX_MIB_PAWSACTIVEREJECTED);
L
Linus Torvalds 已提交
5777 5778 5779 5780 5781 5782 5783 5784 5785 5786 5787 5788 5789 5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809
			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..."
		 */

5810
		tcp_ecn_rcv_synack(tp, th);
L
Linus Torvalds 已提交
5811

5812
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
5813
		tcp_ack(sk, skb, FLAG_SLOWPATH);
L
Linus Torvalds 已提交
5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830 5831 5832 5833 5834 5835 5836 5837 5838 5839 5840

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

5841
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5842 5843 5844 5845 5846 5847
		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;
5848

5849 5850
		smc_check_reset_syn(tp);

R
Ralf Baechle 已提交
5851
		smp_mb();
L
Linus Torvalds 已提交
5852

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

5855 5856
		fastopen_fail = (tp->syn_fastopen || tp->syn_data) &&
				tcp_rcv_fastopen_synack(sk, skb, &foc);
5857

5858 5859 5860 5861 5862 5863
		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;
5864 5865 5866
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
5867 5868 5869 5870 5871 5872 5873
			/* 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
			 */
5874
			inet_csk_schedule_ack(sk);
5875
			tcp_enter_quickack_mode(sk, TCP_MAX_QUICKACKS);
5876 5877
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
5878 5879

discard:
5880
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900
			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. */
5901
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
I
Ilpo Järvinen 已提交
5902
	    tcp_paws_reject(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914 5915 5916 5917 5918 5919 5920 5921
		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;
5922
		tp->copied_seq = tp->rcv_nxt;
L
Linus Torvalds 已提交
5923 5924 5925 5926 5927 5928 5929 5930 5931
		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;

5932
		tcp_ecn_rcv_syn(tp, th);
L
Linus Torvalds 已提交
5933

J
John Heffner 已提交
5934
		tcp_mtup_init(sk);
5935
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5936 5937 5938 5939 5940
		tcp_initialize_rcv_mss(sk);

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
5941 5942 5943
		 * 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 已提交
5944 5945 5946 5947 5948 5949 5950 5951 5952 5953 5954 5955 5956 5957 5958 5959 5960 5961 5962 5963 5964 5965 5966 5967 5968 5969 5970 5971 5972
		 *
		 * 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
5973
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5974 5975 5976
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5977

5978
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
5979 5980
{
	struct tcp_sock *tp = tcp_sk(sk);
5981
	struct inet_connection_sock *icsk = inet_csk(sk);
5982
	const struct tcphdr *th = tcp_hdr(skb);
5983
	struct request_sock *req;
L
Linus Torvalds 已提交
5984
	int queued = 0;
5985
	bool acceptable;
L
Linus Torvalds 已提交
5986 5987 5988 5989 5990 5991

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

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5992
		if (th->ack)
L
Linus Torvalds 已提交
5993 5994
			return 1;

S
Stephen Hemminger 已提交
5995
		if (th->rst)
L
Linus Torvalds 已提交
5996 5997
			goto discard;

S
Stephen Hemminger 已提交
5998
		if (th->syn) {
E
Eric Dumazet 已提交
5999 6000
			if (th->fin)
				goto discard;
6001 6002 6003 6004 6005 6006
			/* 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 已提交
6007

6008 6009
			if (!acceptable)
				return 1;
6010
			consume_skb(skb);
6011
			return 0;
L
Linus Torvalds 已提交
6012 6013 6014 6015
		}
		goto discard;

	case TCP_SYN_SENT:
6016
		tp->rx_opt.saw_tstamp = 0;
6017
		tcp_mstamp_refresh(tp);
6018
		queued = tcp_rcv_synsent_state_process(sk, skb, th);
L
Linus Torvalds 已提交
6019 6020 6021 6022 6023 6024
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
6025
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
6026 6027 6028
		return 0;
	}

6029
	tcp_mstamp_refresh(tp);
6030
	tp->rx_opt.saw_tstamp = 0;
6031
	req = tp->fastopen_rsk;
6032
	if (req) {
6033 6034
		bool req_stolen;

6035
		WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
6036 6037
		    sk->sk_state != TCP_FIN_WAIT1);

6038
		if (!tcp_check_req(sk, skb, req, true, &req_stolen))
6039
			goto discard;
6040
	}
6041

6042
	if (!th->ack && !th->rst && !th->syn)
6043 6044
		goto discard;

6045
	if (!tcp_validate_incoming(sk, skb, th, 0))
E
Eric Dumazet 已提交
6046
		return 0;
L
Linus Torvalds 已提交
6047 6048

	/* step 5: check the ACK field */
6049 6050
	acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
				      FLAG_UPDATE_TS_RECENT |
6051
				      FLAG_NO_CHALLENGE_ACK) > 0;
6052

6053 6054 6055 6056 6057 6058
	if (!acceptable) {
		if (sk->sk_state == TCP_SYN_RECV)
			return 1;	/* send one RST */
		tcp_send_challenge_ack(sk, skb);
		goto discard;
	}
6059 6060
	switch (sk->sk_state) {
	case TCP_SYN_RECV:
6061
		tp->delivered++; /* SYN-ACK delivery isn't tracked in tcp_ack */
Y
Yuchung Cheng 已提交
6062 6063 6064
		if (!tp->srtt_us)
			tcp_synack_rtt_meas(sk, req);

6065 6066 6067 6068
		/* Once we leave TCP_SYN_RECV, we no longer need req
		 * so release it.
		 */
		if (req) {
6069
			inet_csk(sk)->icsk_retransmits = 0;
6070
			reqsk_fastopen_remove(sk, req, false);
6071 6072 6073 6074 6075 6076 6077 6078 6079
			/* 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);
6080
		} else {
6081
			tcp_init_transfer(sk, BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB);
6082 6083 6084 6085 6086
			tp->copied_seq = tp->rcv_nxt;
		}
		smp_mb();
		tcp_set_state(sk, TCP_ESTABLISHED);
		sk->sk_state_change(sk);
L
Linus Torvalds 已提交
6087

6088 6089 6090 6091 6092 6093 6094 6095 6096 6097 6098 6099 6100 6101
		/* 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;

6102 6103
		if (!inet_csk(sk)->icsk_ca_ops->cong_control)
			tcp_update_pacing_rate(sk);
6104

6105
		/* Prevent spurious tcp_cwnd_restart() on first data packet */
6106
		tp->lsndtime = tcp_jiffies32;
6107 6108

		tcp_initialize_rcv_mss(sk);
6109
		tcp_fast_path_on(tp);
6110 6111
		break;

6112 6113 6114
	case TCP_FIN_WAIT1: {
		int tmo;

6115 6116 6117 6118 6119
		/* 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.
		 */
6120
		if (req) {
6121 6122 6123 6124
			/* We no longer need the request sock. */
			reqsk_fastopen_remove(sk, req, false);
			tcp_rearm_rto(sk);
		}
6125 6126
		if (tp->snd_una != tp->write_seq)
			break;
6127

6128 6129
		tcp_set_state(sk, TCP_FIN_WAIT2);
		sk->sk_shutdown |= SEND_SHUTDOWN;
6130

6131
		sk_dst_confirm(sk);
6132

6133 6134 6135 6136 6137
		if (!sock_flag(sk, SOCK_DEAD)) {
			/* Wake up lingering close() */
			sk->sk_state_change(sk);
			break;
		}
L
Linus Torvalds 已提交
6138

6139 6140 6141 6142 6143 6144 6145 6146 6147
		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)
6148
				tcp_fastopen_active_disable(sk);
6149
			tcp_done(sk);
6150
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
6151 6152 6153 6154 6155 6156 6157 6158 6159 6160 6161 6162 6163 6164 6165 6166 6167
			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;
6168 6169
		}
		break;
6170
	}
L
Linus Torvalds 已提交
6171

6172 6173 6174 6175 6176 6177
	case TCP_CLOSING:
		if (tp->snd_una == tp->write_seq) {
			tcp_time_wait(sk, TCP_TIME_WAIT, 0);
			goto discard;
		}
		break;
L
Linus Torvalds 已提交
6178

6179 6180 6181 6182 6183
	case TCP_LAST_ACK:
		if (tp->snd_una == tp->write_seq) {
			tcp_update_metrics(sk);
			tcp_done(sk);
			goto discard;
L
Linus Torvalds 已提交
6184
		}
6185
		break;
6186
	}
L
Linus Torvalds 已提交
6187 6188 6189 6190 6191 6192 6193 6194 6195 6196 6197

	/* 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;
6198
		/* fall through */
L
Linus Torvalds 已提交
6199 6200 6201
	case TCP_FIN_WAIT1:
	case TCP_FIN_WAIT2:
		/* RFC 793 says to queue data in these states,
6202
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
6203 6204 6205 6206 6207
		 * 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)) {
6208
				NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
6209 6210 6211 6212 6213
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
6214
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
6215 6216 6217 6218 6219 6220 6221
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
6222
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
6223 6224 6225
		tcp_ack_snd_check(sk);
	}

6226
	if (!queued) {
L
Linus Torvalds 已提交
6227
discard:
6228
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
6229 6230 6231 6232
	}
	return 0;
}
EXPORT_SYMBOL(tcp_rcv_state_process);
O
Octavian Purdila 已提交
6233 6234 6235 6236 6237 6238

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)
6239 6240
		net_dbg_ratelimited("drop open request from %pI4/%u\n",
				    &ireq->ir_rmt_addr, port);
6241 6242
#if IS_ENABLED(CONFIG_IPV6)
	else if (family == AF_INET6)
6243 6244
		net_dbg_ratelimited("drop open request from %pI6/%u\n",
				    &ireq->ir_v6_rmt_addr, port);
6245
#endif
O
Octavian Purdila 已提交
6246 6247
}

6248 6249 6250 6251 6252
/* 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 已提交
6253
 * TCP ECN negotiation.
6254 6255
 *
 * Exception: tcp_ca wants ECN. This is required for DCTCP
6256 6257 6258
 * congestion control: Linux DCTCP asserts ECT on all packets,
 * including SYN, which is most optimal solution; however,
 * others, such as FreeBSD do not.
6259 6260 6261
 */
static void tcp_ecn_create_request(struct request_sock *req,
				   const struct sk_buff *skb,
6262 6263
				   const struct sock *listen_sk,
				   const struct dst_entry *dst)
6264 6265 6266 6267
{
	const struct tcphdr *th = tcp_hdr(skb);
	const struct net *net = sock_net(listen_sk);
	bool th_ecn = th->ece && th->cwr;
6268
	bool ect, ecn_ok;
6269
	u32 ecn_ok_dst;
6270 6271 6272 6273 6274

	if (!th_ecn)
		return;

	ect = !INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield);
6275 6276
	ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
	ecn_ok = net->ipv4.sysctl_tcp_ecn || ecn_ok_dst;
6277

6278
	if ((!ect && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
6279 6280
	    (ecn_ok_dst & DST_FEATURE_ECN_CA) ||
	    tcp_bpf_ca_needs_ecn((struct sock *)req))
6281 6282 6283
		inet_rsk(req)->ecn_ok = 1;
}

6284 6285 6286 6287 6288 6289
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);

6290
	req->rsk_rcv_wnd = 0;		/* So that tcp_send_synack() knows! */
6291 6292 6293
	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;
6294
	tcp_rsk(req)->snt_synack = tcp_clock_us();
6295 6296 6297 6298 6299 6300 6301 6302 6303 6304 6305 6306
	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);
6307 6308 6309
#if IS_ENABLED(CONFIG_SMC)
	ireq->smc_ok = rx_opt->smc_ok;
#endif
6310 6311
}

E
Eric Dumazet 已提交
6312
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
6313 6314
				      struct sock *sk_listener,
				      bool attach_listener)
E
Eric Dumazet 已提交
6315
{
6316 6317
	struct request_sock *req = reqsk_alloc(ops, sk_listener,
					       attach_listener);
E
Eric Dumazet 已提交
6318 6319 6320 6321

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

E
Eric Dumazet 已提交
6322
		ireq->ireq_opt = NULL;
6323 6324 6325
#if IS_ENABLED(CONFIG_IPV6)
		ireq->pktopts = NULL;
#endif
6326
		atomic64_set(&ireq->ir_cookie, 0);
E
Eric Dumazet 已提交
6327 6328
		ireq->ireq_state = TCP_NEW_SYN_RECV;
		write_pnet(&ireq->ireq_net, sock_net(sk_listener));
6329
		ireq->ireq_family = sk_listener->sk_family;
E
Eric Dumazet 已提交
6330 6331 6332 6333 6334 6335
	}

	return req;
}
EXPORT_SYMBOL(inet_reqsk_alloc);

6336 6337 6338
/*
 * Return true if a syncookie should be sent
 */
6339
static bool tcp_syn_flood_action(const struct sock *sk,
6340 6341 6342
				 const struct sk_buff *skb,
				 const char *proto)
{
6343
	struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
6344 6345
	const char *msg = "Dropping request";
	bool want_cookie = false;
6346
	struct net *net = sock_net(sk);
6347 6348

#ifdef CONFIG_SYN_COOKIES
6349
	if (net->ipv4.sysctl_tcp_syncookies) {
6350 6351
		msg = "Sending cookies";
		want_cookie = true;
6352
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
6353 6354
	} else
#endif
6355
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
6356

6357
	if (!queue->synflood_warned &&
6358
	    net->ipv4.sysctl_tcp_syncookies != 2 &&
6359
	    xchg(&queue->synflood_warned, 1) == 0)
6360 6361
		pr_info("%s: Possible SYN flooding on port %d. %s.  Check SNMP counters.\n",
			proto, ntohs(tcp_hdr(skb)->dest), msg);
6362

6363 6364 6365
	return want_cookie;
}

6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376 6377 6378 6379 6380 6381 6382
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 已提交
6383 6384 6385 6386
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)
{
6387 6388
	struct tcp_fastopen_cookie foc = { .len = -1 };
	__u32 isn = TCP_SKB_CB(skb)->tcp_tw_isn;
O
Octavian Purdila 已提交
6389 6390
	struct tcp_options_received tmp_opt;
	struct tcp_sock *tp = tcp_sk(sk);
6391
	struct net *net = sock_net(sk);
6392 6393 6394
	struct sock *fastopen_sk = NULL;
	struct request_sock *req;
	bool want_cookie = false;
6395
	struct dst_entry *dst;
O
Octavian Purdila 已提交
6396 6397 6398 6399 6400 6401
	struct flowi fl;

	/* TW buckets are converted to open requests without
	 * limitations, they conserve resources and peer is
	 * evidently real one.
	 */
6402
	if ((net->ipv4.sysctl_tcp_syncookies == 2 ||
O
Octavian Purdila 已提交
6403 6404 6405 6406 6407 6408
	     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;
	}

6409
	if (sk_acceptq_is_full(sk)) {
6410
		NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
O
Octavian Purdila 已提交
6411 6412 6413
		goto drop;
	}

6414
	req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
O
Octavian Purdila 已提交
6415 6416 6417 6418
	if (!req)
		goto drop;

	tcp_rsk(req)->af_specific = af_ops;
6419
	tcp_rsk(req)->ts_off = 0;
O
Octavian Purdila 已提交
6420 6421 6422 6423

	tcp_clear_options(&tmp_opt);
	tmp_opt.mss_clamp = af_ops->mss_clamp;
	tmp_opt.user_mss  = tp->rx_opt.user_mss;
6424 6425
	tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0,
			  want_cookie ? NULL : &foc);
O
Octavian Purdila 已提交
6426 6427 6428 6429

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

6430 6431 6432
	if (IS_ENABLED(CONFIG_SMC) && want_cookie)
		tmp_opt.smc_ok = 0;

O
Octavian Purdila 已提交
6433 6434
	tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
	tcp_openreq_init(req, &tmp_opt, skb, sk);
6435
	inet_rsk(req)->no_srccheck = inet_sk(sk)->transparent;
O
Octavian Purdila 已提交
6436

6437
	/* Note: tcp_v6_init_req() might override ir_iif for link locals */
6438
	inet_rsk(req)->ir_iif = inet_request_bound_dev_if(sk, skb);
6439

O
Octavian Purdila 已提交
6440 6441 6442 6443 6444
	af_ops->init_req(req, sk, skb);

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

6445
	if (tmp_opt.tstamp_ok)
6446
		tcp_rsk(req)->ts_off = af_ops->init_ts_off(net, skb);
6447

6448 6449 6450 6451
	dst = af_ops->route_req(sk, &fl, req);
	if (!dst)
		goto drop_and_free;

6452
	if (!want_cookie && !isn) {
O
Octavian Purdila 已提交
6453
		/* Kill the following clause, if you dislike this way. */
6454 6455 6456 6457
		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 已提交
6458 6459 6460 6461 6462 6463 6464 6465 6466 6467 6468 6469
			/* 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;
		}

6470
		isn = af_ops->init_seq(skb);
O
Octavian Purdila 已提交
6471 6472
	}

6473 6474 6475 6476 6477 6478 6479 6480 6481
	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 已提交
6482
	tcp_rsk(req)->snt_isn = isn;
6483
	tcp_rsk(req)->txhash = net_tx_rndhash();
O
Octavian Purdila 已提交
6484
	tcp_openreq_init_rwin(req, sk, dst);
6485
	sk_rx_queue_set(req_to_sk(req), skb);
6486 6487
	if (!want_cookie) {
		tcp_reqsk_record_syn(sk, req, skb);
6488
		fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc, dst);
6489
	}
6490
	if (fastopen_sk) {
6491
		af_ops->send_synack(fastopen_sk, dst, &fl, req,
6492
				    &foc, TCP_SYNACK_FASTOPEN);
6493 6494 6495 6496
		/* 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);
6497 6498
		sock_put(fastopen_sk);
	} else {
6499
		tcp_rsk(req)->tfo_listener = false;
6500
		if (!want_cookie)
6501 6502
			inet_csk_reqsk_queue_hash_add(sk, req,
				tcp_timeout_init((struct sock *)req));
6503 6504 6505
		af_ops->send_synack(sk, dst, &fl, req, &foc,
				    !want_cookie ? TCP_SYNACK_NORMAL :
						   TCP_SYNACK_COOKIE);
6506 6507 6508 6509
		if (want_cookie) {
			reqsk_free(req);
			return 0;
		}
O
Octavian Purdila 已提交
6510
	}
6511
	reqsk_put(req);
O
Octavian Purdila 已提交
6512 6513 6514 6515 6516 6517 6518
	return 0;

drop_and_release:
	dst_release(dst);
drop_and_free:
	reqsk_free(req);
drop:
6519
	tcp_listendrop(sk);
O
Octavian Purdila 已提交
6520 6521 6522
	return 0;
}
EXPORT_SYMBOL(tcp_conn_request);