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

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

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

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

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

#define FLAG_DATA		0x01 /* Incoming frame contained data.		*/
#define FLAG_WIN_UPDATE		0x02 /* Incoming ACK was a window update.	*/
#define FLAG_DATA_ACKED		0x04 /* This ACK acknowledged new data.		*/
#define FLAG_RETRANS_DATA_ACKED	0x08 /* "" "" some of which was retransmitted.	*/
#define FLAG_SYN_ACKED		0x10 /* This ACK acknowledged SYN.		*/
#define FLAG_DATA_SACKED	0x20 /* New SACK.				*/
#define FLAG_ECE		0x40 /* ECE in this ACK				*/
91
#define FLAG_LOST_RETRANS	0x80 /* This ACK marks some retransmission lost */
92
#define FLAG_SLOWPATH		0x100 /* Do not skip RFC checks for window update.*/
Y
Yuchung Cheng 已提交
93
#define FLAG_ORIG_SACK_ACKED	0x200 /* Never retransmitted data are (s)acked	*/
94
#define FLAG_SND_UNA_ADVANCED	0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
95
#define FLAG_DSACKING_ACK	0x800 /* SACK blocks contained D-SACK info */
96
#define FLAG_SET_XMIT_TIMER	0x1000 /* Set TLP or RTO timer */
97
#define FLAG_SACK_RENEGING	0x2000 /* snd_una advanced to a sacked seq */
98
#define FLAG_UPDATE_TS_RECENT	0x4000 /* tcp_replace_ts_recent() */
99
#define FLAG_NO_CHALLENGE_ACK	0x8000 /* do not call tcp_send_challenge_ack()	*/
100
#define FLAG_ACK_MAYBE_DELAYED	0x10000 /* Likely a delayed ACK */
L
Linus Torvalds 已提交
101 102 103

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

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

110 111 112 113
#define REXMIT_NONE	0 /* no loss recovery to do */
#define REXMIT_LOST	1 /* retransmit packets marked lost */
#define REXMIT_NEW	2 /* FRTO-style transmit of unsent/new packets */

114 115
static void tcp_gro_dev_warn(struct sock *sk, const struct sk_buff *skb,
			     unsigned int len)
116 117 118 119 120 121 122 123 124 125
{
	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);
126 127 128
		if (!dev || len >= dev->mtu)
			pr_warn("%s: Driver has suspect GRO implementation, TCP performance may be compromised.\n",
				dev ? dev->name : "Unknown driver");
129 130 131 132
		rcu_read_unlock();
	}
}

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

142
	icsk->icsk_ack.last_seg_size = 0;
L
Linus Torvalds 已提交
143 144 145 146

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

187
static void tcp_incr_quickack(struct sock *sk)
L
Linus Torvalds 已提交
188
{
189
	struct inet_connection_sock *icsk = inet_csk(sk);
190
	unsigned int quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
L
Linus Torvalds 已提交
191

192 193
	if (quickacks == 0)
		quickacks = 2;
194 195
	if (quickacks > icsk->icsk_ack.quick)
		icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS);
L
Linus Torvalds 已提交
196 197
}

198
static void tcp_enter_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
199
{
200 201 202 203
	struct inet_connection_sock *icsk = inet_csk(sk);
	tcp_incr_quickack(sk);
	icsk->icsk_ack.pingpong = 0;
	icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
204 205 206 207 208 209
}

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

210
static bool tcp_in_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
211
{
212
	const struct inet_connection_sock *icsk = inet_csk(sk);
213
	const struct dst_entry *dst = __sk_dst_get(sk);
E
Eric Dumazet 已提交
214

215 216
	return (dst && dst_metric(dst, RTAX_QUICKACK)) ||
		(icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong);
L
Linus Torvalds 已提交
217 218
}

219
static void tcp_ecn_queue_cwr(struct tcp_sock *tp)
220
{
221
	if (tp->ecn_flags & TCP_ECN_OK)
222 223 224
		tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}

225
static void tcp_ecn_accept_cwr(struct tcp_sock *tp, const struct sk_buff *skb)
226 227 228 229 230
{
	if (tcp_hdr(skb)->cwr)
		tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

231
static void tcp_ecn_withdraw_cwr(struct tcp_sock *tp)
232 233 234 235
{
	tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

236
static void __tcp_ecn_check_ce(struct tcp_sock *tp, const struct sk_buff *skb)
237
{
238
	switch (TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK) {
239
	case INET_ECN_NOT_ECT:
240
		/* Funny extension: if ECT is not set on a segment,
241 242 243 244
		 * and we already seen ECT on a previous segment,
		 * it is probably a retransmit.
		 */
		if (tp->ecn_flags & TCP_ECN_SEEN)
245
			tcp_enter_quickack_mode((struct sock *)tp);
246 247
		break;
	case INET_ECN_CE:
248 249 250
		if (tcp_ca_needs_ecn((struct sock *)tp))
			tcp_ca_event((struct sock *)tp, CA_EVENT_ECN_IS_CE);

251 252 253 254 255
		if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR)) {
			/* Better not delay acks, sender can have a very low cwnd */
			tcp_enter_quickack_mode((struct sock *)tp);
			tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
		}
256 257
		tp->ecn_flags |= TCP_ECN_SEEN;
		break;
258
	default:
259 260
		if (tcp_ca_needs_ecn((struct sock *)tp))
			tcp_ca_event((struct sock *)tp, CA_EVENT_ECN_NO_CE);
261
		tp->ecn_flags |= TCP_ECN_SEEN;
262
		break;
263 264 265
	}
}

266 267 268 269 270 271 272
static void tcp_ecn_check_ce(struct tcp_sock *tp, const struct sk_buff *skb)
{
	if (tp->ecn_flags & TCP_ECN_OK)
		__tcp_ecn_check_ce(tp, skb);
}

static void tcp_ecn_rcv_synack(struct tcp_sock *tp, const struct tcphdr *th)
273
{
274
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || th->cwr))
275 276 277
		tp->ecn_flags &= ~TCP_ECN_OK;
}

278
static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
279
{
280
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
281 282 283
		tp->ecn_flags &= ~TCP_ECN_OK;
}

284
static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
285
{
286
	if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
E
Eric Dumazet 已提交
287 288
		return true;
	return false;
289 290
}

L
Linus Torvalds 已提交
291 292 293 294 295
/* Buffer size and advertised window tuning.
 *
 * 1. Tuning sk->sk_sndbuf, when connection enters established state.
 */

E
Eric Dumazet 已提交
296
static void tcp_sndbuf_expand(struct sock *sk)
L
Linus Torvalds 已提交
297
{
E
Eric Dumazet 已提交
298
	const struct tcp_sock *tp = tcp_sk(sk);
299
	const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
E
Eric Dumazet 已提交
300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317
	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
318
	 * extra cushion (application might react slowly to EPOLLOUT)
E
Eric Dumazet 已提交
319
	 */
320 321
	sndmem = ca_ops->sndbuf_expand ? ca_ops->sndbuf_expand(sk) : 2;
	sndmem *= nr_segs * per_mss;
L
Linus Torvalds 已提交
322

323
	if (sk->sk_sndbuf < sndmem)
324
		sk->sk_sndbuf = min(sndmem, sock_net(sk)->ipv4.sysctl_tcp_wmem[2]);
L
Linus Torvalds 已提交
325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347
}

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

/* Slow part of check#2. */
353
static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
354
{
355
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
356
	/* Optimize this! */
357
	int truesize = tcp_win_from_space(sk, skb->truesize) >> 1;
358
	int window = tcp_win_from_space(sk, sock_net(sk)->ipv4.sysctl_tcp_rmem[2]) >> 1;
L
Linus Torvalds 已提交
359 360 361

	while (tp->rcv_ssthresh <= window) {
		if (truesize <= skb->len)
362
			return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
L
Linus Torvalds 已提交
363 364 365 366 367 368 369

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

370
static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
371
{
372 373
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
374 375 376
	/* Check #1 */
	if (tp->rcv_ssthresh < tp->window_clamp &&
	    (int)tp->rcv_ssthresh < tcp_space(sk) &&
377
	    !tcp_under_memory_pressure(sk)) {
L
Linus Torvalds 已提交
378 379 380 381 382
		int incr;

		/* Check #2. Increase window, if skb with such overhead
		 * will fit to rcvbuf in future.
		 */
383
		if (tcp_win_from_space(sk, skb->truesize) <= skb->len)
384
			incr = 2 * tp->advmss;
L
Linus Torvalds 已提交
385
		else
386
			incr = __tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
387 388

		if (incr) {
389
			incr = max_t(int, incr, 2 * skb->len);
390 391
			tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr,
					       tp->window_clamp);
392
			inet_csk(sk)->icsk_ack.quick |= 1;
L
Linus Torvalds 已提交
393 394 395 396 397 398 399
		}
	}
}

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

403 404
	rcvmem = 2 * SKB_TRUESIZE(mss + MAX_TCP_HEADER) *
		 tcp_default_init_rwnd(mss);
405

E
Eric Dumazet 已提交
406 407 408
	/* Dynamic Right Sizing (DRS) has 2 to 3 RTT latency
	 * Allow enough cushion so that sender is not limited by our window
	 */
409
	if (sock_net(sk)->ipv4.sysctl_tcp_moderate_rcvbuf)
E
Eric Dumazet 已提交
410 411
		rcvmem <<= 2;

412
	if (sk->sk_rcvbuf < rcvmem)
413
		sk->sk_rcvbuf = min(rcvmem, sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
414 415
}

S
Stephen Hemminger 已提交
416
/* 4. Try to fixup all. It is made immediately after connection enters
L
Linus Torvalds 已提交
417 418
 *    established state.
 */
419
void tcp_init_buffer_space(struct sock *sk)
L
Linus Torvalds 已提交
420
{
421
	int tcp_app_win = sock_net(sk)->ipv4.sysctl_tcp_app_win;
L
Linus Torvalds 已提交
422 423 424 425 426 427
	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 已提交
428
		tcp_sndbuf_expand(sk);
L
Linus Torvalds 已提交
429 430

	tp->rcvq_space.space = tp->rcv_wnd;
431
	tcp_mstamp_refresh(tp);
432
	tp->rcvq_space.time = tp->tcp_mstamp;
E
Eric Dumazet 已提交
433
	tp->rcvq_space.seq = tp->copied_seq;
L
Linus Torvalds 已提交
434 435 436 437 438 439

	maxwin = tcp_full_space(sk);

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

440
		if (tcp_app_win && maxwin > 4 * tp->advmss)
L
Linus Torvalds 已提交
441
			tp->window_clamp = max(maxwin -
442
					       (maxwin >> tcp_app_win),
L
Linus Torvalds 已提交
443 444 445 446
					       4 * tp->advmss);
	}

	/* Force reservation of one segment. */
447
	if (tcp_app_win &&
L
Linus Torvalds 已提交
448 449 450 451 452
	    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);
453
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
454 455 456
}

/* 5. Recalculate window clamp after socket hit its memory bounds. */
457
static void tcp_clamp_window(struct sock *sk)
L
Linus Torvalds 已提交
458
{
459
	struct tcp_sock *tp = tcp_sk(sk);
460
	struct inet_connection_sock *icsk = inet_csk(sk);
461
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
462

463
	icsk->icsk_ack.quick = 0;
L
Linus Torvalds 已提交
464

465
	if (sk->sk_rcvbuf < net->ipv4.sysctl_tcp_rmem[2] &&
466
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
467
	    !tcp_under_memory_pressure(sk) &&
468
	    sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)) {
469
		sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
470
				    net->ipv4.sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
471
	}
472
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf)
473
		tp->rcv_ssthresh = min(tp->window_clamp, 2U * tp->advmss);
L
Linus Torvalds 已提交
474 475
}

S
Stephen Hemminger 已提交
476 477 478 479 480 481 482 483 484
/* 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)
{
485
	const struct tcp_sock *tp = tcp_sk(sk);
S
Stephen Hemminger 已提交
486 487
	unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);

488
	hint = min(hint, tp->rcv_wnd / 2);
489
	hint = min(hint, TCP_MSS_DEFAULT);
S
Stephen Hemminger 已提交
490 491 492 493
	hint = max(hint, TCP_MIN_MSS);

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

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

536
	tp->rcv_rtt_est.rtt_us = new_sample;
L
Linus Torvalds 已提交
537 538 539 540
}

static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
{
541 542
	u32 delta_us;

543
	if (tp->rcv_rtt_est.time == 0)
L
Linus Torvalds 已提交
544 545 546
		goto new_measure;
	if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
		return;
547
	delta_us = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcv_rtt_est.time);
548 549
	if (!delta_us)
		delta_us = 1;
550
	tcp_rcv_rtt_update(tp, delta_us, 1);
L
Linus Torvalds 已提交
551 552 553

new_measure:
	tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
554
	tp->rcv_rtt_est.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
555 556
}

557 558
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
559
{
560
	struct tcp_sock *tp = tcp_sk(sk);
561

L
Linus Torvalds 已提交
562 563
	if (tp->rx_opt.rcv_tsecr &&
	    (TCP_SKB_CB(skb)->end_seq -
564 565
	     TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss)) {
		u32 delta = tcp_time_stamp(tp) - tp->rx_opt.rcv_tsecr;
566
		u32 delta_us;
567

568 569 570
		if (!delta)
			delta = 1;
		delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ);
571 572
		tcp_rcv_rtt_update(tp, delta_us, 0);
	}
L
Linus Torvalds 已提交
573 574 575 576 577 578 579 580 581
}

/*
 * 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);
582
	u32 copied;
L
Linus Torvalds 已提交
583
	int time;
584

585
	tcp_mstamp_refresh(tp);
586
	time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time);
587
	if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0)
L
Linus Torvalds 已提交
588
		return;
589

E
Eric Dumazet 已提交
590 591 592 593 594 595 596 597 598 599 600 601 602 603
	/* 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 .... >
	 */

604
	if (sock_net(sk)->ipv4.sysctl_tcp_moderate_rcvbuf &&
E
Eric Dumazet 已提交
605
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
606
		int rcvmem, rcvbuf;
E
Eric Dumazet 已提交
607
		u64 rcvwin, grow;
L
Linus Torvalds 已提交
608

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

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

E
Eric Dumazet 已提交
619
		rcvmem = SKB_TRUESIZE(tp->advmss + MAX_TCP_HEADER);
620
		while (tcp_win_from_space(sk, rcvmem) < tp->advmss)
E
Eric Dumazet 已提交
621
			rcvmem += 128;
L
Linus Torvalds 已提交
622

623 624 625
		do_div(rcvwin, tp->advmss);
		rcvbuf = min_t(u64, rcvwin * rcvmem,
			       sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
E
Eric Dumazet 已提交
626 627
		if (rcvbuf > sk->sk_rcvbuf) {
			sk->sk_rcvbuf = rcvbuf;
L
Linus Torvalds 已提交
628

E
Eric Dumazet 已提交
629
			/* Make the window clamp follow along.  */
630
			tp->window_clamp = tcp_win_from_space(sk, rcvbuf);
L
Linus Torvalds 已提交
631 632
		}
	}
E
Eric Dumazet 已提交
633
	tp->rcvq_space.space = copied;
634

L
Linus Torvalds 已提交
635 636
new_measure:
	tp->rcvq_space.seq = tp->copied_seq;
637
	tp->rcvq_space.time = tp->tcp_mstamp;
L
Linus Torvalds 已提交
638 639 640 641 642 643 644 645 646 647 648 649
}

/* 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
 */
650
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
651
{
652
	struct tcp_sock *tp = tcp_sk(sk);
653
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
654 655
	u32 now;

656
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
657

658
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
659 660

	tcp_rcv_rtt_measure(tp);
661

662
	now = tcp_jiffies32;
L
Linus Torvalds 已提交
663

664
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
665 666 667
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
668 669
		tcp_incr_quickack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
670
	} else {
671
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
672

673
		if (m <= TCP_ATO_MIN / 2) {
L
Linus Torvalds 已提交
674
			/* The fastest case is the first. */
675 676 677 678 679 680
			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 已提交
681
			/* Too long gap. Apparently sender failed to
L
Linus Torvalds 已提交
682 683
			 * restart window, so that we send ACKs quickly.
			 */
684
			tcp_incr_quickack(sk);
685
			sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
686 687
		}
	}
688
	icsk->icsk_ack.lrcvtime = now;
L
Linus Torvalds 已提交
689

690
	tcp_ecn_check_ce(tp, skb);
L
Linus Torvalds 已提交
691 692

	if (skb->len >= 128)
693
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
694 695 696 697 698 699 700 701 702 703 704
}

/* 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
 */
705
static void tcp_rtt_estimator(struct sock *sk, long mrtt_us)
L
Linus Torvalds 已提交
706
{
707
	struct tcp_sock *tp = tcp_sk(sk);
708 709
	long m = mrtt_us; /* RTT */
	u32 srtt = tp->srtt_us;
L
Linus Torvalds 已提交
710 711 712 713

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

E
Eric Dumazet 已提交
769 770 771 772 773 774
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) */
775 776 777 778 779 780 781 782 783 784 785
	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)
786
		rate *= sock_net(sk)->ipv4.sysctl_tcp_pacing_ss_ratio;
787
	else
788
		rate *= sock_net(sk)->ipv4.sysctl_tcp_pacing_ca_ratio;
E
Eric Dumazet 已提交
789 790 791

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

792 793
	if (likely(tp->srtt_us))
		do_div(rate, tp->srtt_us);
E
Eric Dumazet 已提交
794

795
	/* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate
796 797 798
	 * without any lock. We want to make sure compiler wont store
	 * intermediate values in this location.
	 */
799 800
	WRITE_ONCE(sk->sk_pacing_rate, min_t(u64, rate,
					     sk->sk_max_pacing_rate));
E
Eric Dumazet 已提交
801 802
}

L
Linus Torvalds 已提交
803 804 805
/* Calculate rto without backoff.  This is the second half of Van Jacobson's
 * routine referred to above.
 */
806
static void tcp_set_rto(struct sock *sk)
L
Linus Torvalds 已提交
807
{
808
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
809 810 811 812 813 814 815 816
	/* 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 已提交
817
	 *    ACKs in some circumstances.
L
Linus Torvalds 已提交
818
	 */
819
	inet_csk(sk)->icsk_rto = __tcp_set_rto(tp);
L
Linus Torvalds 已提交
820 821 822 823

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

827 828 829
	/* NOTE: clamping at TCP_RTO_MIN is not required, current algo
	 * guarantees that rto is higher.
	 */
830
	tcp_bound_rto(sk);
L
Linus Torvalds 已提交
831 832
}

833
__u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst)
L
Linus Torvalds 已提交
834 835 836
{
	__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

837
	if (!cwnd)
838
		cwnd = TCP_INIT_CWND;
L
Linus Torvalds 已提交
839 840 841
	return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
}

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

849 850 851 852 853 854
/* 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 已提交
855
{
856
	struct tcp_sock *tp = tcp_sk(sk);
857 858
	const u32 mss = tp->mss_cache;
	u32 fack, metric;
859

860 861
	fack = tcp_highest_sack_seq(tp);
	if (!before(low_seq, fack))
862 863
		return;

864 865
	metric = fack - low_seq;
	if ((metric > tp->reordering * mss) && mss) {
L
Linus Torvalds 已提交
866
#if FASTRETRANS_DEBUG > 1
867 868 869
		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,
870
			 0,
871 872
			 tp->sacked_out,
			 tp->undo_marker ? tp->undo_retrans : 0);
L
Linus Torvalds 已提交
873
#endif
874 875
		tp->reordering = min_t(u32, (metric + mss - 1) / mss,
				       sock_net(sk)->ipv4.sysctl_tcp_max_reordering);
L
Linus Torvalds 已提交
876
	}
Y
Yuchung Cheng 已提交
877

Y
Yuchung Cheng 已提交
878
	tp->rack.reord = 1;
879
	/* This exciting event is worth to be remembered. 8) */
880 881
	NET_INC_STATS(sock_net(sk),
		      ts ? LINUX_MIB_TCPTSREORDER : LINUX_MIB_TCPSACKREORDER);
L
Linus Torvalds 已提交
882 883
}

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

893 894 895 896 897 898 899 900 901 902 903 904 905 906 907 908
/* 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);
}

909 910 911 912 913 914
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);
915
		tcp_sum_lost(tp, skb);
916 917 918 919
		TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
	}
}

Y
Yuchung Cheng 已提交
920
void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb)
921 922 923
{
	tcp_verify_retransmit_hint(tp, skb);

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

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

1035
	/* In outstanding window? ...This is valid exit for D-SACKs too.
I
Ilpo Järvinen 已提交
1036 1037 1038
	 * start_seq == snd_una is non-sensical (see comments above)
	 */
	if (after(start_seq, tp->snd_una))
E
Eric Dumazet 已提交
1039
		return true;
I
Ilpo Järvinen 已提交
1040 1041

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

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

	if (!before(start_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1049
		return true;
I
Ilpo Järvinen 已提交
1050 1051 1052

	/* Too old */
	if (!after(end_seq, tp->undo_marker))
E
Eric Dumazet 已提交
1053
		return false;
I
Ilpo Järvinen 已提交
1054 1055 1056 1057 1058 1059 1060

	/* 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 已提交
1061 1062 1063
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)
1064
{
1065
	struct tcp_sock *tp = tcp_sk(sk);
1066 1067
	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 已提交
1068
	bool dup_sack = false;
1069 1070

	if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
E
Eric Dumazet 已提交
1071
		dup_sack = true;
1072
		tcp_dsack_seen(tp);
1073
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
1074
	} else if (num_sacks > 1) {
1075 1076
		u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
		u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
1077 1078 1079

		if (!after(end_seq_0, end_seq_1) &&
		    !before(start_seq_0, start_seq_1)) {
E
Eric Dumazet 已提交
1080
			dup_sack = true;
1081
			tcp_dsack_seen(tp);
1082
			NET_INC_STATS(sock_net(sk),
1083
					LINUX_MIB_TCPDSACKOFORECV);
1084 1085 1086 1087
		}
	}

	/* D-SACK for already forgotten data... Do dumb counting. */
Y
Yuchung Cheng 已提交
1088
	if (dup_sack && tp->undo_marker && tp->undo_retrans > 0 &&
1089 1090 1091 1092 1093 1094 1095
	    !after(end_seq_0, prior_snd_una) &&
	    after(end_seq_0, tp->undo_marker))
		tp->undo_retrans--;

	return dup_sack;
}

1096
struct tcp_sacktag_state {
1097
	u32	reord;
1098 1099 1100 1101
	/* 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.
	 */
1102 1103
	u64	first_sackt;
	u64	last_sackt;
1104
	struct rate_sample *rate;
1105
	int	flag;
1106
	unsigned int mss_now;
1107 1108
};

1109 1110 1111 1112 1113
/* 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).
1114 1115
 *
 * FIXME: this could be merged to shift decision code
1116
 */
1117
static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
E
Eric Dumazet 已提交
1118
				  u32 start_seq, u32 end_seq)
1119
{
E
Eric Dumazet 已提交
1120 1121
	int err;
	bool in_sack;
1122
	unsigned int pkt_len;
1123
	unsigned int mss;
1124 1125 1126 1127 1128 1129

	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)) {
1130
		mss = tcp_skb_mss(skb);
1131 1132
		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);

1133
		if (!in_sack) {
1134
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1135 1136 1137
			if (pkt_len < mss)
				pkt_len = mss;
		} else {
1138
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1139 1140 1141 1142 1143 1144 1145 1146 1147
			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;
1148
			if (!in_sack && new_len < pkt_len)
1149 1150 1151
				new_len += mss;
			pkt_len = new_len;
		}
1152 1153 1154 1155

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

1156 1157
		err = tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
				   pkt_len, mss, GFP_ATOMIC);
1158 1159 1160 1161 1162 1163 1164
		if (err < 0)
			return err;
	}

	return in_sack;
}

1165 1166 1167 1168
/* 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,
1169
			  int dup_sack, int pcount,
1170
			  u64 xmit_time)
1171
{
1172
	struct tcp_sock *tp = tcp_sk(sk);
1173 1174 1175

	/* Account D-SACK for retransmitted packet. */
	if (dup_sack && (sacked & TCPCB_RETRANS)) {
Y
Yuchung Cheng 已提交
1176
		if (tp->undo_marker && tp->undo_retrans > 0 &&
1177
		    after(end_seq, tp->undo_marker))
1178
			tp->undo_retrans--;
1179 1180 1181
		if ((sacked & TCPCB_SACKED_ACKED) &&
		    before(start_seq, state->reord))
				state->reord = start_seq;
1182 1183 1184
	}

	/* Nothing to do; acked frame is about to be dropped (was ACKed). */
1185
	if (!after(end_seq, tp->snd_una))
1186
		return sacked;
1187 1188

	if (!(sacked & TCPCB_SACKED_ACKED)) {
1189
		tcp_rack_advance(tp, sacked, end_seq, xmit_time);
1190

1191 1192 1193 1194 1195 1196
		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) {
1197
				sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
1198 1199
				tp->lost_out -= pcount;
				tp->retrans_out -= pcount;
1200 1201 1202 1203 1204 1205
			}
		} else {
			if (!(sacked & TCPCB_RETRANS)) {
				/* New sack for not retransmitted frame,
				 * which was in hole. It is reordering.
				 */
1206
				if (before(start_seq,
1207 1208 1209 1210
					   tcp_highest_sack_seq(tp)) &&
				    before(start_seq, state->reord))
					state->reord = start_seq;

Y
Yuchung Cheng 已提交
1211 1212
				if (!after(end_seq, tp->high_seq))
					state->flag |= FLAG_ORIG_SACK_ACKED;
1213 1214 1215
				if (state->first_sackt == 0)
					state->first_sackt = xmit_time;
				state->last_sackt = xmit_time;
1216 1217 1218
			}

			if (sacked & TCPCB_LOST) {
1219
				sacked &= ~TCPCB_LOST;
1220
				tp->lost_out -= pcount;
1221 1222 1223
			}
		}

1224 1225
		sacked |= TCPCB_SACKED_ACKED;
		state->flag |= FLAG_DATA_SACKED;
1226
		tp->sacked_out += pcount;
Y
Yuchung Cheng 已提交
1227
		tp->delivered += pcount;  /* Out-of-order packets delivered */
1228 1229

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
Y
Yuchung Cheng 已提交
1230
		if (tp->lost_skb_hint &&
1231
		    before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
1232
			tp->lost_cnt_hint += pcount;
1233 1234 1235 1236 1237 1238
	}

	/* 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.
	 */
1239 1240
	if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
		sacked &= ~TCPCB_SACKED_RETRANS;
1241
		tp->retrans_out -= pcount;
1242 1243
	}

1244
	return sacked;
1245 1246
}

1247 1248 1249
/* Shift newly-SACKed bytes from this skb to the immediately previous
 * already-SACKed sk_buff. Mark the newly-SACKed bytes as such.
 */
1250 1251
static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *prev,
			    struct sk_buff *skb,
E
Eric Dumazet 已提交
1252 1253 1254
			    struct tcp_sacktag_state *state,
			    unsigned int pcount, int shifted, int mss,
			    bool dup_sack)
1255 1256
{
	struct tcp_sock *tp = tcp_sk(sk);
1257 1258
	u32 start_seq = TCP_SKB_CB(skb)->seq;	/* start of newly-SACKed */
	u32 end_seq = start_seq + shifted;	/* end of newly-SACKed */
1259 1260 1261

	BUG_ON(!pcount);

1262 1263 1264 1265 1266 1267 1268
	/* 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 已提交
1269
			start_seq, end_seq, dup_sack, pcount,
1270
			skb->skb_mstamp);
1271
	tcp_rate_skb_delivered(sk, skb, state->rate);
1272 1273

	if (skb == tp->lost_skb_hint)
1274 1275
		tp->lost_cnt_hint += pcount;

1276 1277 1278
	TCP_SKB_CB(prev)->end_seq += shifted;
	TCP_SKB_CB(skb)->seq += shifted;

1279 1280 1281
	tcp_skb_pcount_add(prev, pcount);
	BUG_ON(tcp_skb_pcount(skb) < pcount);
	tcp_skb_pcount_add(skb, -pcount);
1282 1283 1284 1285 1286 1287

	/* 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.
	 */
1288 1289
	if (!TCP_SKB_CB(prev)->tcp_gso_size)
		TCP_SKB_CB(prev)->tcp_gso_size = mss;
1290 1291

	/* CHECKME: To clear or not to clear? Mimics normal skb currently */
1292
	if (tcp_skb_pcount(skb) <= 1)
1293
		TCP_SKB_CB(skb)->tcp_gso_size = 0;
1294 1295 1296 1297 1298 1299

	/* 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));
1300
		NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTED);
E
Eric Dumazet 已提交
1301
		return false;
1302 1303 1304 1305
	}

	/* Whole SKB was eaten :-) */

1306 1307 1308 1309 1310 1311 1312
	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);
	}

1313
	TCP_SKB_CB(prev)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
1314
	TCP_SKB_CB(prev)->eor = TCP_SKB_CB(skb)->eor;
1315 1316 1317
	if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
		TCP_SKB_CB(prev)->end_seq++;

1318 1319 1320
	if (skb == tcp_highest_sack(sk))
		tcp_advance_highest_sack(sk, skb);

1321
	tcp_skb_collapse_tstamp(prev, skb);
1322 1323
	if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp))
		TCP_SKB_CB(prev)->tx.delivered_mstamp = 0;
1324

1325
	tcp_rtx_queue_unlink_and_free(skb, sk);
1326

1327
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
1328

E
Eric Dumazet 已提交
1329
	return true;
1330 1331 1332 1333 1334
}

/* I wish gso_size would have a bit more sane initialization than
 * something-or-zero which complicates things
 */
1335
static int tcp_skb_seglen(const struct sk_buff *skb)
1336
{
1337
	return tcp_skb_pcount(skb) == 1 ? skb->len : tcp_skb_mss(skb);
1338 1339 1340
}

/* Shifting pages past head area doesn't work */
1341
static int skb_can_shift(const struct sk_buff *skb)
1342 1343 1344 1345 1346 1347 1348 1349
{
	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,
1350
					  struct tcp_sacktag_state *state,
1351
					  u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1352
					  bool dup_sack)
1353 1354 1355 1356 1357 1358 1359 1360 1361 1362 1363 1364 1365
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *prev;
	int mss;
	int pcount = 0;
	int len;
	int in_sack;

	if (!sk_can_gso(sk))
		goto fallback;

	/* Normally R but no L won't result in plain S */
	if (!dup_sack &&
1366
	    (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1367 1368 1369 1370 1371 1372 1373 1374
		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 */
1375 1376
	prev = skb_rb_prev(skb);
	if (!prev)
1377 1378 1379 1380 1381
		goto fallback;

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

1382 1383 1384
	if (!tcp_skb_can_collapse_to(prev))
		goto fallback;

1385 1386 1387 1388 1389 1390
	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);
1391
		mss = tcp_skb_seglen(skb);
1392 1393 1394 1395

		/* TODO: Fix DSACKs to not fragment already SACKed and we can
		 * drop this restriction as unnecessary
		 */
1396
		if (mss != tcp_skb_seglen(prev))
1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419 1420 1421 1422 1423 1424 1425 1426 1427 1428 1429 1430 1431 1432 1433 1434 1435 1436
			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
		 */
1437
		if (mss != tcp_skb_seglen(prev))
1438 1439 1440 1441 1442 1443 1444 1445 1446 1447 1448 1449
			goto fallback;

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

1450 1451 1452 1453
	/* tcp_sacktag_one() won't SACK-tag ranges below snd_una */
	if (!after(TCP_SKB_CB(skb)->seq + len, tp->snd_una))
		goto fallback;

1454 1455
	if (!skb_shift(prev, skb, len))
		goto fallback;
1456
	if (!tcp_shifted_skb(sk, prev, skb, state, pcount, len, mss, dup_sack))
1457 1458 1459 1460 1461
		goto out;

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

1466 1467
	if (!skb_can_shift(skb) ||
	    ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1468
	    (mss != tcp_skb_seglen(skb)))
1469 1470 1471 1472 1473
		goto out;

	len = skb->len;
	if (skb_shift(prev, skb, len)) {
		pcount += tcp_skb_pcount(skb);
1474 1475
		tcp_shifted_skb(sk, prev, skb, state, tcp_skb_pcount(skb),
				len, mss, 0);
1476 1477 1478 1479 1480 1481 1482 1483 1484
	}

out:
	return prev;

noop:
	return skb;

fallback:
1485
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1486 1487 1488
	return NULL;
}

1489 1490
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
1491
					struct tcp_sacktag_state *state,
1492
					u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1493
					bool dup_sack_in)
1494
{
1495 1496 1497
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *tmp;

1498
	skb_rbtree_walk_from(skb) {
1499
		int in_sack = 0;
E
Eric Dumazet 已提交
1500
		bool dup_sack = dup_sack_in;
1501 1502 1503 1504 1505

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

1506
		if (next_dup  &&
1507 1508 1509 1510 1511
		    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 已提交
1512
				dup_sack = true;
1513 1514
		}

1515 1516 1517 1518 1519
		/* 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) {
1520 1521
			tmp = tcp_shift_skb_data(sk, skb, state,
						 start_seq, end_seq, dup_sack);
1522
			if (tmp) {
1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535
				if (tmp != skb) {
					skb = tmp;
					continue;
				}

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

1536 1537 1538
		if (unlikely(in_sack < 0))
			break;

1539
		if (in_sack) {
1540 1541 1542 1543 1544 1545 1546
			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 已提交
1547
						tcp_skb_pcount(skb),
1548
						skb->skb_mstamp);
1549
			tcp_rate_skb_delivered(sk, skb, state->rate);
1550 1551
			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
				list_del_init(&skb->tcp_tsorted_anchor);
1552

1553 1554 1555 1556
			if (!before(TCP_SKB_CB(skb)->seq,
				    tcp_highest_sack_seq(tp)))
				tcp_advance_highest_sack(sk, skb);
		}
1557 1558 1559 1560
	}
	return skb;
}

1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573 1574 1575 1576 1577 1578 1579 1580 1581 1582 1583
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;
}

1584
static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,
1585 1586
					struct tcp_sacktag_state *state,
					u32 skip_to_seq)
1587
{
1588 1589
	if (skb && after(TCP_SKB_CB(skb)->seq, skip_to_seq))
		return skb;
1590

1591
	return tcp_sacktag_bsearch(sk, state, skip_to_seq);
1592 1593 1594 1595 1596
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
1597 1598
						struct tcp_sacktag_state *state,
						u32 skip_to_seq)
1599
{
1600
	if (!next_dup)
1601 1602 1603
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1604 1605 1606 1607
		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);
1608 1609 1610 1611 1612
	}

	return skb;
}

1613
static int tcp_sack_cache_ok(const struct tcp_sock *tp, const struct tcp_sack_block *cache)
1614 1615 1616 1617
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

L
Linus Torvalds 已提交
1618
static int
1619
tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
1620
			u32 prior_snd_una, struct tcp_sacktag_state *state)
L
Linus Torvalds 已提交
1621 1622
{
	struct tcp_sock *tp = tcp_sk(sk);
1623 1624
	const unsigned char *ptr = (skb_transport_header(ack_skb) +
				    TCP_SKB_CB(ack_skb)->sacked);
1625
	struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);
1626
	struct tcp_sack_block sp[TCP_NUM_SACKS];
1627 1628
	struct tcp_sack_block *cache;
	struct sk_buff *skb;
1629
	int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);
1630
	int used_sacks;
E
Eric Dumazet 已提交
1631
	bool found_dup_sack = false;
1632
	int i, j;
1633
	int first_sack_index;
L
Linus Torvalds 已提交
1634

1635
	state->flag = 0;
1636
	state->reord = tp->snd_nxt;
1637

1638
	if (!tp->sacked_out)
1639
		tcp_highest_sack_reset(sk);
L
Linus Torvalds 已提交
1640

1641
	found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,
1642
					 num_sacks, prior_snd_una);
1643
	if (found_dup_sack) {
1644
		state->flag |= FLAG_DSACKING_ACK;
1645 1646
		tp->delivered++; /* A spurious retransmission is delivered */
	}
1647 1648 1649 1650 1651 1652 1653 1654

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

1655 1656 1657
	if (!tp->packets_out)
		goto out;

1658 1659 1660
	used_sacks = 0;
	first_sack_index = 0;
	for (i = 0; i < num_sacks; i++) {
E
Eric Dumazet 已提交
1661
		bool dup_sack = !i && found_dup_sack;
1662

1663 1664
		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);
1665 1666 1667 1668

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

1671 1672
			if (dup_sack) {
				if (!tp->undo_marker)
1673
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;
1674
				else
1675
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;
1676 1677 1678 1679 1680
			} 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;
1681
				mib_idx = LINUX_MIB_TCPSACKDISCARD;
1682
			}
1683

1684
			NET_INC_STATS(sock_net(sk), mib_idx);
1685 1686 1687 1688 1689 1690 1691 1692 1693 1694 1695 1696
			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++;
	}

1697 1698
	/* order SACK blocks to allow in order walk of the retrans queue */
	for (i = used_sacks - 1; i > 0; i--) {
1699 1700
		for (j = 0; j < i; j++) {
			if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1701
				swap(sp[j], sp[j + 1]);
1702

1703 1704
				/* Track where the first SACK block goes to */
				if (j == first_sack_index)
1705
					first_sack_index = j + 1;
1706 1707 1708 1709
			}
		}
	}

1710 1711
	state->mss_now = tcp_current_mss(sk);
	skb = NULL;
1712 1713 1714 1715 1716 1717 1718 1719 1720 1721 1722
	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++;
1723 1724
	}

1725
	while (i < used_sacks) {
1726 1727
		u32 start_seq = sp[i].start_seq;
		u32 end_seq = sp[i].end_seq;
E
Eric Dumazet 已提交
1728
		bool dup_sack = (found_dup_sack && (i == first_sack_index));
1729
		struct tcp_sack_block *next_dup = NULL;
1730

1731 1732
		if (found_dup_sack && ((i + 1) == first_sack_index))
			next_dup = &sp[i + 1];
L
Linus Torvalds 已提交
1733

1734 1735 1736 1737 1738 1739 1740 1741 1742 1743 1744
		/* 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)) {
1745
				skb = tcp_sacktag_skip(skb, sk, state,
1746
						       start_seq);
1747
				skb = tcp_sacktag_walk(skb, sk, next_dup,
1748
						       state,
1749 1750
						       start_seq,
						       cache->start_seq,
1751
						       dup_sack);
1752
			}
1753

1754
			/* Rest of the block already fully processed? */
1755
			if (!after(end_seq, cache->end_seq))
1756
				goto advance_sp;
1757

1758
			skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
1759
						       state,
1760
						       cache->end_seq);
1761

1762
			/* ...tail remains todo... */
1763
			if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1764
				/* ...but better entrypoint exists! */
1765
				skb = tcp_highest_sack(sk);
1766
				if (!skb)
1767
					break;
1768 1769
				cache++;
				goto walk;
1770 1771
			}

1772
			skb = tcp_sacktag_skip(skb, sk, state, cache->end_seq);
1773 1774 1775 1776
			/* Check overlap against next cached too (past this one already) */
			cache++;
			continue;
		}
L
Linus Torvalds 已提交
1777

1778 1779
		if (!before(start_seq, tcp_highest_sack_seq(tp))) {
			skb = tcp_highest_sack(sk);
1780
			if (!skb)
1781
				break;
L
Linus Torvalds 已提交
1782
		}
1783
		skb = tcp_sacktag_skip(skb, sk, state, start_seq);
1784 1785

walk:
1786
		skb = tcp_sacktag_walk(skb, sk, next_dup, state,
1787
				       start_seq, end_seq, dup_sack);
1788

1789 1790
advance_sp:
		i++;
L
Linus Torvalds 已提交
1791 1792
	}

1793 1794 1795 1796 1797 1798 1799 1800
	/* 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];

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

1804
	tcp_verify_left_out(tp);
1805 1806
out:

L
Linus Torvalds 已提交
1807
#if FASTRETRANS_DEBUG > 0
1808 1809 1810 1811
	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 已提交
1812
#endif
1813
	return state->flag;
L
Linus Torvalds 已提交
1814 1815
}

1816
/* Limits sacked_out so that sum with lost_out isn't ever larger than
E
Eric Dumazet 已提交
1817
 * packets_out. Returns false if sacked_out adjustement wasn't necessary.
1818
 */
E
Eric Dumazet 已提交
1819
static bool tcp_limit_reno_sacked(struct tcp_sock *tp)
1820 1821 1822 1823 1824 1825 1826 1827
{
	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 已提交
1828
		return true;
1829
	}
E
Eric Dumazet 已提交
1830
	return false;
1831 1832 1833 1834 1835 1836 1837 1838 1839
}

/* 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);
1840 1841 1842 1843 1844 1845 1846

	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);
1847 1848 1849 1850 1851 1852 1853
}

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

1856 1857
	tp->sacked_out++;
	tcp_check_reno_reordering(sk, 0);
Y
Yuchung Cheng 已提交
1858 1859
	if (tp->sacked_out > prior_sacked)
		tp->delivered++; /* Some out-of-order packet is delivered */
1860
	tcp_verify_left_out(tp);
1861 1862 1863 1864 1865 1866 1867 1868 1869 1870
}

/* 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 已提交
1871
		tp->delivered += max_t(int, acked - tp->sacked_out, 1);
1872
		if (acked - 1 >= tp->sacked_out)
1873 1874
			tp->sacked_out = 0;
		else
1875
			tp->sacked_out -= acked - 1;
1876 1877
	}
	tcp_check_reno_reordering(sk, acked);
1878
	tcp_verify_left_out(tp);
1879 1880 1881 1882 1883 1884 1885
}

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

Y
Yuchung Cheng 已提交
1886
void tcp_clear_retrans(struct tcp_sock *tp)
L
Linus Torvalds 已提交
1887 1888 1889 1890
{
	tp->retrans_out = 0;
	tp->lost_out = 0;
	tp->undo_marker = 0;
Y
Yuchung Cheng 已提交
1891
	tp->undo_retrans = -1;
Y
Yuchung Cheng 已提交
1892
	tp->sacked_out = 0;
L
Linus Torvalds 已提交
1893 1894
}

Y
Yuchung Cheng 已提交
1895
static inline void tcp_init_undo(struct tcp_sock *tp)
1896
{
Y
Yuchung Cheng 已提交
1897 1898 1899
	tp->undo_marker = tp->snd_una;
	/* Retransmission still in flight may cause DSACKs later. */
	tp->undo_retrans = tp->retrans_out ? : -1;
1900 1901
}

1902
/* Enter Loss state. If we detect SACK reneging, forget all SACK information
L
Linus Torvalds 已提交
1903 1904 1905
 * and reset tags completely, otherwise preserve SACKs. If receiver
 * dropped its ofo queue, we will know this due to reneging detection.
 */
1906
void tcp_enter_loss(struct sock *sk)
L
Linus Torvalds 已提交
1907
{
1908
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1909
	struct tcp_sock *tp = tcp_sk(sk);
1910
	struct net *net = sock_net(sk);
L
Linus Torvalds 已提交
1911
	struct sk_buff *skb;
1912
	bool is_reneg;			/* is receiver reneging on SACKs? */
1913
	bool mark_lost;
L
Linus Torvalds 已提交
1914 1915

	/* Reduce ssthresh if it has not yet been made inside this window. */
Y
Yuchung Cheng 已提交
1916 1917
	if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
	    !after(tp->high_seq, tp->snd_una) ||
1918 1919
	    (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
1920
		tp->prior_cwnd = tp->snd_cwnd;
1921 1922
		tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		tcp_ca_event(sk, CA_EVENT_LOSS);
Y
Yuchung Cheng 已提交
1923
		tcp_init_undo(tp);
L
Linus Torvalds 已提交
1924 1925 1926
	}
	tp->snd_cwnd	   = 1;
	tp->snd_cwnd_cnt   = 0;
1927
	tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
1928

Y
Yuchung Cheng 已提交
1929 1930
	tp->retrans_out = 0;
	tp->lost_out = 0;
1931 1932 1933

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

1935
	skb = tcp_rtx_queue_head(sk);
1936 1937
	is_reneg = skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED);
	if (is_reneg) {
1938
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
1939
		tp->sacked_out = 0;
1940 1941
		/* Mark SACK reneging until we recover from this loss event. */
		tp->is_sack_reneg = 1;
1942
	}
1943
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
1944

1945
	skb_rbtree_walk_from(skb) {
1946 1947 1948 1949
		mark_lost = (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
			     is_reneg);
		if (mark_lost)
			tcp_sum_lost(tp, skb);
L
Linus Torvalds 已提交
1950
		TCP_SKB_CB(skb)->sacked &= (~TCPCB_TAGBITS)|TCPCB_SACKED_ACKED;
1951
		if (mark_lost) {
L
Linus Torvalds 已提交
1952 1953 1954 1955 1956
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
		}
	}
1957
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1958

1959 1960 1961 1962
	/* 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 &&
1963
	    tp->sacked_out >= net->ipv4.sysctl_tcp_reordering)
1964
		tp->reordering = min_t(unsigned int, tp->reordering,
1965
				       net->ipv4.sysctl_tcp_reordering);
1966
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
1967
	tp->high_seq = tp->snd_nxt;
1968
	tcp_ecn_queue_cwr(tp);
Y
Yuchung Cheng 已提交
1969

1970 1971 1972 1973 1974 1975 1976
	/* F-RTO RFC5682 sec 3.1 step 1 mandates to disable F-RTO
	 * if a previous recovery is underway, otherwise it may incorrectly
	 * call a timeout spurious if some previously retransmitted packets
	 * are s/acked (sec 3.2). We do not apply that retriction since
	 * retransmitted skbs are permanently tagged with TCPCB_EVER_RETRANS
	 * so FLAG_ORIG_SACK_ACKED is always correct. But we do disable F-RTO
	 * on PTMU discovery to avoid sending new data.
Y
Yuchung Cheng 已提交
1977
	 */
E
Eric Dumazet 已提交
1978
	tp->frto = net->ipv4.sysctl_tcp_frto &&
1979
		   !inet_csk(sk)->icsk_mtup.probe_size;
L
Linus Torvalds 已提交
1980 1981
}

1982 1983 1984 1985
/* 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).
 *
1986 1987 1988 1989 1990
 * 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.
1991
 */
E
Eric Dumazet 已提交
1992
static bool tcp_check_sack_reneging(struct sock *sk, int flag)
L
Linus Torvalds 已提交
1993
{
1994
	if (flag & FLAG_SACK_RENEGING) {
1995 1996 1997
		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 已提交
1998

1999
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2000
					  delay, TCP_RTO_MAX);
E
Eric Dumazet 已提交
2001
		return true;
L
Linus Torvalds 已提交
2002
	}
E
Eric Dumazet 已提交
2003
	return false;
L
Linus Torvalds 已提交
2004 2005
}

2006 2007 2008 2009 2010 2011 2012 2013 2014 2015 2016
/* 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.
 */
2017
static inline int tcp_dupack_heuristics(const struct tcp_sock *tp)
2018
{
Y
Yuchung Cheng 已提交
2019
	return tp->sacked_out + 1;
2020 2021
}

Y
Yuchung Cheng 已提交
2022
/* Linux NewReno/SACK/ECN state machine.
L
Linus Torvalds 已提交
2023 2024 2025 2026 2027 2028 2029 2030 2031 2032 2033 2034 2035 2036 2037 2038 2039 2040 2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055 2056 2057 2058 2059 2060 2061 2062 2063 2064 2065 2066 2067 2068
 * --------------------------------------
 *
 * "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.
 *
2069
 *		Essentially, we have now a few algorithms detecting
L
Linus Torvalds 已提交
2070 2071
 *		lost packets.
 *
2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089
 *		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 已提交
2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107 2108 2109 2110 2111 2112 2113 2114 2115 2116 2117 2118
 *		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 已提交
2119
static bool tcp_time_to_recover(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2120
{
2121
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2122 2123 2124

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

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

E
Eric Dumazet 已提交
2131
	return false;
L
Linus Torvalds 已提交
2132 2133
}

2134
/* Detect loss in event "A" above by marking head of queue up as lost.
Y
Yuchung Cheng 已提交
2135
 * For non-SACK(Reno) senders, the first "packets" number of segments
2136 2137 2138
 * 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.
2139
 */
I
Ilpo Järvinen 已提交
2140
static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
L
Linus Torvalds 已提交
2141
{
2142
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2143
	struct sk_buff *skb;
2144
	int cnt, oldcnt, lost;
2145
	unsigned int mss;
2146 2147
	/* 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 已提交
2148

2149
	WARN_ON(packets > tp->packets_out);
2150 2151
	skb = tp->lost_skb_hint;
	if (skb) {
I
Ilpo Järvinen 已提交
2152
		/* Head already handled? */
2153
		if (mark_head && after(TCP_SKB_CB(skb)->seq, tp->snd_una))
I
Ilpo Järvinen 已提交
2154
			return;
2155
		cnt = tp->lost_cnt_hint;
2156
	} else {
2157
		skb = tcp_rtx_queue_head(sk);
2158 2159
		cnt = 0;
	}
L
Linus Torvalds 已提交
2160

2161
	skb_rbtree_walk_from(skb) {
2162 2163 2164 2165
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2166

2167
		if (after(TCP_SKB_CB(skb)->end_seq, loss_high))
2168 2169 2170
			break;

		oldcnt = cnt;
Y
Yuchung Cheng 已提交
2171
		if (tcp_is_reno(tp) ||
2172 2173 2174
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

2175
		if (cnt > packets) {
Y
Yuchung Cheng 已提交
2176
			if (tcp_is_sack(tp) ||
2177
			    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
2178
			    (oldcnt >= packets))
2179 2180
				break;

2181
			mss = tcp_skb_mss(skb);
2182 2183 2184
			/* If needed, chop off the prefix to mark as lost. */
			lost = (packets - oldcnt) * mss;
			if (lost < skb->len &&
2185 2186
			    tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
					 lost, mss, GFP_ATOMIC) < 0)
2187 2188 2189 2190
				break;
			cnt = packets;
		}

2191
		tcp_skb_mark_lost(tp, skb);
I
Ilpo Järvinen 已提交
2192 2193 2194

		if (mark_head)
			break;
L
Linus Torvalds 已提交
2195
	}
2196
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2197 2198 2199 2200
}

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

2201
static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
L
Linus Torvalds 已提交
2202
{
2203 2204
	struct tcp_sock *tp = tcp_sk(sk);

2205
	if (tcp_is_reno(tp)) {
I
Ilpo Järvinen 已提交
2206
		tcp_mark_head_lost(sk, 1, 1);
L
Linus Torvalds 已提交
2207
	} else {
2208
		int sacked_upto = tp->sacked_out - tp->reordering;
I
Ilpo Järvinen 已提交
2209 2210 2211 2212
		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 已提交
2213 2214 2215
	}
}

2216 2217 2218 2219 2220 2221
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);
}

2222 2223 2224 2225 2226 2227 2228 2229 2230 2231
/* 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 已提交
2232 2233 2234
/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
2235
static inline bool tcp_packet_delayed(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2236 2237
{
	return !tp->retrans_stamp ||
2238
	       tcp_tsopt_ecr_before(tp, tp->retrans_stamp);
L
Linus Torvalds 已提交
2239 2240 2241 2242
}

/* Undo procedures. */

2243 2244 2245 2246 2247 2248 2249 2250 2251 2252 2253 2254 2255 2256 2257 2258 2259 2260 2261 2262 2263 2264
/* 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;

2265
	skb = tcp_rtx_queue_head(sk);
2266 2267 2268 2269 2270 2271
	if (unlikely(skb && TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS))
		return true;

	return false;
}

2272
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2273
{
J
Joe Perches 已提交
2274
#if FASTRETRANS_DEBUG > 1
2275
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2276
	struct inet_sock *inet = inet_sk(sk);
2277

2278
	if (sk->sk_family == AF_INET) {
2279 2280 2281 2282 2283 2284
		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);
2285
	}
E
Eric Dumazet 已提交
2286
#if IS_ENABLED(CONFIG_IPV6)
2287
	else if (sk->sk_family == AF_INET6) {
2288 2289
		pr_debug("Undo %s %pI6/%u c%u l%u ss%u/%u p%u\n",
			 msg,
2290
			 &sk->sk_v6_daddr, ntohs(inet->inet_dport),
2291 2292 2293
			 tp->snd_cwnd, tcp_left_out(tp),
			 tp->snd_ssthresh, tp->prior_ssthresh,
			 tp->packets_out);
2294 2295
	}
#endif
L
Linus Torvalds 已提交
2296
#endif
J
Joe Perches 已提交
2297
}
L
Linus Torvalds 已提交
2298

2299
static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
L
Linus Torvalds 已提交
2300
{
2301 2302
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2303 2304 2305
	if (unmark_loss) {
		struct sk_buff *skb;

2306
		skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
Y
Yuchung Cheng 已提交
2307 2308 2309 2310 2311 2312
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
		}
		tp->lost_out = 0;
		tcp_clear_all_retrans_hints(tp);
	}

L
Linus Torvalds 已提交
2313
	if (tp->prior_ssthresh) {
2314 2315
		const struct inet_connection_sock *icsk = inet_csk(sk);

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

2318
		if (tp->prior_ssthresh > tp->snd_ssthresh) {
L
Linus Torvalds 已提交
2319
			tp->snd_ssthresh = tp->prior_ssthresh;
2320
			tcp_ecn_withdraw_cwr(tp);
L
Linus Torvalds 已提交
2321 2322
		}
	}
2323
	tp->snd_cwnd_stamp = tcp_jiffies32;
2324
	tp->undo_marker = 0;
2325
	tp->rack.advanced = 1; /* Force RACK to re-exam losses */
L
Linus Torvalds 已提交
2326 2327
}

2328
static inline bool tcp_may_undo(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2329
{
2330
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2331 2332 2333
}

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

L
Linus Torvalds 已提交
2338
	if (tcp_may_undo(tp)) {
2339 2340
		int mib_idx;

L
Linus Torvalds 已提交
2341 2342 2343
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2344
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2345
		tcp_undo_cwnd_reduction(sk, false);
2346
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2347
			mib_idx = LINUX_MIB_TCPLOSSUNDO;
L
Linus Torvalds 已提交
2348
		else
2349 2350
			mib_idx = LINUX_MIB_TCPFULLUNDO;

2351
		NET_INC_STATS(sock_net(sk), mib_idx);
2352 2353
	} else if (tp->rack.reo_wnd_persist) {
		tp->rack.reo_wnd_persist--;
L
Linus Torvalds 已提交
2354
	}
2355
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2356 2357 2358
		/* 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. */
2359 2360
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;
E
Eric Dumazet 已提交
2361
		return true;
L
Linus Torvalds 已提交
2362
	}
2363
	tcp_set_ca_state(sk, TCP_CA_Open);
2364
	tp->is_sack_reneg = 0;
E
Eric Dumazet 已提交
2365
	return false;
L
Linus Torvalds 已提交
2366 2367 2368
}

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

L
Linus Torvalds 已提交
2373
	if (tp->undo_marker && !tp->undo_retrans) {
2374 2375
		tp->rack.reo_wnd_persist = min(TCP_RACK_RECOVERY_THRESH,
					       tp->rack.reo_wnd_persist + 1);
2376
		DBGUNDO(sk, "D-SACK");
2377
		tcp_undo_cwnd_reduction(sk, false);
2378
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
2379
		return true;
L
Linus Torvalds 已提交
2380
	}
2381
	return false;
L
Linus Torvalds 已提交
2382 2383
}

Y
Yuchung Cheng 已提交
2384 2385
/* 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 已提交
2386
{
2387 2388
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2389
	if (frto_undo || tcp_may_undo(tp)) {
2390
		tcp_undo_cwnd_reduction(sk, true);
2391

2392
		DBGUNDO(sk, "partial loss");
2393
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
Y
Yuchung Cheng 已提交
2394
		if (frto_undo)
2395
			NET_INC_STATS(sock_net(sk),
2396
					LINUX_MIB_TCPSPURIOUSRTOS);
2397
		inet_csk(sk)->icsk_retransmits = 0;
2398
		if (frto_undo || tcp_is_sack(tp)) {
2399
			tcp_set_ca_state(sk, TCP_CA_Open);
2400 2401
			tp->is_sack_reneg = 0;
		}
E
Eric Dumazet 已提交
2402
		return true;
L
Linus Torvalds 已提交
2403
	}
E
Eric Dumazet 已提交
2404
	return false;
L
Linus Torvalds 已提交
2405 2406
}

2407
/* The cwnd reduction in CWR and Recovery uses the PRR algorithm in RFC 6937.
2408 2409 2410 2411
 * 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.
2412 2413 2414
 *   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.
2415
 */
2416
static void tcp_init_cwnd_reduction(struct sock *sk)
2417 2418 2419 2420
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->high_seq = tp->snd_nxt;
N
Nandita Dukkipati 已提交
2421
	tp->tlp_high_seq = 0;
2422 2423 2424 2425
	tp->snd_cwnd_cnt = 0;
	tp->prior_cwnd = tp->snd_cwnd;
	tp->prr_delivered = 0;
	tp->prr_out = 0;
2426
	tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);
2427
	tcp_ecn_queue_cwr(tp);
2428 2429
}

2430
void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int flag)
2431 2432 2433 2434 2435
{
	struct tcp_sock *tp = tcp_sk(sk);
	int sndcnt = 0;
	int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);

2436 2437 2438
	if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))
		return;

2439
	tp->prr_delivered += newly_acked_sacked;
2440
	if (delta < 0) {
2441 2442 2443
		u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
			       tp->prior_cwnd - 1;
		sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;
2444 2445
	} else if ((flag & FLAG_RETRANS_DATA_ACKED) &&
		   !(flag & FLAG_LOST_RETRANS)) {
2446 2447 2448
		sndcnt = min_t(int, delta,
			       max_t(int, tp->prr_delivered - tp->prr_out,
				     newly_acked_sacked) + 1);
2449 2450
	} else {
		sndcnt = min(delta, newly_acked_sacked);
2451
	}
2452 2453
	/* Force a fast retransmit upon entering fast recovery */
	sndcnt = max(sndcnt, (tp->prr_out ? 0 : 1));
2454 2455 2456
	tp->snd_cwnd = tcp_packets_in_flight(tp) + sndcnt;
}

2457
static inline void tcp_end_cwnd_reduction(struct sock *sk)
L
Linus Torvalds 已提交
2458
{
2459
	struct tcp_sock *tp = tcp_sk(sk);
2460

2461 2462 2463
	if (inet_csk(sk)->icsk_ca_ops->cong_control)
		return;

2464
	/* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
2465 2466
	if (tp->snd_ssthresh < TCP_INFINITE_SSTHRESH &&
	    (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR || tp->undo_marker)) {
2467
		tp->snd_cwnd = tp->snd_ssthresh;
2468
		tp->snd_cwnd_stamp = tcp_jiffies32;
2469
	}
2470
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2471 2472
}

2473
/* Enter CWR state. Disable cwnd undo since congestion is proven with ECN */
2474
void tcp_enter_cwr(struct sock *sk)
Y
Yuchung Cheng 已提交
2475 2476 2477 2478
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->prior_ssthresh = 0;
2479
	if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
Y
Yuchung Cheng 已提交
2480
		tp->undo_marker = 0;
2481
		tcp_init_cwnd_reduction(sk);
Y
Yuchung Cheng 已提交
2482 2483 2484
		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}
2485
EXPORT_SYMBOL(tcp_enter_cwr);
Y
Yuchung Cheng 已提交
2486

2487 2488 2489 2490 2491
static void tcp_try_keep_open(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int state = TCP_CA_Open;

2492
	if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
2493 2494 2495 2496 2497 2498 2499 2500
		state = TCP_CA_Disorder;

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

2501
static void tcp_try_to_open(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2502
{
2503 2504
	struct tcp_sock *tp = tcp_sk(sk);

2505 2506
	tcp_verify_left_out(tp);

Y
Yuchung Cheng 已提交
2507
	if (!tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2508 2509
		tp->retrans_stamp = 0;

2510
	if (flag & FLAG_ECE)
2511
		tcp_enter_cwr(sk);
L
Linus Torvalds 已提交
2512

2513
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2514
		tcp_try_keep_open(sk);
L
Linus Torvalds 已提交
2515 2516 2517
	}
}

J
John Heffner 已提交
2518 2519 2520 2521 2522 2523
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;
2524
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
J
John Heffner 已提交
2525 2526
}

2527
static void tcp_mtup_probe_success(struct sock *sk)
J
John Heffner 已提交
2528 2529 2530 2531 2532 2533 2534 2535 2536 2537
{
	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;
2538
	tp->snd_cwnd_stamp = tcp_jiffies32;
2539
	tp->snd_ssthresh = tcp_current_ssthresh(sk);
J
John Heffner 已提交
2540 2541 2542 2543

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

2547 2548 2549 2550 2551 2552 2553 2554 2555
/* 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 已提交
2556
	unsigned int mss = tcp_current_mss(sk);
2557

2558
	skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
2559
		if (tcp_skb_seglen(skb) > mss &&
2560 2561 2562 2563 2564 2565 2566 2567 2568 2569 2570
		    !(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);

2571
	if (!tp->lost_out)
2572 2573 2574 2575 2576 2577 2578 2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589 2590 2591 2592
		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 已提交
2593
EXPORT_SYMBOL(tcp_simple_retransmit);
2594

2595
void tcp_enter_recovery(struct sock *sk, bool ece_ack)
2596 2597 2598 2599 2600 2601 2602 2603 2604
{
	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;

2605
	NET_INC_STATS(sock_net(sk), mib_idx);
2606 2607

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

2610
	if (!tcp_in_cwnd_reduction(sk)) {
2611 2612
		if (!ece_ack)
			tp->prior_ssthresh = tcp_current_ssthresh(sk);
2613
		tcp_init_cwnd_reduction(sk);
2614 2615 2616 2617
	}
	tcp_set_ca_state(sk, TCP_CA_Recovery);
}

2618 2619 2620
/* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
 * recovered or spurious. Otherwise retransmits more on partial ACKs.
 */
2621 2622
static void tcp_process_loss(struct sock *sk, int flag, bool is_dupack,
			     int *rexmit)
2623 2624
{
	struct tcp_sock *tp = tcp_sk(sk);
Y
Yuchung Cheng 已提交
2625
	bool recovered = !before(tp->snd_una, tp->high_seq);
2626

2627 2628 2629 2630
	if ((flag & FLAG_SND_UNA_ADVANCED) &&
	    tcp_try_undo_loss(sk, false))
		return;

2631 2632 2633 2634 2635 2636 2637 2638 2639 2640
	/* The ACK (s)acks some never-retransmitted data meaning not all
	 * the data packets before the timeout were lost. Therefore we
	 * undo the congestion window and state. This is essentially
	 * the operation in F-RTO (RFC5682 section 3.1 step 3.b). Since
	 * a retransmitted skb is permantly marked, we can apply such an
	 * operation even if F-RTO was not used.
	 */
	if ((flag & FLAG_ORIG_SACK_ACKED) &&
	    tcp_try_undo_loss(sk, tp->undo_marker))
		return;
2641

2642
	if (tp->frto) { /* F-RTO RFC5682 sec 3.1 (sack enhanced version). */
2643 2644 2645
		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 已提交
2646 2647
		} else if (flag & FLAG_SND_UNA_ADVANCED && !recovered) {
			tp->high_seq = tp->snd_nxt;
2648 2649 2650 2651
			/* Step 2.b. Try send new data (but deferred until cwnd
			 * is updated in tcp_ack()). Otherwise fall back to
			 * the conventional recovery.
			 */
2652
			if (!tcp_write_queue_empty(sk) &&
2653 2654 2655 2656
			    after(tcp_wnd_end(tp), tp->snd_nxt)) {
				*rexmit = REXMIT_NEW;
				return;
			}
Y
Yuchung Cheng 已提交
2657 2658 2659 2660 2661 2662
			tp->frto = 0;
		}
	}

	if (recovered) {
		/* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
2663 2664 2665
		tcp_try_undo_recovery(sk);
		return;
	}
Y
Yuchung Cheng 已提交
2666 2667 2668 2669 2670 2671 2672 2673 2674
	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);
	}
2675
	*rexmit = REXMIT_LOST;
2676 2677
}

Y
Yuchung Cheng 已提交
2678
/* Undo during fast recovery after partial ACK. */
2679
static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una)
Y
Yuchung Cheng 已提交
2680 2681 2682
{
	struct tcp_sock *tp = tcp_sk(sk);

2683
	if (tp->undo_marker && tcp_packet_delayed(tp)) {
Y
Yuchung Cheng 已提交
2684
		/* Plain luck! Hole if filled with delayed
2685
		 * packet, rather than with a retransmit. Check reordering.
Y
Yuchung Cheng 已提交
2686
		 */
2687
		tcp_check_sack_reordering(sk, prior_snd_una, 1);
2688 2689 2690 2691 2692 2693

		/* 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.
		 */
2694
		if (tp->retrans_out)
2695 2696
			return true;

Y
Yuchung Cheng 已提交
2697 2698 2699
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;

2700 2701
		DBGUNDO(sk, "partial recovery");
		tcp_undo_cwnd_reduction(sk, true);
2702
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
2703 2704
		tcp_try_keep_open(sk);
		return true;
Y
Yuchung Cheng 已提交
2705
	}
2706
	return false;
Y
Yuchung Cheng 已提交
2707 2708
}

2709
static void tcp_rack_identify_loss(struct sock *sk, int *ack_flag)
2710 2711 2712 2713
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Use RACK to detect loss */
2714
	if (sock_net(sk)->ipv4.sysctl_tcp_recovery & TCP_RACK_LOSS_DETECTION) {
2715 2716
		u32 prior_retrans = tp->retrans_out;

2717
		tcp_rack_mark_lost(sk);
2718 2719 2720 2721 2722
		if (prior_retrans > tp->retrans_out)
			*ack_flag |= FLAG_LOST_RETRANS;
	}
}

2723 2724 2725 2726 2727 2728 2729 2730
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 已提交
2731 2732 2733 2734 2735
/* 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.
 *
2736 2737 2738
 * 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 已提交
2739 2740 2741 2742
 *
 * It does _not_ decide what to send, it is made in function
 * tcp_xmit_retransmit_queue().
 */
2743
static void tcp_fastretrans_alert(struct sock *sk, const u32 prior_snd_una,
2744
				  bool is_dupack, int *ack_flag, int *rexmit)
L
Linus Torvalds 已提交
2745
{
2746
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2747
	struct tcp_sock *tp = tcp_sk(sk);
2748
	int fast_rexmit = 0, flag = *ack_flag;
Y
Yuchung Cheng 已提交
2749
	bool do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
2750
				     tcp_force_fast_retransmit(sk));
L
Linus Torvalds 已提交
2751

2752
	if (!tp->packets_out && tp->sacked_out)
L
Linus Torvalds 已提交
2753 2754
		tp->sacked_out = 0;

2755
	/* Now state machine starts.
L
Linus Torvalds 已提交
2756
	 * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
2757
	if (flag & FLAG_ECE)
L
Linus Torvalds 已提交
2758 2759 2760
		tp->prior_ssthresh = 0;

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

2764
	/* C. Check consistency of the current state. */
2765
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2766

2767
	/* D. Check state exit conditions. State can be terminated
L
Linus Torvalds 已提交
2768
	 *    when high_seq is ACKed. */
2769
	if (icsk->icsk_ca_state == TCP_CA_Open) {
2770
		WARN_ON(tp->retrans_out != 0);
L
Linus Torvalds 已提交
2771 2772
		tp->retrans_stamp = 0;
	} else if (!before(tp->snd_una, tp->high_seq)) {
2773
		switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2774 2775 2776 2777
		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) {
2778
				tcp_end_cwnd_reduction(sk);
2779
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2780 2781 2782 2783
			}
			break;

		case TCP_CA_Recovery:
2784
			if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
2785
				tcp_reset_reno_sack(tp);
2786
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
2787
				return;
2788
			tcp_end_cwnd_reduction(sk);
L
Linus Torvalds 已提交
2789 2790 2791 2792
			break;
		}
	}

2793
	/* E. Process state. */
2794
	switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
2795
	case TCP_CA_Recovery:
2796
		if (!(flag & FLAG_SND_UNA_ADVANCED)) {
2797
			if (tcp_is_reno(tp) && is_dupack)
2798
				tcp_add_reno_sack(sk);
2799
		} else {
2800
			if (tcp_try_undo_partial(sk, prior_snd_una))
2801 2802 2803
				return;
			/* Partial ACK arrived. Force fast retransmit. */
			do_lost = tcp_is_reno(tp) ||
2804
				  tcp_force_fast_retransmit(sk);
2805
		}
2806 2807 2808 2809
		if (tcp_try_undo_dsack(sk)) {
			tcp_try_keep_open(sk);
			return;
		}
2810
		tcp_rack_identify_loss(sk, ack_flag);
L
Linus Torvalds 已提交
2811 2812
		break;
	case TCP_CA_Loss:
2813
		tcp_process_loss(sk, flag, is_dupack, rexmit);
2814
		tcp_rack_identify_loss(sk, ack_flag);
2815 2816
		if (!(icsk->icsk_ca_state == TCP_CA_Open ||
		      (*ack_flag & FLAG_LOST_RETRANS)))
L
Linus Torvalds 已提交
2817
			return;
2818
		/* Change state if cwnd is undone or retransmits are lost */
2819
		/* fall through */
L
Linus Torvalds 已提交
2820
	default:
2821
		if (tcp_is_reno(tp)) {
2822
			if (flag & FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
2823 2824
				tcp_reset_reno_sack(tp);
			if (is_dupack)
2825
				tcp_add_reno_sack(sk);
L
Linus Torvalds 已提交
2826 2827
		}

2828
		if (icsk->icsk_ca_state <= TCP_CA_Disorder)
2829
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2830

2831
		tcp_rack_identify_loss(sk, ack_flag);
2832
		if (!tcp_time_to_recover(sk, flag)) {
2833
			tcp_try_to_open(sk, flag);
L
Linus Torvalds 已提交
2834 2835 2836
			return;
		}

J
John Heffner 已提交
2837 2838 2839
		/* MTU probe failure: don't reduce cwnd */
		if (icsk->icsk_ca_state < TCP_CA_CWR &&
		    icsk->icsk_mtup.probe_size &&
2840
		    tp->snd_una == tp->mtu_probe.probe_seq_start) {
J
John Heffner 已提交
2841 2842 2843 2844 2845 2846 2847
			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 已提交
2848
		/* Otherwise enter Recovery state */
2849
		tcp_enter_recovery(sk, (flag & FLAG_ECE));
2850
		fast_rexmit = 1;
L
Linus Torvalds 已提交
2851 2852
	}

2853
	if (do_lost)
2854
		tcp_update_scoreboard(sk, fast_rexmit);
2855
	*rexmit = REXMIT_LOST;
L
Linus Torvalds 已提交
2856 2857
}

2858
static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us, const int flag)
2859
{
2860
	u32 wlen = sock_net(sk)->ipv4.sysctl_tcp_min_rtt_wlen * HZ;
2861 2862
	struct tcp_sock *tp = tcp_sk(sk);

2863 2864 2865 2866 2867 2868 2869
	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;
	}
2870
	minmax_running_min(&tp->rtt_min, wlen, tcp_jiffies32,
2871
			   rtt_us ? : jiffies_to_usecs(1));
2872 2873
}

2874 2875 2876
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)
2877
{
2878 2879 2880 2881 2882 2883 2884
	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).
	 */
2885 2886
	if (seq_rtt_us < 0)
		seq_rtt_us = sack_rtt_us;
Y
Yuchung Cheng 已提交
2887

L
Linus Torvalds 已提交
2888 2889 2890 2891 2892 2893
	/* 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.
	 */
2894
	if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2895 2896 2897 2898 2899 2900
	    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;
	}
2901
	rs->rtt_us = ca_rtt_us; /* RTT of last (S)ACKed packet (or -1) */
2902
	if (seq_rtt_us < 0)
Y
Yuchung Cheng 已提交
2903
		return false;
L
Linus Torvalds 已提交
2904

2905 2906 2907 2908
	/* 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.
	 */
2909
	tcp_update_rtt_min(sk, ca_rtt_us, flag);
2910
	tcp_rtt_estimator(sk, seq_rtt_us);
2911
	tcp_set_rto(sk);
L
Linus Torvalds 已提交
2912

2913 2914
	/* RFC6298: only reset backoff on valid RTT measurement. */
	inet_csk(sk)->icsk_backoff = 0;
Y
Yuchung Cheng 已提交
2915
	return true;
L
Linus Torvalds 已提交
2916 2917
}

2918
/* Compute time elapsed between (last) SYNACK and the ACK completing 3WHS. */
Y
Yuchung Cheng 已提交
2919
void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
2920
{
2921
	struct rate_sample rs;
Y
Yuchung Cheng 已提交
2922
	long rtt_us = -1L;
2923

2924 2925
	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 已提交
2926

2927
	tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us, &rs);
2928 2929
}

Y
Yuchung Cheng 已提交
2930

2931
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
L
Linus Torvalds 已提交
2932
{
2933
	const struct inet_connection_sock *icsk = inet_csk(sk);
2934 2935

	icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
2936
	tcp_sk(sk)->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
2937 2938 2939 2940 2941
}

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

2947 2948 2949 2950 2951 2952
	/* 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 已提交
2953
	if (!tp->packets_out) {
2954
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
2955
	} else {
2956 2957
		u32 rto = inet_csk(sk)->icsk_rto;
		/* Offset the time elapsed after installing regular RTO */
Y
Yuchung Cheng 已提交
2958
		if (icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
N
Nandita Dukkipati 已提交
2959
		    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
2960
			s64 delta_us = tcp_rto_delta_us(sk);
E
Eric Dumazet 已提交
2961
			/* delta_us may not be positive if the socket is locked
N
Nandita Dukkipati 已提交
2962
			 * when the retrans timer fires and is rescheduled.
2963
			 */
2964
			rto = usecs_to_jiffies(max_t(int, delta_us, 1));
2965 2966 2967
		}
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, rto,
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
2968
	}
2969 2970
}

2971 2972 2973
/* Try to schedule a loss probe; if that doesn't work, then schedule an RTO. */
static void tcp_set_xmit_timer(struct sock *sk)
{
2974
	if (!tcp_schedule_loss_probe(sk, true))
2975 2976 2977
		tcp_rearm_rto(sk);
}

2978
/* If we get here, the whole TSO packet has not been acked. */
2979
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
2980 2981
{
	struct tcp_sock *tp = tcp_sk(sk);
2982
	u32 packets_acked;
L
Linus Torvalds 已提交
2983

2984
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
2985 2986

	packets_acked = tcp_skb_pcount(skb);
2987
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
2988 2989 2990 2991 2992
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

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

2996
	return packets_acked;
L
Linus Torvalds 已提交
2997 2998
}

2999 3000 3001 3002 3003 3004
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 */
3005
	if (likely(!TCP_SKB_CB(skb)->txstamp_ack))
3006 3007 3008
		return;

	shinfo = skb_shinfo(skb);
3009
	if (!before(shinfo->tskey, prior_snd_una) &&
3010 3011 3012 3013 3014
	    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);
	}
3015 3016
}

3017 3018 3019 3020
/* 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.
 */
3021 3022
static int tcp_clean_rtx_queue(struct sock *sk, u32 prior_fack,
			       u32 prior_snd_una,
3023
			       struct tcp_sacktag_state *sack)
L
Linus Torvalds 已提交
3024
{
3025
	const struct inet_connection_sock *icsk = inet_csk(sk);
3026
	u64 first_ackt, last_ackt;
3027 3028
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_sacked = tp->sacked_out;
3029
	u32 reord = tp->snd_nxt; /* lowest acked un-retx un-sacked seq */
3030
	struct sk_buff *skb, *next;
3031
	bool fully_acked = true;
3032
	long sack_rtt_us = -1L;
3033
	long seq_rtt_us = -1L;
3034
	long ca_rtt_us = -1L;
3035
	u32 pkts_acked = 0;
3036
	u32 last_in_flight = 0;
3037
	bool rtt_update;
3038 3039
	int flag = 0;

3040
	first_ackt = 0;
L
Linus Torvalds 已提交
3041

3042
	for (skb = skb_rb_first(&sk->tcp_rtx_queue); skb; skb = next) {
3043
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3044
		const u32 start_seq = scb->seq;
3045
		u8 sacked = scb->sacked;
3046
		u32 acked_pcount;
L
Linus Torvalds 已提交
3047

3048
		tcp_ack_tstamp(sk, skb, prior_snd_una);
3049

3050
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
3051
		if (after(scb->end_seq, tp->snd_una)) {
3052 3053 3054 3055
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

3056 3057
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
3058
				break;
E
Eric Dumazet 已提交
3059
			fully_acked = false;
3060
		} else {
3061
			acked_pcount = tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
3062 3063
		}

3064
		if (unlikely(sacked & TCPCB_RETRANS)) {
3065
			if (sacked & TCPCB_SACKED_RETRANS)
3066
				tp->retrans_out -= acked_pcount;
3067
			flag |= FLAG_RETRANS_DATA_ACKED;
3068
		} else if (!(sacked & TCPCB_SACKED_ACKED)) {
3069
			last_ackt = skb->skb_mstamp;
3070 3071
			WARN_ON_ONCE(last_ackt == 0);
			if (!first_ackt)
3072 3073
				first_ackt = last_ackt;

3074
			last_in_flight = TCP_SKB_CB(skb)->tx.in_flight;
3075 3076
			if (before(start_seq, reord))
				reord = start_seq;
3077 3078
			if (!after(scb->end_seq, tp->high_seq))
				flag |= FLAG_ORIG_SACK_ACKED;
3079
		}
3080

Y
Yuchung Cheng 已提交
3081
		if (sacked & TCPCB_SACKED_ACKED) {
3082
			tp->sacked_out -= acked_pcount;
Y
Yuchung Cheng 已提交
3083 3084 3085
		} else if (tcp_is_sack(tp)) {
			tp->delivered += acked_pcount;
			if (!tcp_skb_spurious_retrans(tp, skb))
3086
				tcp_rack_advance(tp, sacked, scb->end_seq,
3087
						 skb->skb_mstamp);
Y
Yuchung Cheng 已提交
3088
		}
3089
		if (sacked & TCPCB_LOST)
3090
			tp->lost_out -= acked_pcount;
3091

3092 3093
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
3094
		tcp_rate_skb_delivered(sk, skb, sack->rate);
3095

3096 3097 3098 3099 3100 3101 3102
		/* 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.
		 */
3103
		if (likely(!(scb->tcp_flags & TCPHDR_SYN))) {
3104 3105 3106 3107 3108 3109
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

3110 3111 3112
		if (!fully_acked)
			break;

3113
		next = skb_rb_next(skb);
3114
		if (unlikely(skb == tp->retransmit_skb_hint))
3115
			tp->retransmit_skb_hint = NULL;
3116
		if (unlikely(skb == tp->lost_skb_hint))
3117
			tp->lost_skb_hint = NULL;
3118
		tcp_rtx_queue_unlink_and_free(skb, sk);
L
Linus Torvalds 已提交
3119 3120
	}

3121 3122 3123
	if (!skb)
		tcp_chrono_stop(sk, TCP_CHRONO_BUSY);

I
Ilpo Järvinen 已提交
3124 3125 3126
	if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
		tp->snd_up = tp->snd_una;

3127 3128 3129
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

3130 3131 3132
	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);
3133 3134 3135 3136 3137 3138 3139 3140 3141 3142 3143

		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;
		}
3144
	}
3145 3146 3147
	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);
3148
	}
3149
	rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
3150
					ca_rtt_us, sack->rate);
Y
Yuchung Cheng 已提交
3151

3152
	if (flag & FLAG_ACKED) {
3153
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
3154 3155 3156 3157 3158
		if (unlikely(icsk->icsk_mtup.probe_size &&
			     !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
			tcp_mtup_probe_success(sk);
		}

3159 3160 3161
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
		} else {
3162 3163
			int delta;

3164
			/* Non-retransmitted hole got filled? That's reordering */
3165 3166
			if (before(reord, prior_fack))
				tcp_check_sack_reordering(sk, reord, 0);
3167

Y
Yuchung Cheng 已提交
3168
			delta = prior_sacked - tp->sacked_out;
3169
			tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3170
		}
3171
	} else if (skb && rtt_update && sack_rtt_us >= 0 &&
3172
		   sack_rtt_us > tcp_stamp_us_delta(tp->tcp_mstamp, skb->skb_mstamp)) {
3173 3174 3175 3176
		/* 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.
		 */
3177
		flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
L
Linus Torvalds 已提交
3178 3179
	}

3180 3181
	if (icsk->icsk_ca_ops->pkts_acked) {
		struct ack_sample sample = { .pkts_acked = pkts_acked,
3182
					     .rtt_us = sack->rate->rtt_us,
3183
					     .in_flight = last_in_flight };
3184 3185 3186

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

L
Linus Torvalds 已提交
3188
#if FASTRETRANS_DEBUG > 0
3189 3190 3191
	WARN_ON((int)tp->sacked_out < 0);
	WARN_ON((int)tp->lost_out < 0);
	WARN_ON((int)tp->retrans_out < 0);
3192
	if (!tp->packets_out && tcp_is_sack(tp)) {
S
Stephen Hemminger 已提交
3193
		icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3194
		if (tp->lost_out) {
3195 3196
			pr_debug("Leak l=%u %d\n",
				 tp->lost_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3197 3198 3199
			tp->lost_out = 0;
		}
		if (tp->sacked_out) {
3200 3201
			pr_debug("Leak s=%u %d\n",
				 tp->sacked_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3202 3203 3204
			tp->sacked_out = 0;
		}
		if (tp->retrans_out) {
3205 3206
			pr_debug("Leak r=%u %d\n",
				 tp->retrans_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3207 3208 3209 3210
			tp->retrans_out = 0;
		}
	}
#endif
3211
	return flag;
L
Linus Torvalds 已提交
3212 3213 3214 3215
}

static void tcp_ack_probe(struct sock *sk)
{
3216
	struct inet_connection_sock *icsk = inet_csk(sk);
3217 3218
	struct sk_buff *head = tcp_send_head(sk);
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3219 3220

	/* Was it a usable window open? */
3221 3222 3223
	if (!head)
		return;
	if (!after(TCP_SKB_CB(head)->end_seq, tcp_wnd_end(tp))) {
3224 3225
		icsk->icsk_backoff = 0;
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
L
Linus Torvalds 已提交
3226 3227 3228 3229
		/* Socket must be waked up by subsequent tcp_data_snd_check().
		 * This function is not for random using!
		 */
	} else {
3230
		unsigned long when = tcp_probe0_when(sk, TCP_RTO_MAX);
3231

3232
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3233
					  when, TCP_RTO_MAX);
L
Linus Torvalds 已提交
3234 3235 3236
	}
}

3237
static inline bool tcp_ack_is_dubious(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3238
{
E
Eric Dumazet 已提交
3239 3240
	return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
		inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
L
Linus Torvalds 已提交
3241 3242
}

3243
/* Decide wheather to run the increase function of congestion control. */
3244
static inline bool tcp_may_raise_cwnd(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3245
{
3246 3247
	/* If reordering is high then always grow cwnd whenever data is
	 * delivered regardless of its ordering. Otherwise stay conservative
3248
	 * and only grow cwnd on in-order delivery (RFC5681). A stretched ACK w/
3249 3250 3251
	 * new SACK or ECE mark may first advance cwnd here and later reduce
	 * cwnd in tcp_fastretrans_alert() based on more states.
	 */
3252
	if (tcp_sk(sk)->reordering > sock_net(sk)->ipv4.sysctl_tcp_reordering)
3253 3254
		return flag & FLAG_FORWARD_PROGRESS;

3255
	return flag & FLAG_DATA_ACKED;
L
Linus Torvalds 已提交
3256 3257
}

Y
Yuchung Cheng 已提交
3258 3259 3260 3261 3262 3263
/* 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,
3264
			     int flag, const struct rate_sample *rs)
Y
Yuchung Cheng 已提交
3265
{
3266 3267 3268 3269 3270 3271 3272
	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 已提交
3273 3274 3275 3276 3277 3278 3279 3280 3281 3282
	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 已提交
3283 3284 3285
/* Check that window update is acceptable.
 * The function assumes that snd_una<=ack<=snd_next.
 */
3286
static inline bool tcp_may_update_window(const struct tcp_sock *tp,
3287 3288
					const u32 ack, const u32 ack_seq,
					const u32 nwin)
L
Linus Torvalds 已提交
3289
{
E
Eric Dumazet 已提交
3290
	return	after(ack, tp->snd_una) ||
L
Linus Torvalds 已提交
3291
		after(ack_seq, tp->snd_wl1) ||
E
Eric Dumazet 已提交
3292
		(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);
L
Linus Torvalds 已提交
3293 3294
}

3295 3296 3297 3298 3299
/* 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;

3300
	sock_owned_by_me((struct sock *)tp);
3301 3302 3303 3304
	tp->bytes_acked += delta;
	tp->snd_una = ack;
}

3305 3306 3307 3308 3309
/* 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;

3310
	sock_owned_by_me((struct sock *)tp);
3311 3312 3313 3314
	tp->bytes_received += delta;
	tp->rcv_nxt = seq;
}

L
Linus Torvalds 已提交
3315 3316 3317 3318 3319
/* 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.
 */
3320
static int tcp_ack_update_window(struct sock *sk, const struct sk_buff *skb, u32 ack,
3321
				 u32 ack_seq)
L
Linus Torvalds 已提交
3322
{
3323
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3324
	int flag = 0;
3325
	u32 nwin = ntohs(tcp_hdr(skb)->window);
L
Linus Torvalds 已提交
3326

3327
	if (likely(!tcp_hdr(skb)->syn))
L
Linus Torvalds 已提交
3328 3329 3330 3331
		nwin <<= tp->rx_opt.snd_wscale;

	if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {
		flag |= FLAG_WIN_UPDATE;
3332
		tcp_update_wl(tp, ack_seq);
L
Linus Torvalds 已提交
3333 3334 3335 3336

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

3337 3338 3339 3340 3341 3342
			/* Note, it is the only place, where
			 * fast path is recovered for sending TCP.
			 */
			tp->pred_flags = 0;
			tcp_fast_path_check(sk);

3343
			if (!tcp_write_queue_empty(sk))
3344 3345
				tcp_slow_start_after_idle_check(sk);

L
Linus Torvalds 已提交
3346 3347
			if (nwin > tp->max_window) {
				tp->max_window = nwin;
3348
				tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
3349 3350 3351 3352
			}
		}
	}

3353
	tcp_snd_una_update(tp, ack);
L
Linus Torvalds 已提交
3354 3355 3356 3357

	return flag;
}

3358 3359 3360 3361
static bool __tcp_oow_rate_limited(struct net *net, int mib_idx,
				   u32 *last_oow_ack_time)
{
	if (*last_oow_ack_time) {
3362
		s32 elapsed = (s32)(tcp_jiffies32 - *last_oow_ack_time);
3363

3364
		if (0 <= elapsed && elapsed < net->ipv4.sysctl_tcp_invalid_ratelimit) {
3365 3366 3367 3368 3369
			NET_INC_STATS(net, mib_idx);
			return true;	/* rate-limited: don't send yet! */
		}
	}

3370
	*last_oow_ack_time = tcp_jiffies32;
3371 3372 3373 3374

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

3375 3376 3377 3378 3379 3380 3381 3382 3383 3384 3385 3386 3387
/* 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)
3388
		return false;
3389

3390
	return __tcp_oow_rate_limited(net, mib_idx, last_oow_ack_time);
3391 3392
}

3393
/* RFC 5961 7 [ACK Throttling] */
3394
static void tcp_send_challenge_ack(struct sock *sk, const struct sk_buff *skb)
3395 3396 3397 3398
{
	/* unprotected vars, we dont care of overwrites */
	static u32 challenge_timestamp;
	static unsigned int challenge_count;
3399
	struct tcp_sock *tp = tcp_sk(sk);
3400
	struct net *net = sock_net(sk);
3401
	u32 count, now;
3402 3403

	/* First check our per-socket dupack rate limit. */
3404
	if (__tcp_oow_rate_limited(net,
3405 3406
				   LINUX_MIB_TCPACKSKIPPEDCHALLENGE,
				   &tp->last_oow_ack_time))
3407
		return;
3408

3409
	/* Then check host-wide RFC 5961 rate limit. */
3410
	now = jiffies / HZ;
3411
	if (now != challenge_timestamp) {
3412 3413
		u32 ack_limit = net->ipv4.sysctl_tcp_challenge_ack_limit;
		u32 half = (ack_limit + 1) >> 1;
3414

3415
		challenge_timestamp = now;
3416
		WRITE_ONCE(challenge_count, half + prandom_u32_max(ack_limit));
3417
	}
3418 3419 3420
	count = READ_ONCE(challenge_count);
	if (count > 0) {
		WRITE_ONCE(challenge_count, count - 1);
3421
		NET_INC_STATS(net, LINUX_MIB_TCPCHALLENGEACK);
3422 3423 3424 3425
		tcp_send_ack(sk);
	}
}

3426 3427 3428 3429 3430 3431 3432 3433 3434 3435 3436 3437 3438 3439 3440 3441 3442 3443 3444 3445 3446
static void tcp_store_ts_recent(struct tcp_sock *tp)
{
	tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
	tp->rx_opt.ts_recent_stamp = get_seconds();
}

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

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

N
Nandita Dukkipati 已提交
3447
/* This routine deals with acks during a TLP episode.
3448 3449
 * We mark the end of a TLP episode on receiving TLP dupack or when
 * ack is after tlp_high_seq.
N
Nandita Dukkipati 已提交
3450 3451 3452 3453 3454 3455
 * 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);

3456
	if (before(ack, tp->tlp_high_seq))
N
Nandita Dukkipati 已提交
3457 3458
		return;

3459 3460 3461 3462 3463 3464 3465 3466 3467 3468 3469
	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);
3470
		NET_INC_STATS(sock_net(sk),
3471
				LINUX_MIB_TCPLOSSPROBERECOVERY);
3472 3473 3474
	} 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 已提交
3475 3476 3477 3478
		tp->tlp_high_seq = 0;
	}
}

3479 3480 3481 3482 3483 3484 3485 3486
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);
}

3487 3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498 3499 3500 3501 3502 3503 3504 3505 3506 3507
/* Congestion control has updated the cwnd already. So if we're in
 * loss recovery then now we do any new sends (for FRTO) or
 * retransmits (for CA_Loss or CA_recovery) that make sense.
 */
static void tcp_xmit_recovery(struct sock *sk, int rexmit)
{
	struct tcp_sock *tp = tcp_sk(sk);

	if (rexmit == REXMIT_NONE)
		return;

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

L
Linus Torvalds 已提交
3508
/* This routine deals with incoming acks, but not outgoing ones. */
3509
static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
L
Linus Torvalds 已提交
3510
{
3511
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3512
	struct tcp_sock *tp = tcp_sk(sk);
3513
	struct tcp_sacktag_state sack_state;
3514
	struct rate_sample rs = { .prior_delivered = 0 };
L
Linus Torvalds 已提交
3515
	u32 prior_snd_una = tp->snd_una;
3516
	bool is_sack_reneg = tp->is_sack_reneg;
L
Linus Torvalds 已提交
3517 3518
	u32 ack_seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;
3519
	bool is_dupack = false;
3520
	int prior_packets = tp->packets_out;
3521 3522
	u32 delivered = tp->delivered;
	u32 lost = tp->lost;
3523
	int rexmit = REXMIT_NONE; /* Flag to (re)transmit to recover losses */
3524
	u32 prior_fack;
3525

3526
	sack_state.first_sackt = 0;
3527
	sack_state.rate = &rs;
L
Linus Torvalds 已提交
3528

3529 3530
	/* We very likely will need to access rtx queue. */
	prefetch(sk->tcp_rtx_queue.rb_node);
3531

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

3545 3546 3547 3548 3549 3550
	/* 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;

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

E
Eric Dumazet 已提交
3556
	prior_fack = tcp_is_sack(tp) ? tcp_highest_sack_seq(tp) : tp->snd_una;
3557
	rs.prior_in_flight = tcp_packets_in_flight(tp);
3558

3559 3560 3561 3562 3563 3564
	/* 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);

3565 3566 3567 3568 3569 3570 3571 3572 3573 3574 3575 3576 3577
	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 {
3578
		u32 ack_ev_flags = CA_ACK_SLOWPATH;
L
Linus Torvalds 已提交
3579

3580 3581 3582 3583
		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 已提交
3584

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

3587 3588 3589
		if (TCP_SKB_CB(skb)->sacked)
			flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
							&sack_state);
3590

3591 3592 3593 3594 3595 3596 3597
		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 已提交
3598

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

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

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

3614
	tcp_rack_update_reo_wnd(sk, &rs);
3615

3616 3617 3618 3619 3620 3621
	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);

3622
	if (tcp_ack_is_dubious(sk, flag)) {
3623
		is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
3624 3625
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
L
Linus Torvalds 已提交
3626
	}
N
Nandita Dukkipati 已提交
3627

3628 3629
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
		sk_dst_confirm(sk);
N
Nandita Dukkipati 已提交
3630

3631 3632
	delivered = tp->delivered - delivered;	/* freshly ACKed or SACKed */
	lost = tp->lost - lost;			/* freshly marked lost */
3633
	rs.is_ack_delayed = !!(flag & FLAG_ACK_MAYBE_DELAYED);
3634
	tcp_rate_gen(sk, delivered, lost, is_sack_reneg, sack_state.rate);
3635
	tcp_cong_control(sk, ack, delivered, flag, sack_state.rate);
3636
	tcp_xmit_recovery(sk, rexmit);
L
Linus Torvalds 已提交
3637 3638 3639
	return 1;

no_queue:
3640 3641
	/* If data was DSACKed, see if we can undo a cwnd reduction. */
	if (flag & FLAG_DSACKING_ACK)
3642 3643
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
L
Linus Torvalds 已提交
3644 3645 3646 3647
	/* If this ack opens up a zero window, clear backoff.  It was
	 * being used to time the probes, and is probably far higher than
	 * it needs to be for normal retransmission.
	 */
3648
	tcp_ack_probe(sk);
N
Nandita Dukkipati 已提交
3649 3650 3651

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

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

L
Linus Torvalds 已提交
3658
old_ack:
3659 3660 3661
	/* 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.
	 */
3662
	if (TCP_SKB_CB(skb)->sacked) {
Y
Yuchung Cheng 已提交
3663
		flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
3664
						&sack_state);
3665 3666
		tcp_fastretrans_alert(sk, prior_snd_una, is_dupack, &flag,
				      &rexmit);
3667
		tcp_xmit_recovery(sk, rexmit);
3668
	}
L
Linus Torvalds 已提交
3669

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

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

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

3691 3692 3693 3694 3695 3696 3697 3698 3699 3700 3701 3702 3703 3704 3705
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 已提交
3706 3707 3708 3709
/* 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.
 */
3710 3711
void tcp_parse_options(const struct net *net,
		       const struct sk_buff *skb,
C
Christoph Paasch 已提交
3712
		       struct tcp_options_received *opt_rx, int estab,
Y
Yuchung Cheng 已提交
3713
		       struct tcp_fastopen_cookie *foc)
L
Linus Torvalds 已提交
3714
{
3715 3716
	const unsigned char *ptr;
	const struct tcphdr *th = tcp_hdr(skb);
3717
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3718

3719
	ptr = (const unsigned char *)(th + 1);
L
Linus Torvalds 已提交
3720 3721
	opt_rx->saw_tstamp = 0;

S
Stephen Hemminger 已提交
3722
	while (length > 0) {
3723
		int opcode = *ptr++;
L
Linus Torvalds 已提交
3724 3725 3726
		int opsize;

		switch (opcode) {
3727 3728 3729 3730 3731 3732 3733 3734
		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 已提交
3735
				return;
3736 3737 3738 3739 3740
			if (opsize > length)
				return;	/* don't parse partial options */
			switch (opcode) {
			case TCPOPT_MSS:
				if (opsize == TCPOLEN_MSS && th->syn && !estab) {
3741
					u16 in_mss = get_unaligned_be16(ptr);
3742 3743 3744 3745 3746
					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 已提交
3747
					}
3748 3749 3750 3751
				}
				break;
			case TCPOPT_WINDOW:
				if (opsize == TCPOLEN_WINDOW && th->syn &&
3752
				    !estab && net->ipv4.sysctl_tcp_window_scaling) {
3753 3754
					__u8 snd_wscale = *(__u8 *)ptr;
					opt_rx->wscale_ok = 1;
3755 3756
					if (snd_wscale > TCP_MAX_WSCALE) {
						net_info_ratelimited("%s: Illegal window scaling value %d > %u received\n",
3757
								     __func__,
3758 3759 3760
								     snd_wscale,
								     TCP_MAX_WSCALE);
						snd_wscale = TCP_MAX_WSCALE;
L
Linus Torvalds 已提交
3761
					}
3762 3763 3764 3765 3766 3767
					opt_rx->snd_wscale = snd_wscale;
				}
				break;
			case TCPOPT_TIMESTAMP:
				if ((opsize == TCPOLEN_TIMESTAMP) &&
				    ((estab && opt_rx->tstamp_ok) ||
3768
				     (!estab && net->ipv4.sysctl_tcp_timestamps))) {
3769
					opt_rx->saw_tstamp = 1;
3770 3771
					opt_rx->rcv_tsval = get_unaligned_be32(ptr);
					opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
3772 3773 3774 3775
				}
				break;
			case TCPOPT_SACK_PERM:
				if (opsize == TCPOLEN_SACK_PERM && th->syn &&
E
Eric Dumazet 已提交
3776
				    !estab && net->ipv4.sysctl_tcp_sack) {
3777
					opt_rx->sack_ok = TCP_SACK_SEEN;
3778 3779 3780
					tcp_sack_reset(opt_rx);
				}
				break;
L
Linus Torvalds 已提交
3781

3782 3783 3784 3785 3786 3787 3788
			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;
3789
#ifdef CONFIG_TCP_MD5SIG
3790 3791 3792 3793 3794 3795
			case TCPOPT_MD5SIG:
				/*
				 * The MD5 Hash has already been
				 * checked (see tcp_v{4,6}_do_rcv()).
				 */
				break;
3796
#endif
3797 3798 3799 3800 3801 3802
			case TCPOPT_FASTOPEN:
				tcp_parse_fastopen_option(
					opsize - TCPOLEN_FASTOPEN_BASE,
					ptr, th->syn, foc, false);
				break;

Y
Yuchung Cheng 已提交
3803 3804
			case TCPOPT_EXP:
				/* Fast Open option shares code 254 using a
3805
				 * 16 bits magic number.
Y
Yuchung Cheng 已提交
3806
				 */
3807 3808 3809 3810 3811 3812
				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);
3813 3814 3815
				else
					smc_parse_options(th, opt_rx, ptr,
							  opsize);
Y
Yuchung Cheng 已提交
3816 3817 3818
				break;

			}
3819 3820
			ptr += opsize-2;
			length -= opsize;
3821
		}
L
Linus Torvalds 已提交
3822 3823
	}
}
E
Eric Dumazet 已提交
3824
EXPORT_SYMBOL(tcp_parse_options);
L
Linus Torvalds 已提交
3825

E
Eric Dumazet 已提交
3826
static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
3827
{
3828
	const __be32 *ptr = (const __be32 *)(th + 1);
3829 3830 3831 3832 3833 3834 3835

	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;
3836 3837 3838 3839
		if (*ptr)
			tp->rx_opt.rcv_tsecr = ntohl(*ptr) - tp->tsoffset;
		else
			tp->rx_opt.rcv_tsecr = 0;
E
Eric Dumazet 已提交
3840
		return true;
3841
	}
E
Eric Dumazet 已提交
3842
	return false;
3843 3844
}

L
Linus Torvalds 已提交
3845 3846 3847
/* Fast parse options. This hopes to only see timestamps.
 * If it is wrong it falls back on tcp_parse_options().
 */
3848 3849
static bool tcp_fast_parse_options(const struct net *net,
				   const struct sk_buff *skb,
C
Christoph Paasch 已提交
3850
				   const struct tcphdr *th, struct tcp_sock *tp)
L
Linus Torvalds 已提交
3851
{
3852 3853 3854 3855
	/* 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 已提交
3856
		tp->rx_opt.saw_tstamp = 0;
E
Eric Dumazet 已提交
3857
		return false;
L
Linus Torvalds 已提交
3858
	} else if (tp->rx_opt.tstamp_ok &&
3859
		   th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
3860
		if (tcp_parse_aligned_timestamp(tp, th))
E
Eric Dumazet 已提交
3861
			return true;
L
Linus Torvalds 已提交
3862
	}
3863

3864
	tcp_parse_options(net, skb, &tp->rx_opt, 1, NULL);
3865
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
3866 3867
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;

E
Eric Dumazet 已提交
3868
	return true;
L
Linus Torvalds 已提交
3869 3870
}

3871 3872 3873 3874
#ifdef CONFIG_TCP_MD5SIG
/*
 * Parse MD5 Signature option
 */
3875
const u8 *tcp_parse_md5sig_option(const struct tcphdr *th)
3876
{
3877 3878
	int length = (th->doff << 2) - sizeof(*th);
	const u8 *ptr = (const u8 *)(th + 1);
3879 3880 3881 3882 3883 3884 3885 3886 3887

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

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

W
Weilong Chen 已提交
3888
		switch (opcode) {
3889 3890 3891 3892 3893 3894 3895 3896 3897 3898
		case TCPOPT_EOL:
			return NULL;
		case TCPOPT_NOP:
			length--;
			continue;
		default:
			opsize = *ptr++;
			if (opsize < 2 || opsize > length)
				return NULL;
			if (opcode == TCPOPT_MD5SIG)
3899
				return opsize == TCPOLEN_MD5SIG ? ptr : NULL;
3900 3901 3902 3903 3904 3905
		}
		ptr += opsize - 2;
		length -= opsize;
	}
	return NULL;
}
E
Eric Dumazet 已提交
3906
EXPORT_SYMBOL(tcp_parse_md5sig_option);
3907 3908
#endif

L
Linus Torvalds 已提交
3909 3910 3911 3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931
/* 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) ]
 */

3932
static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
3933
{
3934 3935
	const struct tcp_sock *tp = tcp_sk(sk);
	const struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
3936 3937 3938 3939 3940 3941 3942 3943 3944 3945 3946 3947 3948
	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. */
3949
		(s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <= (inet_csk(sk)->icsk_rto * 1024) / HZ);
L
Linus Torvalds 已提交
3950 3951
}

3952
static inline bool tcp_paws_discard(const struct sock *sk,
3953
				   const struct sk_buff *skb)
L
Linus Torvalds 已提交
3954
{
3955
	const struct tcp_sock *tp = tcp_sk(sk);
I
Ilpo Järvinen 已提交
3956 3957 3958

	return !tcp_paws_check(&tp->rx_opt, TCP_PAWS_WINDOW) &&
	       !tcp_disordered_ack(sk, skb);
L
Linus Torvalds 已提交
3959 3960 3961 3962 3963 3964 3965 3966 3967 3968 3969 3970 3971 3972 3973
}

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

3974
static inline bool tcp_sequence(const struct tcp_sock *tp, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
3975 3976 3977 3978 3979 3980
{
	return	!before(end_seq, tp->rcv_wup) &&
		!after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

/* When we get a reset we do this. */
3981
void tcp_reset(struct sock *sk)
L
Linus Torvalds 已提交
3982
{
3983 3984
	trace_tcp_receive_reset(sk);

L
Linus Torvalds 已提交
3985 3986
	/* We want the right error as BSD sees it (and indeed as we do). */
	switch (sk->sk_state) {
3987 3988 3989 3990 3991 3992 3993 3994 3995 3996
	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 已提交
3997
	}
T
Tom Marshall 已提交
3998 3999
	/* This barrier is coupled with smp_rmb() in tcp_poll() */
	smp_wmb();
L
Linus Torvalds 已提交
4000

4001 4002
	tcp_done(sk);

L
Linus Torvalds 已提交
4003 4004 4005 4006 4007 4008 4009 4010 4011 4012 4013 4014 4015 4016 4017 4018 4019 4020
	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.
 */
4021
void tcp_fin(struct sock *sk)
L
Linus Torvalds 已提交
4022 4023 4024
{
	struct tcp_sock *tp = tcp_sk(sk);

4025
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4026 4027 4028 4029 4030

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

	switch (sk->sk_state) {
4031 4032 4033 4034
	case TCP_SYN_RECV:
	case TCP_ESTABLISHED:
		/* Move to CLOSE_WAIT */
		tcp_set_state(sk, TCP_CLOSE_WAIT);
4035
		inet_csk(sk)->icsk_ack.pingpong = 1;
4036
		break;
L
Linus Torvalds 已提交
4037

4038 4039 4040 4041 4042 4043 4044 4045 4046
	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 已提交
4047

4048 4049 4050 4051 4052 4053 4054 4055 4056 4057 4058 4059 4060 4061 4062 4063 4064
	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 已提交
4065
		pr_err("%s: Impossible, sk->sk_state=%d\n",
4066
		       __func__, sk->sk_state);
4067
		break;
4068
	}
L
Linus Torvalds 已提交
4069 4070 4071 4072

	/* It _is_ possible, that we have something out-of-order _after_ FIN.
	 * Probably, we should reset in this case. For now drop them.
	 */
4073
	skb_rbtree_purge(&tp->out_of_order_queue);
4074
	if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4075
		tcp_sack_reset(&tp->rx_opt);
4076
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4077 4078 4079 4080 4081 4082 4083

	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)
4084
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP);
L
Linus Torvalds 已提交
4085
		else
4086
			sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
L
Linus Torvalds 已提交
4087 4088 4089
	}
}

E
Eric Dumazet 已提交
4090
static inline bool tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
4091
				  u32 end_seq)
L
Linus Torvalds 已提交
4092 4093 4094 4095 4096 4097
{
	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 已提交
4098
		return true;
L
Linus Torvalds 已提交
4099
	}
E
Eric Dumazet 已提交
4100
	return false;
L
Linus Torvalds 已提交
4101 4102
}

4103
static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4104
{
4105 4106
	struct tcp_sock *tp = tcp_sk(sk);

E
Eric Dumazet 已提交
4107
	if (tcp_is_sack(tp) && sock_net(sk)->ipv4.sysctl_tcp_dsack) {
4108 4109
		int mib_idx;

L
Linus Torvalds 已提交
4110
		if (before(seq, tp->rcv_nxt))
4111
			mib_idx = LINUX_MIB_TCPDSACKOLDSENT;
L
Linus Torvalds 已提交
4112
		else
4113 4114
			mib_idx = LINUX_MIB_TCPDSACKOFOSENT;

4115
		NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
4116 4117 4118 4119 4120 4121 4122

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

4123
static void tcp_dsack_extend(struct sock *sk, u32 seq, u32 end_seq)
L
Linus Torvalds 已提交
4124
{
4125 4126
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
4127
	if (!tp->rx_opt.dsack)
4128
		tcp_dsack_set(sk, seq, end_seq);
L
Linus Torvalds 已提交
4129 4130 4131 4132
	else
		tcp_sack_extend(tp->duplicate_sack, seq, end_seq);
}

4133
static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
4134 4135 4136 4137 4138
{
	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)) {
4139
		NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4140
		tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4141

E
Eric Dumazet 已提交
4142
		if (tcp_is_sack(tp) && sock_net(sk)->ipv4.sysctl_tcp_dsack) {
L
Linus Torvalds 已提交
4143 4144 4145 4146
			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;
4147
			tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, end_seq);
L
Linus Torvalds 已提交
4148 4149 4150 4151 4152 4153 4154 4155 4156 4157 4158 4159 4160
		}
	}

	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];
4161
	struct tcp_sack_block *swalk = sp + 1;
L
Linus Torvalds 已提交
4162 4163 4164 4165

	/* See if the recent change to the first SACK eats into
	 * or hits the sequence space of other SACK blocks, if so coalesce.
	 */
4166
	for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;) {
L
Linus Torvalds 已提交
4167 4168 4169 4170 4171 4172 4173
		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--;
4174 4175
			for (i = this_sack; i < tp->rx_opt.num_sacks; i++)
				sp[i] = sp[i + 1];
L
Linus Torvalds 已提交
4176 4177 4178 4179 4180 4181 4182 4183 4184 4185 4186 4187 4188 4189 4190 4191
			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;

4192
	for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
L
Linus Torvalds 已提交
4193 4194
		if (tcp_sack_extend(sp, seq, end_seq)) {
			/* Rotate this_sack to the first one. */
4195
			for (; this_sack > 0; this_sack--, sp--)
4196
				swap(*sp, *(sp - 1));
L
Linus Torvalds 已提交
4197 4198 4199 4200 4201 4202 4203 4204 4205 4206 4207 4208
			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.
	 */
4209
	if (this_sack >= TCP_NUM_SACKS) {
L
Linus Torvalds 已提交
4210 4211 4212 4213
		this_sack--;
		tp->rx_opt.num_sacks--;
		sp--;
	}
S
Stephen Hemminger 已提交
4214
	for (; this_sack > 0; this_sack--, sp--)
4215
		*sp = *(sp - 1);
L
Linus Torvalds 已提交
4216 4217 4218 4219 4220 4221 4222 4223 4224 4225 4226 4227 4228 4229 4230 4231 4232

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. */
4233
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4234 4235 4236 4237
		tp->rx_opt.num_sacks = 0;
		return;
	}

4238
	for (this_sack = 0; this_sack < num_sacks;) {
L
Linus Torvalds 已提交
4239 4240 4241 4242 4243
		/* 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! */
4244
			WARN_ON(before(tp->rcv_nxt, sp->end_seq));
L
Linus Torvalds 已提交
4245 4246

			/* Zap this SACK, by moving forward any other SACKS. */
W
Weilong Chen 已提交
4247
			for (i = this_sack+1; i < num_sacks; i++)
L
Linus Torvalds 已提交
4248 4249 4250 4251 4252 4253 4254
				tp->selective_acks[i-1] = tp->selective_acks[i];
			num_sacks--;
			continue;
		}
		this_sack++;
		sp++;
	}
4255
	tp->rx_opt.num_sacks = num_sacks;
L
Linus Torvalds 已提交
4256 4257
}

4258 4259 4260
/**
 * tcp_try_coalesce - try to merge skb to prior one
 * @sk: socket
4261
 * @dest: destination queue
4262 4263 4264 4265 4266 4267 4268 4269 4270 4271 4272 4273 4274 4275 4276 4277 4278 4279 4280 4281 4282 4283 4284 4285 4286 4287 4288 4289
 * @to: prior buffer
 * @from: buffer to add in queue
 * @fragstolen: pointer to boolean
 *
 * Before queueing skb @from after @to, try to merge them
 * to reduce overall memory use and queue lengths, if cost is small.
 * Packets in ofo or receive queues can stay a long time.
 * Better try to coalesce them right now to avoid future collapses.
 * Returns true if caller should free @from instead of queueing it
 */
static bool tcp_try_coalesce(struct sock *sk,
			     struct sk_buff *to,
			     struct sk_buff *from,
			     bool *fragstolen)
{
	int delta;

	*fragstolen = false;

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

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

	atomic_add(delta, &sk->sk_rmem_alloc);
	sk_mem_charge(sk, delta);
4290
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
4291 4292 4293
	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;
4294 4295 4296

	if (TCP_SKB_CB(from)->has_rxtstamp) {
		TCP_SKB_CB(to)->has_rxtstamp = true;
E
Eric Dumazet 已提交
4297
		to->tstamp = from->tstamp;
4298 4299
	}

4300 4301 4302
	return true;
}

4303 4304 4305 4306 4307 4308
static void tcp_drop(struct sock *sk, struct sk_buff *skb)
{
	sk_drops_add(sk, skb);
	__kfree_skb(skb);
}

L
Linus Torvalds 已提交
4309 4310 4311 4312 4313 4314 4315
/* 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;
4316
	bool fin, fragstolen, eaten;
4317
	struct sk_buff *skb, *tail;
4318
	struct rb_node *p;
L
Linus Torvalds 已提交
4319

4320 4321
	p = rb_first(&tp->out_of_order_queue);
	while (p) {
4322
		skb = rb_to_skb(p);
L
Linus Torvalds 已提交
4323 4324 4325 4326 4327 4328 4329
		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;
4330
			tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);
L
Linus Torvalds 已提交
4331
		}
4332 4333
		p = rb_next(p);
		rb_erase(&skb->rbnode, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
4334

4335
		if (unlikely(!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))) {
4336
			SOCK_DEBUG(sk, "ofo packet was already received\n");
4337
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4338 4339 4340 4341 4342 4343
			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);

4344
		tail = skb_peek_tail(&sk->sk_receive_queue);
E
Eric Dumazet 已提交
4345
		eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
4346
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
4347
		fin = TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN;
4348 4349
		if (!eaten)
			__skb_queue_tail(&sk->sk_receive_queue, skb);
4350
		else
4351
			kfree_skb_partial(skb, fragstolen);
4352 4353 4354 4355 4356 4357 4358 4359

		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 已提交
4360 4361 4362
	}
}

E
Eric Dumazet 已提交
4363
static bool tcp_prune_ofo_queue(struct sock *sk);
L
Linus Torvalds 已提交
4364 4365
static int tcp_prune_queue(struct sock *sk);

4366 4367
static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb,
				 unsigned int size)
4368 4369
{
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
4370
	    !sk_rmem_schedule(sk, skb, size)) {
4371 4372 4373 4374

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

4375
		while (!sk_rmem_schedule(sk, skb, size)) {
4376 4377
			if (!tcp_prune_ofo_queue(sk))
				return -1;
4378 4379 4380 4381 4382
		}
	}
	return 0;
}

E
Eric Dumazet 已提交
4383 4384 4385
static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
4386
	struct rb_node **p, *parent;
E
Eric Dumazet 已提交
4387 4388
	struct sk_buff *skb1;
	u32 seq, end_seq;
4389
	bool fragstolen;
E
Eric Dumazet 已提交
4390

4391
	tcp_ecn_check_ce(tp, skb);
E
Eric Dumazet 已提交
4392

4393
	if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
4394
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
4395
		tcp_drop(sk, skb);
E
Eric Dumazet 已提交
4396 4397 4398
		return;
	}

4399 4400
	/* Disable header prediction. */
	tp->pred_flags = 0;
E
Eric Dumazet 已提交
4401 4402
	inet_csk_schedule_ack(sk);

4403
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
4404 4405
	seq = TCP_SKB_CB(skb)->seq;
	end_seq = TCP_SKB_CB(skb)->end_seq;
E
Eric Dumazet 已提交
4406
	SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
4407
		   tp->rcv_nxt, seq, end_seq);
E
Eric Dumazet 已提交
4408

4409 4410
	p = &tp->out_of_order_queue.rb_node;
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
E
Eric Dumazet 已提交
4411 4412 4413
		/* Initial out of order segment, build 1 SACK. */
		if (tcp_is_sack(tp)) {
			tp->rx_opt.num_sacks = 1;
4414 4415
			tp->selective_acks[0].start_seq = seq;
			tp->selective_acks[0].end_seq = end_seq;
E
Eric Dumazet 已提交
4416
		}
4417 4418 4419
		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 已提交
4420 4421 4422
		goto end;
	}

4423 4424 4425
	/* In the typical case, we are adding an skb to the end of the list.
	 * Use of ooo_last_skb avoids the O(Log(N)) rbtree lookup.
	 */
E
Eric Dumazet 已提交
4426
	if (tcp_try_coalesce(sk, tp->ooo_last_skb,
4427
			     skb, &fragstolen)) {
4428 4429 4430 4431 4432 4433
coalesce_done:
		tcp_grow_window(sk, skb);
		kfree_skb_partial(skb, fragstolen);
		skb = NULL;
		goto add_sack;
	}
4434 4435 4436 4437 4438 4439
	/* 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;
	}
4440 4441 4442 4443 4444

	/* Find place to insert this segment. Handle overlaps on the way. */
	parent = NULL;
	while (*p) {
		parent = *p;
4445
		skb1 = rb_to_skb(parent);
4446 4447 4448
		if (before(seq, TCP_SKB_CB(skb1)->seq)) {
			p = &parent->rb_left;
			continue;
E
Eric Dumazet 已提交
4449
		}
4450 4451 4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474
		if (before(seq, TCP_SKB_CB(skb1)->end_seq)) {
			if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
				/* All the bits are present. Drop. */
				NET_INC_STATS(sock_net(sk),
					      LINUX_MIB_TCPOFOMERGE);
				__kfree_skb(skb);
				skb = NULL;
				tcp_dsack_set(sk, seq, end_seq);
				goto add_sack;
			}
			if (after(seq, TCP_SKB_CB(skb1)->seq)) {
				/* Partial overlap. */
				tcp_dsack_set(sk, seq, TCP_SKB_CB(skb1)->end_seq);
			} else {
				/* skb's seq == skb1's seq and skb covers skb1.
				 * Replace skb1 with skb.
				 */
				rb_replace_node(&skb1->rbnode, &skb->rbnode,
						&tp->out_of_order_queue);
				tcp_dsack_extend(sk,
						 TCP_SKB_CB(skb1)->seq,
						 TCP_SKB_CB(skb1)->end_seq);
				NET_INC_STATS(sock_net(sk),
					      LINUX_MIB_TCPOFOMERGE);
				__kfree_skb(skb1);
4475
				goto merge_right;
4476
			}
E
Eric Dumazet 已提交
4477
		} else if (tcp_try_coalesce(sk, skb1,
4478
					    skb, &fragstolen)) {
4479
			goto coalesce_done;
E
Eric Dumazet 已提交
4480
		}
4481
		p = &parent->rb_right;
E
Eric Dumazet 已提交
4482
	}
4483
insert:
4484 4485 4486
	/* 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 已提交
4487

4488
merge_right:
4489
	/* Remove other segments covered by skb. */
4490
	while ((skb1 = skb_rb_next(skb)) != NULL) {
E
Eric Dumazet 已提交
4491 4492 4493 4494 4495 4496 4497
		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;
		}
4498
		rb_erase(&skb1->rbnode, &tp->out_of_order_queue);
E
Eric Dumazet 已提交
4499 4500
		tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
				 TCP_SKB_CB(skb1)->end_seq);
4501
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
4502
		tcp_drop(sk, skb1);
E
Eric Dumazet 已提交
4503
	}
4504
	/* If there is no skb after us, we are the last_skb ! */
4505
	if (!skb1)
4506
		tp->ooo_last_skb = skb;
E
Eric Dumazet 已提交
4507 4508 4509 4510 4511

add_sack:
	if (tcp_is_sack(tp))
		tcp_sack_new_ofo_skb(sk, seq, end_seq);
end:
4512 4513
	if (skb) {
		tcp_grow_window(sk, skb);
4514
		skb_condense(skb);
E
Eric Dumazet 已提交
4515
		skb_set_owner_r(skb, sk);
4516
	}
E
Eric Dumazet 已提交
4517 4518
}

4519
static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb, int hdrlen,
4520 4521 4522 4523 4524 4525 4526
		  bool *fragstolen)
{
	int eaten;
	struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue);

	__skb_pull(skb, hdrlen);
	eaten = (tail &&
E
Eric Dumazet 已提交
4527
		 tcp_try_coalesce(sk, tail,
4528
				  skb, fragstolen)) ? 1 : 0;
4529
	tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
4530 4531 4532 4533 4534 4535
	if (!eaten) {
		__skb_queue_tail(&sk->sk_receive_queue, skb);
		skb_set_owner_r(skb, sk);
	}
	return eaten;
}
E
Eric Dumazet 已提交
4536

4537 4538
int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size)
{
4539
	struct sk_buff *skb;
4540 4541
	int err = -ENOMEM;
	int data_len = 0;
4542 4543
	bool fragstolen;

4544 4545 4546
	if (size == 0)
		return 0;

4547 4548 4549 4550 4551 4552 4553 4554 4555
	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);
4556 4557 4558
	if (!skb)
		goto err;

4559 4560 4561 4562
	skb_put(skb, size - data_len);
	skb->data_len = data_len;
	skb->len = size;

4563
	if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
4564 4565
		goto err_free;

4566 4567
	err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
	if (err)
4568 4569 4570 4571 4572 4573
		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;

4574
	if (tcp_queue_rcv(sk, skb, 0, &fragstolen)) {
4575 4576 4577 4578 4579 4580 4581 4582
		WARN_ON_ONCE(fragstolen); /* should not happen */
		__kfree_skb(skb);
	}
	return size;

err_free:
	kfree_skb(skb);
err:
4583 4584
	return err;

4585 4586
}

L
Linus Torvalds 已提交
4587 4588 4589
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
E
Eric Dumazet 已提交
4590 4591
	bool fragstolen;
	int eaten;
L
Linus Torvalds 已提交
4592

4593 4594 4595 4596
	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
		__kfree_skb(skb);
		return;
	}
E
Eric Dumazet 已提交
4597
	skb_dst_drop(skb);
4598
	__skb_pull(skb, tcp_hdr(skb)->doff * 4);
L
Linus Torvalds 已提交
4599

4600
	tcp_ecn_accept_cwr(tp, skb);
L
Linus Torvalds 已提交
4601

4602
	tp->rx_opt.dsack = 0;
L
Linus Torvalds 已提交
4603 4604 4605 4606 4607 4608 4609 4610 4611 4612 4613

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

		/* Ok. In sequence. In window. */
queue_and_out:
E
Eric Dumazet 已提交
4614 4615 4616 4617 4618
		if (skb_queue_len(&sk->sk_receive_queue) == 0)
			sk_forced_mem_schedule(sk, skb->truesize);
		else if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
			goto drop;

4619
		eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);
4620
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
S
Stephen Hemminger 已提交
4621
		if (skb->len)
4622
			tcp_event_data_recv(sk, skb);
4623
		if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
4624
			tcp_fin(sk);
L
Linus Torvalds 已提交
4625

4626
		if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4627 4628 4629 4630 4631
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
4632
			if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4633
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
4634 4635 4636 4637 4638
		}

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

4639 4640
		tcp_fast_path_check(sk);

4641 4642
		if (eaten > 0)
			kfree_skb_partial(skb, fragstolen);
4643
		if (!sock_flag(sk, SOCK_DEAD))
4644
			sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
4645 4646 4647 4648 4649
		return;
	}

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

out_of_window:
4654 4655
		tcp_enter_quickack_mode(sk);
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4656
drop:
4657
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4658 4659 4660 4661 4662 4663 4664
		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;

4665
	tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4666 4667 4668 4669 4670 4671 4672

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

4673
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
4674

L
Linus Torvalds 已提交
4675 4676 4677 4678 4679 4680 4681 4682
		/* If window is closed, drop tail of packet. But after
		 * remembering D-SACK for its head made in previous line.
		 */
		if (!tcp_receive_window(tp))
			goto out_of_window;
		goto queue_and_out;
	}

E
Eric Dumazet 已提交
4683
	tcp_data_queue_ofo(sk, skb);
L
Linus Torvalds 已提交
4684 4685
}

4686 4687 4688 4689 4690
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;

4691
	return skb_rb_next(skb);
4692 4693
}

4694
static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
4695 4696
					struct sk_buff_head *list,
					struct rb_root *root)
4697
{
4698
	struct sk_buff *next = tcp_skb_next(skb, list);
4699

4700 4701 4702 4703
	if (list)
		__skb_unlink(skb, list);
	else
		rb_erase(&skb->rbnode, root);
4704 4705

	__kfree_skb(skb);
4706
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
4707 4708 4709 4710

	return next;
}

4711
/* Insert skb into rb tree, ordered by TCP_SKB_CB(skb)->seq */
4712
void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb)
4713 4714 4715 4716 4717 4718 4719
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct sk_buff *skb1;

	while (*p) {
		parent = *p;
4720
		skb1 = rb_to_skb(parent);
4721 4722 4723 4724 4725 4726 4727 4728 4729
		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 已提交
4730 4731
/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
4732
 *
4733
 * If tail is NULL, this means until the end of the queue.
4734
 *
L
Linus Torvalds 已提交
4735 4736 4737 4738
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
4739 4740
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 已提交
4741
{
4742 4743
	struct sk_buff *skb = head, *n;
	struct sk_buff_head tmp;
4744
	bool end_of_skbs;
L
Linus Torvalds 已提交
4745

S
Stephen Hemminger 已提交
4746
	/* First, check that queue is collapsible and find
4747 4748
	 * the point where collapsing can be useful.
	 */
4749
restart:
4750 4751 4752
	for (end_of_skbs = true; skb != NULL && skb != tail; skb = n) {
		n = tcp_skb_next(skb, list);

L
Linus Torvalds 已提交
4753 4754
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
4755
			skb = tcp_collapse_one(sk, skb, list, root);
4756 4757 4758
			if (!skb)
				break;
			goto restart;
L
Linus Torvalds 已提交
4759 4760 4761 4762 4763 4764 4765
		}

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

4773 4774 4775 4776
		if (n && n != tail &&
		    TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(n)->seq) {
			end_of_skbs = false;
			break;
4777
		}
L
Linus Torvalds 已提交
4778 4779 4780 4781

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

4786 4787
	__skb_queue_head_init(&tmp);

L
Linus Torvalds 已提交
4788
	while (before(start, end)) {
4789
		int copy = min_t(int, SKB_MAX_ORDER(0, 0), end - start);
L
Linus Torvalds 已提交
4790 4791
		struct sk_buff *nskb;

4792
		nskb = alloc_skb(copy, GFP_ATOMIC);
L
Linus Torvalds 已提交
4793
		if (!nskb)
4794
			break;
4795

L
Linus Torvalds 已提交
4796 4797
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
4798 4799 4800 4801
		if (list)
			__skb_queue_before(list, skb, nskb);
		else
			__skb_queue_tail(&tmp, nskb); /* defer rbtree insertion */
4802
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4803 4804 4805 4806 4807 4808

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

4809
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4810 4811 4812 4813 4814 4815 4816 4817 4818
			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)) {
4819
				skb = tcp_collapse_one(sk, skb, list, root);
4820 4821
				if (!skb ||
				    skb == tail ||
4822
				    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
4823
					goto end;
L
Linus Torvalds 已提交
4824 4825 4826
			}
		}
	}
4827 4828 4829
end:
	skb_queue_walk_safe(&tmp, skb, n)
		tcp_rbtree_insert(root, skb);
L
Linus Torvalds 已提交
4830 4831 4832 4833 4834 4835 4836 4837
}

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

4841
	skb = skb_rb_first(&tp->out_of_order_queue);
4842 4843
new_range:
	if (!skb) {
4844
		tp->ooo_last_skb = skb_rb_last(&tp->out_of_order_queue);
L
Linus Torvalds 已提交
4845
		return;
4846
	}
L
Linus Torvalds 已提交
4847 4848
	start = TCP_SKB_CB(skb)->seq;
	end = TCP_SKB_CB(skb)->end_seq;
4849

4850
	for (head = skb;;) {
4851
		skb = skb_rb_next(skb);
L
Linus Torvalds 已提交
4852

4853 4854 4855
		/* Range is terminated when we see a gap or when
		 * we are at the queue end.
		 */
4856
		if (!skb ||
L
Linus Torvalds 已提交
4857 4858
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
4859
			tcp_collapse(sk, NULL, &tp->out_of_order_queue,
D
David S. Miller 已提交
4860
				     head, skb, start, end);
4861 4862 4863 4864
			goto new_range;
		}

		if (unlikely(before(TCP_SKB_CB(skb)->seq, start)))
L
Linus Torvalds 已提交
4865
			start = TCP_SKB_CB(skb)->seq;
4866
		if (after(TCP_SKB_CB(skb)->end_seq, end))
L
Linus Torvalds 已提交
4867 4868 4869 4870
			end = TCP_SKB_CB(skb)->end_seq;
	}
}

4871
/*
4872 4873 4874 4875 4876 4877 4878 4879
 * Clean the out-of-order queue to make room.
 * We drop high sequences packets to :
 * 1) Let a chance for holes to be filled.
 * 2) not add too big latencies if thousands of packets sit there.
 *    (But if application shrinks SO_RCVBUF, we could still end up
 *     freeing whole queue here)
 *
 * Return true if queue has shrunk.
4880
 */
E
Eric Dumazet 已提交
4881
static bool tcp_prune_ofo_queue(struct sock *sk)
4882 4883
{
	struct tcp_sock *tp = tcp_sk(sk);
4884
	struct rb_node *node, *prev;
4885

4886
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4887
		return false;
4888

4889
	NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
4890 4891 4892 4893
	node = &tp->ooo_last_skb->rbnode;
	do {
		prev = rb_prev(node);
		rb_erase(node, &tp->out_of_order_queue);
4894
		tcp_drop(sk, rb_to_skb(node));
4895
		sk_mem_reclaim(sk);
4896 4897 4898
		if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
		    !tcp_under_memory_pressure(sk))
			break;
4899 4900
		node = prev;
	} while (node);
4901
	tp->ooo_last_skb = rb_to_skb(prev);
4902 4903 4904 4905 4906 4907 4908 4909 4910

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

L
Linus Torvalds 已提交
4913 4914 4915 4916 4917 4918 4919 4920 4921
/* 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)
{
4922
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
4923 4924 4925

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

4926
	NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
L
Linus Torvalds 已提交
4927 4928

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
4929
		tcp_clamp_window(sk);
4930
	else if (tcp_under_memory_pressure(sk))
L
Linus Torvalds 已提交
4931 4932 4933
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

	tcp_collapse_ofo_queue(sk);
4934
	if (!skb_queue_empty(&sk->sk_receive_queue))
4935
		tcp_collapse(sk, &sk->sk_receive_queue, NULL,
4936 4937 4938
			     skb_peek(&sk->sk_receive_queue),
			     NULL,
			     tp->copied_seq, tp->rcv_nxt);
4939
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4940 4941 4942 4943 4944 4945 4946

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

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

4947
	tcp_prune_ofo_queue(sk);
L
Linus Torvalds 已提交
4948 4949 4950 4951 4952 4953 4954 4955

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

	/* Massive buffer overcommit. */
4959
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
4960 4961 4962
	return -1;
}

E
Eric Dumazet 已提交
4963
static bool tcp_should_expand_sndbuf(const struct sock *sk)
4964
{
4965
	const struct tcp_sock *tp = tcp_sk(sk);
4966

4967 4968 4969 4970
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
E
Eric Dumazet 已提交
4971
		return false;
4972 4973

	/* If we are under global TCP memory pressure, do not expand.  */
4974
	if (tcp_under_memory_pressure(sk))
E
Eric Dumazet 已提交
4975
		return false;
4976 4977

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

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

E
Eric Dumazet 已提交
4985
	return true;
4986
}
L
Linus Torvalds 已提交
4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997

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

4998
	if (tcp_should_expand_sndbuf(sk)) {
E
Eric Dumazet 已提交
4999
		tcp_sndbuf_expand(sk);
5000
		tp->snd_cwnd_stamp = tcp_jiffies32;
L
Linus Torvalds 已提交
5001 5002 5003 5004 5005
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
5006
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
5007 5008 5009
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
5010
		/* pairs with tcp_poll() */
5011
		smp_mb();
L
Linus Torvalds 已提交
5012
		if (sk->sk_socket &&
5013
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
L
Linus Torvalds 已提交
5014
			tcp_new_space(sk);
5015 5016 5017
			if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
				tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
		}
L
Linus Torvalds 已提交
5018 5019 5020
	}
}

5021
static inline void tcp_data_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5022
{
5023
	tcp_push_pending_frames(sk);
L
Linus Torvalds 已提交
5024 5025 5026 5027 5028 5029 5030 5031 5032 5033 5034
	tcp_check_space(sk);
}

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

	    /* More than one full frame received... */
5035
	if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss &&
L
Linus Torvalds 已提交
5036 5037 5038
	     /* ... and right edge of window advances far enough.
	      * (tcp_recvmsg() will send ACK otherwise). Or...
	      */
5039
	     __tcp_select_window(sk) >= tp->rcv_wnd) ||
L
Linus Torvalds 已提交
5040
	    /* We ACK each frame or... */
5041
	    tcp_in_quickack_mode(sk) ||
L
Linus Torvalds 已提交
5042
	    /* We have out of order data. */
5043
	    (ofo_possible && !RB_EMPTY_ROOT(&tp->out_of_order_queue))) {
L
Linus Torvalds 已提交
5044 5045 5046 5047 5048 5049 5050 5051
		/* Then ack it now */
		tcp_send_ack(sk);
	} else {
		/* Else, send delayed ack. */
		tcp_send_delayed_ack(sk);
	}
}

S
Stephen Hemminger 已提交
5052
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5053
{
5054
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
5055 5056 5057 5058 5059 5060 5061 5062
		/* 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 已提交
5063
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
5064 5065 5066 5067 5068 5069
 *	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).
 */
5070

5071
static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
L
Linus Torvalds 已提交
5072 5073 5074 5075
{
	struct tcp_sock *tp = tcp_sk(sk);
	u32 ptr = ntohs(th->urg_ptr);

5076
	if (ptr && !sock_net(sk)->ipv4.sysctl_tcp_stdurg)
L
Linus Torvalds 已提交
5077 5078 5079 5080 5081 5082 5083 5084 5085 5086 5087 5088 5089 5090 5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101 5102 5103 5104 5105 5106 5107
		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 已提交
5108
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119
	 *
	 * 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 &&
5120
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
5121 5122 5123
		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 已提交
5124
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
5125 5126 5127 5128
			__kfree_skb(skb);
		}
	}

5129 5130
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
5131 5132 5133

	/* Disable header prediction. */
	tp->pred_flags = 0;
L
Linus Torvalds 已提交
5134 5135 5136
}

/* This is the 'fast' part of urgent handling. */
5137
static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
L
Linus Torvalds 已提交
5138 5139 5140 5141 5142
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
5143
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
5144 5145 5146 5147 5148 5149

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

5150
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
5151 5152 5153 5154 5155 5156
		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))
5157
				sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
5158 5159 5160 5161
		}
	}
}

5162 5163 5164 5165 5166 5167 5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178
/* 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));
}

5179 5180 5181
/* Does PAWS and seqno based validation of an incoming segment, flags will
 * play significant role here.
 */
E
Eric Dumazet 已提交
5182 5183
static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
				  const struct tcphdr *th, int syn_inerr)
5184 5185
{
	struct tcp_sock *tp = tcp_sk(sk);
5186
	bool rst_seq_match = false;
5187 5188

	/* RFC1323: H1. Apply PAWS check first. */
5189 5190
	if (tcp_fast_parse_options(sock_net(sk), skb, th, tp) &&
	    tp->rx_opt.saw_tstamp &&
5191 5192
	    tcp_paws_discard(sk, skb)) {
		if (!th->rst) {
5193
			NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
5194 5195 5196 5197
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDPAWS,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210
			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)".
		 */
5211 5212 5213
		if (!th->rst) {
			if (th->syn)
				goto syn_challenge;
5214 5215 5216 5217
			if (!tcp_oow_rate_limited(sock_net(sk), skb,
						  LINUX_MIB_TCPACKSKIPPEDSEQ,
						  &tp->last_oow_ack_time))
				tcp_send_dupack(sk, skb);
5218 5219
		} else if (tcp_reset_check(sk, skb)) {
			tcp_reset(sk);
5220
		}
5221 5222 5223 5224 5225
		goto discard;
	}

	/* Step 2: check RST bit */
	if (th->rst) {
5226 5227 5228 5229
		/* 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,
5230
		 * then
E
Eric Dumazet 已提交
5231 5232 5233 5234
		 *     RESET the connection
		 * else
		 *     Send a challenge ACK
		 */
5235 5236
		if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt ||
		    tcp_reset_check(sk, skb)) {
5237 5238 5239 5240 5241 5242 5243 5244 5245 5246 5247 5248 5249 5250 5251 5252 5253 5254
			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 已提交
5255
			tcp_reset(sk);
5256 5257 5258 5259 5260 5261 5262
		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)
5263
				tcp_fastopen_active_disable(sk);
5264
			tcp_send_challenge_ack(sk, skb);
5265
		}
5266 5267 5268 5269 5270
		goto discard;
	}

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

E
Eric Dumazet 已提交
5271
	/* step 4: Check for a SYN
5272
	 * RFC 5961 4.2 : Send a challenge ack
E
Eric Dumazet 已提交
5273 5274
	 */
	if (th->syn) {
5275
syn_challenge:
5276
		if (syn_inerr)
5277 5278
			TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
5279
		tcp_send_challenge_ack(sk, skb);
E
Eric Dumazet 已提交
5280
		goto discard;
5281 5282
	}

E
Eric Dumazet 已提交
5283
	return true;
5284 5285

discard:
5286
	tcp_drop(sk, skb);
E
Eric Dumazet 已提交
5287
	return false;
5288 5289
}

L
Linus Torvalds 已提交
5290
/*
5291
 *	TCP receive function for the ESTABLISHED state.
5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311
 *
 *	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 已提交
5312
 */
5313
void tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
5314
			 const struct tcphdr *th)
L
Linus Torvalds 已提交
5315
{
5316
	unsigned int len = skb->len;
L
Linus Torvalds 已提交
5317 5318
	struct tcp_sock *tp = tcp_sk(sk);

5319 5320 5321
	/* TCP congestion window tracking */
	trace_tcp_probe(sk, skb);

5322
	tcp_mstamp_refresh(tp);
5323
	if (unlikely(!sk->sk_rx_dst))
E
Eric Dumazet 已提交
5324
		inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
5325 5326 5327 5328 5329 5330 5331 5332 5333 5334 5335 5336 5337 5338
	/*
	 *	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 已提交
5339 5340 5341

	tp->rx_opt.saw_tstamp = 0;

5342 5343 5344 5345 5346 5347 5348 5349 5350 5351 5352 5353 5354 5355 5356 5357 5358 5359 5360 5361 5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375 5376 5377 5378 5379 5380 5381 5382 5383 5384 5385 5386 5387 5388 5389 5390 5391 5392 5393 5394 5395 5396 5397 5398 5399 5400 5401 5402 5403 5404 5405 5406 5407 5408 5409 5410 5411 5412 5413 5414 5415 5416 5417 5418 5419 5420 5421 5422 5423 5424 5425 5426 5427 5428 5429 5430 5431 5432 5433 5434 5435 5436 5437 5438 5439 5440 5441 5442 5443 5444 5445 5446 5447
	/*	pred_flags is 0xS?10 << 16 + snd_wnd
	 *	if header_prediction is to be made
	 *	'S' will always be tp->tcp_header_len >> 2
	 *	'?' will be 0 for the fast path, otherwise pred_flags is 0 to
	 *  turn it off	(when there are holes in the receive
	 *	 space for instance)
	 *	PSH flag is ignored.
	 */

	if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
	    TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
	    !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
		int tcp_header_len = tp->tcp_header_len;

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

		/* Check timestamp */
		if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) {
			/* No? Slow path! */
			if (!tcp_parse_aligned_timestamp(tp, th))
				goto slow_path;

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

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

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

				/* We know that such packets are checksummed
				 * on entry.
				 */
				tcp_ack(sk, skb, 0);
				__kfree_skb(skb);
				tcp_data_snd_check(sk);
				return;
			} else { /* Header too small */
				TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
				goto discard;
			}
		} else {
			int eaten = 0;
			bool fragstolen = false;

			if (tcp_checksum_complete(skb))
				goto csum_error;

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

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

			tcp_rcv_rtt_measure_ts(sk, skb);

			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPHITS);

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

			tcp_event_data_recv(sk, skb);

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

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

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

5451
	if (!th->ack && !th->rst && !th->syn)
5452 5453
		goto discard;

5454 5455 5456 5457
	/*
	 *	Standard slow path.
	 */

E
Eric Dumazet 已提交
5458
	if (!tcp_validate_incoming(sk, skb, th, 1))
5459
		return;
L
Linus Torvalds 已提交
5460

5461 5462
step5:
	if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
5463
		goto discard;
L
Linus Torvalds 已提交
5464

5465
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5466 5467 5468 5469 5470 5471 5472

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

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

5473
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5474
	tcp_ack_snd_check(sk);
5475
	return;
L
Linus Torvalds 已提交
5476 5477

csum_error:
5478 5479
	TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
	TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5480 5481

discard:
5482
	tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5483
}
E
Eric Dumazet 已提交
5484
EXPORT_SYMBOL(tcp_rcv_established);
L
Linus Torvalds 已提交
5485

P
Pavel Emelyanov 已提交
5486 5487 5488 5489 5490 5491
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);
5492
	icsk->icsk_ack.lrcvtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5493

5494
	if (skb) {
E
Eric Dumazet 已提交
5495
		icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
P
Pavel Emelyanov 已提交
5496
		security_inet_conn_established(sk, skb);
D
David S. Miller 已提交
5497
	}
P
Pavel Emelyanov 已提交
5498

5499
	tcp_init_transfer(sk, BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB);
P
Pavel Emelyanov 已提交
5500 5501 5502 5503

	/* Prevent spurious tcp_cwnd_restart() on first data
	 * packet.
	 */
5504
	tp->lsndtime = tcp_jiffies32;
P
Pavel Emelyanov 已提交
5505 5506 5507

	if (sock_flag(sk, SOCK_KEEPOPEN))
		inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
5508 5509 5510 5511 5512

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

5515 5516 5517 5518
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);
5519
	struct sk_buff *data = tp->syn_data ? tcp_rtx_queue_head(sk) : NULL;
5520 5521
	u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
	bool syn_drop = false;
5522 5523 5524 5525 5526 5527 5528

	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;
5529
		tcp_parse_options(sock_net(sk), synack, &opt, 0, NULL);
5530 5531 5532
		mss = opt.mss_clamp;
	}

5533 5534
	if (!tp->syn_fastopen) {
		/* Ignore an unsolicited cookie */
5535
		cookie->len = -1;
5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547 5548 5549
	} 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;
	}
5550

5551
	tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
5552 5553

	if (data) { /* Retransmit unacked data in SYN */
5554 5555
		skb_rbtree_walk_from(data) {
			if (__tcp_retransmit_skb(sk, data, 1))
5556 5557
				break;
		}
5558
		tcp_rearm_rto(sk);
5559
		NET_INC_STATS(sock_net(sk),
5560
				LINUX_MIB_TCPFASTOPENACTIVEFAIL);
5561 5562
		return true;
	}
Y
Yuchung Cheng 已提交
5563
	tp->syn_data_acked = tp->syn_data;
5564
	if (tp->syn_data_acked)
5565
		NET_INC_STATS(sock_net(sk),
5566
				LINUX_MIB_TCPFASTOPENACTIVE);
5567 5568 5569

	tcp_fastopen_add_skb(sk, synack);

5570 5571 5572
	return false;
}

5573 5574 5575 5576 5577 5578 5579 5580 5581 5582
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 已提交
5583
static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
5584
					 const struct tcphdr *th)
L
Linus Torvalds 已提交
5585
{
5586
	struct inet_connection_sock *icsk = inet_csk(sk);
5587
	struct tcp_sock *tp = tcp_sk(sk);
5588
	struct tcp_fastopen_cookie foc = { .len = -1 };
5589
	int saved_clamp = tp->rx_opt.mss_clamp;
5590
	bool fastopen_fail;
L
Linus Torvalds 已提交
5591

5592
	tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc);
5593
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
5594
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;
L
Linus Torvalds 已提交
5595 5596 5597 5598 5599 5600 5601 5602 5603 5604

	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)"
		 */
5605 5606
		if (!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
		    after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt))
L
Linus Torvalds 已提交
5607 5608 5609 5610
			goto reset_and_undo;

		if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
		    !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp,
5611
			     tcp_time_stamp(tp))) {
5612
			NET_INC_STATS(sock_net(sk),
5613
					LINUX_MIB_PAWSACTIVEREJECTED);
L
Linus Torvalds 已提交
5614 5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628 5629 5630 5631 5632 5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646
			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..."
		 */

5647
		tcp_ecn_rcv_synack(tp, th);
L
Linus Torvalds 已提交
5648

5649
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
5650
		tcp_ack(sk, skb, FLAG_SLOWPATH);
L
Linus Torvalds 已提交
5651 5652 5653 5654 5655 5656 5657 5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677

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

5678
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5679 5680 5681 5682 5683 5684
		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;
5685

5686 5687
		smc_check_reset_syn(tp);

R
Ralf Baechle 已提交
5688
		smp_mb();
L
Linus Torvalds 已提交
5689

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

5692 5693
		fastopen_fail = (tp->syn_fastopen || tp->syn_data) &&
				tcp_rcv_fastopen_synack(sk, skb, &foc);
5694

5695 5696 5697 5698 5699 5700
		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;
5701 5702 5703
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
5704 5705 5706 5707 5708 5709 5710
			/* 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
			 */
5711 5712
			inet_csk_schedule_ack(sk);
			tcp_enter_quickack_mode(sk);
5713 5714
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
5715 5716

discard:
5717
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5718 5719 5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737
			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. */
5738
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
I
Ilpo Järvinen 已提交
5739
	    tcp_paws_reject(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5740 5741 5742 5743 5744 5745 5746 5747 5748 5749 5750 5751 5752 5753 5754 5755 5756 5757 5758
		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;
5759
		tp->copied_seq = tp->rcv_nxt;
L
Linus Torvalds 已提交
5760 5761 5762 5763 5764 5765 5766 5767 5768
		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;

5769
		tcp_ecn_rcv_syn(tp, th);
L
Linus Torvalds 已提交
5770

J
John Heffner 已提交
5771
		tcp_mtup_init(sk);
5772
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5773 5774 5775 5776 5777
		tcp_initialize_rcv_mss(sk);

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
5778 5779 5780
		 * 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 已提交
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
		 *
		 * 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
5810
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5811 5812 5813
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5814

5815
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
5816 5817
{
	struct tcp_sock *tp = tcp_sk(sk);
5818
	struct inet_connection_sock *icsk = inet_csk(sk);
5819
	const struct tcphdr *th = tcp_hdr(skb);
5820
	struct request_sock *req;
L
Linus Torvalds 已提交
5821
	int queued = 0;
5822
	bool acceptable;
L
Linus Torvalds 已提交
5823 5824 5825 5826 5827 5828

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

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5829
		if (th->ack)
L
Linus Torvalds 已提交
5830 5831
			return 1;

S
Stephen Hemminger 已提交
5832
		if (th->rst)
L
Linus Torvalds 已提交
5833 5834
			goto discard;

S
Stephen Hemminger 已提交
5835
		if (th->syn) {
E
Eric Dumazet 已提交
5836 5837
			if (th->fin)
				goto discard;
5838 5839 5840 5841 5842 5843
			/* 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 已提交
5844

5845 5846
			if (!acceptable)
				return 1;
5847
			consume_skb(skb);
5848
			return 0;
L
Linus Torvalds 已提交
5849 5850 5851 5852
		}
		goto discard;

	case TCP_SYN_SENT:
5853
		tp->rx_opt.saw_tstamp = 0;
5854
		tcp_mstamp_refresh(tp);
5855
		queued = tcp_rcv_synsent_state_process(sk, skb, th);
L
Linus Torvalds 已提交
5856 5857 5858 5859 5860 5861
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
5862
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5863 5864 5865
		return 0;
	}

5866
	tcp_mstamp_refresh(tp);
5867
	tp->rx_opt.saw_tstamp = 0;
5868
	req = tp->fastopen_rsk;
5869
	if (req) {
5870
		WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
5871 5872
		    sk->sk_state != TCP_FIN_WAIT1);

5873
		if (!tcp_check_req(sk, skb, req, true))
5874
			goto discard;
5875
	}
5876

5877
	if (!th->ack && !th->rst && !th->syn)
5878 5879
		goto discard;

5880
	if (!tcp_validate_incoming(sk, skb, th, 0))
E
Eric Dumazet 已提交
5881
		return 0;
L
Linus Torvalds 已提交
5882 5883

	/* step 5: check the ACK field */
5884 5885
	acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
				      FLAG_UPDATE_TS_RECENT |
5886
				      FLAG_NO_CHALLENGE_ACK) > 0;
5887

5888 5889 5890 5891 5892 5893
	if (!acceptable) {
		if (sk->sk_state == TCP_SYN_RECV)
			return 1;	/* send one RST */
		tcp_send_challenge_ack(sk, skb);
		goto discard;
	}
5894 5895
	switch (sk->sk_state) {
	case TCP_SYN_RECV:
Y
Yuchung Cheng 已提交
5896 5897 5898
		if (!tp->srtt_us)
			tcp_synack_rtt_meas(sk, req);

5899 5900 5901 5902
		/* Once we leave TCP_SYN_RECV, we no longer need req
		 * so release it.
		 */
		if (req) {
5903
			inet_csk(sk)->icsk_retransmits = 0;
5904
			reqsk_fastopen_remove(sk, req, false);
5905 5906 5907 5908 5909 5910 5911 5912 5913
			/* 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);
5914
		} else {
5915
			tcp_init_transfer(sk, BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB);
5916 5917 5918 5919 5920
			tp->copied_seq = tp->rcv_nxt;
		}
		smp_mb();
		tcp_set_state(sk, TCP_ESTABLISHED);
		sk->sk_state_change(sk);
L
Linus Torvalds 已提交
5921

5922 5923 5924 5925 5926 5927 5928 5929 5930 5931 5932 5933 5934 5935
		/* 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;

5936 5937
		if (!inet_csk(sk)->icsk_ca_ops->cong_control)
			tcp_update_pacing_rate(sk);
5938

5939
		/* Prevent spurious tcp_cwnd_restart() on first data packet */
5940
		tp->lsndtime = tcp_jiffies32;
5941 5942

		tcp_initialize_rcv_mss(sk);
5943
		tcp_fast_path_on(tp);
5944 5945
		break;

5946 5947 5948
	case TCP_FIN_WAIT1: {
		int tmo;

5949 5950 5951 5952 5953
		/* 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.
		 */
5954
		if (req) {
5955 5956 5957 5958
			/* We no longer need the request sock. */
			reqsk_fastopen_remove(sk, req, false);
			tcp_rearm_rto(sk);
		}
5959 5960
		if (tp->snd_una != tp->write_seq)
			break;
5961

5962 5963
		tcp_set_state(sk, TCP_FIN_WAIT2);
		sk->sk_shutdown |= SEND_SHUTDOWN;
5964

5965
		sk_dst_confirm(sk);
5966

5967 5968 5969 5970 5971
		if (!sock_flag(sk, SOCK_DEAD)) {
			/* Wake up lingering close() */
			sk->sk_state_change(sk);
			break;
		}
L
Linus Torvalds 已提交
5972

5973 5974 5975 5976 5977 5978 5979 5980 5981
		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)
5982
				tcp_fastopen_active_disable(sk);
5983
			tcp_done(sk);
5984
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
5985 5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001
			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;
6002 6003
		}
		break;
6004
	}
L
Linus Torvalds 已提交
6005

6006 6007 6008 6009 6010 6011
	case TCP_CLOSING:
		if (tp->snd_una == tp->write_seq) {
			tcp_time_wait(sk, TCP_TIME_WAIT, 0);
			goto discard;
		}
		break;
L
Linus Torvalds 已提交
6012

6013 6014 6015 6016 6017
	case TCP_LAST_ACK:
		if (tp->snd_una == tp->write_seq) {
			tcp_update_metrics(sk);
			tcp_done(sk);
			goto discard;
L
Linus Torvalds 已提交
6018
		}
6019
		break;
6020
	}
L
Linus Torvalds 已提交
6021 6022 6023 6024 6025 6026 6027 6028 6029 6030 6031

	/* 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;
6032
		/* fall through */
L
Linus Torvalds 已提交
6033 6034 6035
	case TCP_FIN_WAIT1:
	case TCP_FIN_WAIT2:
		/* RFC 793 says to queue data in these states,
6036
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
6037 6038 6039 6040 6041
		 * 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)) {
6042
				NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
6043 6044 6045 6046 6047
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
6048
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
6049 6050 6051 6052 6053 6054 6055
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
6056
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
6057 6058 6059
		tcp_ack_snd_check(sk);
	}

6060
	if (!queued) {
L
Linus Torvalds 已提交
6061
discard:
6062
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
6063 6064 6065 6066
	}
	return 0;
}
EXPORT_SYMBOL(tcp_rcv_state_process);
O
Octavian Purdila 已提交
6067 6068 6069 6070 6071 6072

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)
6073 6074
		net_dbg_ratelimited("drop open request from %pI4/%u\n",
				    &ireq->ir_rmt_addr, port);
6075 6076
#if IS_ENABLED(CONFIG_IPV6)
	else if (family == AF_INET6)
6077 6078
		net_dbg_ratelimited("drop open request from %pI6/%u\n",
				    &ireq->ir_v6_rmt_addr, port);
6079
#endif
O
Octavian Purdila 已提交
6080 6081
}

6082 6083 6084 6085 6086
/* 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 已提交
6087
 * TCP ECN negotiation.
6088 6089
 *
 * Exception: tcp_ca wants ECN. This is required for DCTCP
6090 6091 6092
 * congestion control: Linux DCTCP asserts ECT on all packets,
 * including SYN, which is most optimal solution; however,
 * others, such as FreeBSD do not.
6093 6094 6095
 */
static void tcp_ecn_create_request(struct request_sock *req,
				   const struct sk_buff *skb,
6096 6097
				   const struct sock *listen_sk,
				   const struct dst_entry *dst)
6098 6099 6100 6101
{
	const struct tcphdr *th = tcp_hdr(skb);
	const struct net *net = sock_net(listen_sk);
	bool th_ecn = th->ece && th->cwr;
6102
	bool ect, ecn_ok;
6103
	u32 ecn_ok_dst;
6104 6105 6106 6107 6108

	if (!th_ecn)
		return;

	ect = !INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield);
6109 6110
	ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
	ecn_ok = net->ipv4.sysctl_tcp_ecn || ecn_ok_dst;
6111

6112
	if ((!ect && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
6113 6114
	    (ecn_ok_dst & DST_FEATURE_ECN_CA) ||
	    tcp_bpf_ca_needs_ecn((struct sock *)req))
6115 6116 6117
		inet_rsk(req)->ecn_ok = 1;
}

6118 6119 6120 6121 6122 6123
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);

6124
	req->rsk_rcv_wnd = 0;		/* So that tcp_send_synack() knows! */
6125 6126 6127
	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;
6128
	tcp_rsk(req)->snt_synack = tcp_clock_us();
6129 6130 6131 6132 6133 6134 6135 6136 6137 6138 6139 6140
	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);
6141 6142 6143
#if IS_ENABLED(CONFIG_SMC)
	ireq->smc_ok = rx_opt->smc_ok;
#endif
6144 6145
}

E
Eric Dumazet 已提交
6146
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
6147 6148
				      struct sock *sk_listener,
				      bool attach_listener)
E
Eric Dumazet 已提交
6149
{
6150 6151
	struct request_sock *req = reqsk_alloc(ops, sk_listener,
					       attach_listener);
E
Eric Dumazet 已提交
6152 6153 6154 6155

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

E
Eric Dumazet 已提交
6156
		ireq->ireq_opt = NULL;
6157 6158 6159
#if IS_ENABLED(CONFIG_IPV6)
		ireq->pktopts = NULL;
#endif
E
Eric Dumazet 已提交
6160 6161 6162
		atomic64_set(&ireq->ir_cookie, 0);
		ireq->ireq_state = TCP_NEW_SYN_RECV;
		write_pnet(&ireq->ireq_net, sock_net(sk_listener));
6163
		ireq->ireq_family = sk_listener->sk_family;
E
Eric Dumazet 已提交
6164 6165 6166 6167 6168 6169
	}

	return req;
}
EXPORT_SYMBOL(inet_reqsk_alloc);

6170 6171 6172
/*
 * Return true if a syncookie should be sent
 */
6173
static bool tcp_syn_flood_action(const struct sock *sk,
6174 6175 6176
				 const struct sk_buff *skb,
				 const char *proto)
{
6177
	struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
6178 6179
	const char *msg = "Dropping request";
	bool want_cookie = false;
6180
	struct net *net = sock_net(sk);
6181 6182

#ifdef CONFIG_SYN_COOKIES
6183
	if (net->ipv4.sysctl_tcp_syncookies) {
6184 6185
		msg = "Sending cookies";
		want_cookie = true;
6186
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
6187 6188
	} else
#endif
6189
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
6190

6191
	if (!queue->synflood_warned &&
6192
	    net->ipv4.sysctl_tcp_syncookies != 2 &&
6193
	    xchg(&queue->synflood_warned, 1) == 0)
6194 6195
		pr_info("%s: Possible SYN flooding on port %d. %s.  Check SNMP counters.\n",
			proto, ntohs(tcp_hdr(skb)->dest), msg);
6196

6197 6198 6199
	return want_cookie;
}

6200 6201 6202 6203 6204 6205 6206 6207 6208 6209 6210 6211 6212 6213 6214 6215 6216
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 已提交
6217 6218 6219 6220
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)
{
6221 6222
	struct tcp_fastopen_cookie foc = { .len = -1 };
	__u32 isn = TCP_SKB_CB(skb)->tcp_tw_isn;
O
Octavian Purdila 已提交
6223 6224
	struct tcp_options_received tmp_opt;
	struct tcp_sock *tp = tcp_sk(sk);
6225
	struct net *net = sock_net(sk);
6226 6227 6228
	struct sock *fastopen_sk = NULL;
	struct request_sock *req;
	bool want_cookie = false;
6229
	struct dst_entry *dst;
O
Octavian Purdila 已提交
6230 6231 6232 6233 6234 6235
	struct flowi fl;

	/* TW buckets are converted to open requests without
	 * limitations, they conserve resources and peer is
	 * evidently real one.
	 */
6236
	if ((net->ipv4.sysctl_tcp_syncookies == 2 ||
O
Octavian Purdila 已提交
6237 6238 6239 6240 6241 6242
	     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;
	}

6243
	if (sk_acceptq_is_full(sk)) {
6244
		NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
O
Octavian Purdila 已提交
6245 6246 6247
		goto drop;
	}

6248
	req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
O
Octavian Purdila 已提交
6249 6250 6251 6252
	if (!req)
		goto drop;

	tcp_rsk(req)->af_specific = af_ops;
6253
	tcp_rsk(req)->ts_off = 0;
O
Octavian Purdila 已提交
6254 6255 6256 6257

	tcp_clear_options(&tmp_opt);
	tmp_opt.mss_clamp = af_ops->mss_clamp;
	tmp_opt.user_mss  = tp->rx_opt.user_mss;
6258 6259
	tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0,
			  want_cookie ? NULL : &foc);
O
Octavian Purdila 已提交
6260 6261 6262 6263 6264 6265

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

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

6268
	/* Note: tcp_v6_init_req() might override ir_iif for link locals */
6269
	inet_rsk(req)->ir_iif = inet_request_bound_dev_if(sk, skb);
6270

O
Octavian Purdila 已提交
6271 6272 6273 6274 6275
	af_ops->init_req(req, sk, skb);

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

6276
	if (tmp_opt.tstamp_ok)
6277
		tcp_rsk(req)->ts_off = af_ops->init_ts_off(net, skb);
6278

6279 6280 6281 6282
	dst = af_ops->route_req(sk, &fl, req);
	if (!dst)
		goto drop_and_free;

6283
	if (!want_cookie && !isn) {
O
Octavian Purdila 已提交
6284
		/* Kill the following clause, if you dislike this way. */
6285 6286 6287 6288
		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 已提交
6289 6290 6291 6292 6293 6294 6295 6296 6297 6298 6299 6300
			/* 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;
		}

6301
		isn = af_ops->init_seq(skb);
O
Octavian Purdila 已提交
6302 6303
	}

6304 6305 6306 6307 6308 6309 6310 6311 6312
	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 已提交
6313
	tcp_rsk(req)->snt_isn = isn;
6314
	tcp_rsk(req)->txhash = net_tx_rndhash();
O
Octavian Purdila 已提交
6315
	tcp_openreq_init_rwin(req, sk, dst);
6316 6317
	if (!want_cookie) {
		tcp_reqsk_record_syn(sk, req, skb);
6318
		fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc, dst);
6319
	}
6320
	if (fastopen_sk) {
6321
		af_ops->send_synack(fastopen_sk, dst, &fl, req,
6322
				    &foc, TCP_SYNACK_FASTOPEN);
6323 6324 6325 6326
		/* 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);
6327 6328
		sock_put(fastopen_sk);
	} else {
6329
		tcp_rsk(req)->tfo_listener = false;
6330
		if (!want_cookie)
6331 6332
			inet_csk_reqsk_queue_hash_add(sk, req,
				tcp_timeout_init((struct sock *)req));
6333 6334 6335
		af_ops->send_synack(sk, dst, &fl, req, &foc,
				    !want_cookie ? TCP_SYNACK_NORMAL :
						   TCP_SYNACK_COOKIE);
6336 6337 6338 6339
		if (want_cookie) {
			reqsk_free(req);
			return 0;
		}
O
Octavian Purdila 已提交
6340
	}
6341
	reqsk_put(req);
O
Octavian Purdila 已提交
6342 6343 6344 6345 6346 6347 6348
	return 0;

drop_and_release:
	dst_release(dst);
drop_and_free:
	reqsk_free(req);
drop:
6349
	tcp_listendrop(sk);
O
Octavian Purdila 已提交
6350 6351 6352
	return 0;
}
EXPORT_SYMBOL(tcp_conn_request);