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

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

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

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

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

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

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

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

#define FLAG_ACKED		(FLAG_DATA_ACKED|FLAG_SYN_ACKED)
#define FLAG_NOT_DUP		(FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED)
#define FLAG_CA_ALERT		(FLAG_DATA_SACKED|FLAG_ECE)
#define FLAG_FORWARD_PROGRESS	(FLAG_ACKED|FLAG_DATA_SACKED)

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

125 126 127 128
#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 */

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

E
Eric Dumazet 已提交
311
static void tcp_sndbuf_expand(struct sock *sk)
L
Linus Torvalds 已提交
312
{
E
Eric Dumazet 已提交
313
	const struct tcp_sock *tp = tcp_sk(sk);
314
	const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
E
Eric Dumazet 已提交
315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334
	int sndmem, per_mss;
	u32 nr_segs;

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

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

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

	/* Fast Recovery (RFC 5681 3.2) :
	 * Cubic needs 1.7 factor, rounded to 2 to include
	 * extra cushion (application might react slowly to POLLOUT)
	 */
335 336
	sndmem = ca_ops->sndbuf_expand ? ca_ops->sndbuf_expand(sk) : 2;
	sndmem *= nr_segs * per_mss;
L
Linus Torvalds 已提交
337

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

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

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

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

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

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

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

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

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

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

418 419
	rcvmem = 2 * SKB_TRUESIZE(mss + MAX_TCP_HEADER) *
		 tcp_default_init_rwnd(mss);
420

E
Eric Dumazet 已提交
421 422 423 424 425 426
	/* Dynamic Right Sizing (DRS) has 2 to 3 RTT latency
	 * Allow enough cushion so that sender is not limited by our window
	 */
	if (sysctl_tcp_moderate_rcvbuf)
		rcvmem <<= 2;

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

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

	tp->rcvq_space.space = tp->rcv_wnd;
E
Eric Dumazet 已提交
445 446
	tp->rcvq_space.time = tcp_time_stamp;
	tp->rcvq_space.seq = tp->copied_seq;
L
Linus Torvalds 已提交
447 448 449 450 451 452 453 454 455 456 457 458 459 460 461 462 463 464 465 466 467 468 469

	maxwin = tcp_full_space(sk);

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

		if (sysctl_tcp_app_win && maxwin > 4 * tp->advmss)
			tp->window_clamp = max(maxwin -
					       (maxwin >> sysctl_tcp_app_win),
					       4 * tp->advmss);
	}

	/* Force reservation of one segment. */
	if (sysctl_tcp_app_win &&
	    tp->window_clamp > 2 * tp->advmss &&
	    tp->window_clamp + tp->advmss > maxwin)
		tp->window_clamp = max(2 * tp->advmss, maxwin - tp->advmss);

	tp->rcv_ssthresh = min(tp->rcv_ssthresh, tp->window_clamp);
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

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

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

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

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

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

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

L
Linus Torvalds 已提交
508 509 510 511
/* 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.
512
 * <http://public.lanl.gov/radiant/pubs.html#DRS>
L
Linus Torvalds 已提交
513 514
 *
 * More detail on this code can be found at
515
 * <http://staff.psc.edu/jheffner/>,
L
Linus Torvalds 已提交
516 517 518 519 520 521 522 523 524 525 526 527 528 529 530 531 532 533
 * though this reference is out of date.  A new paper
 * is pending.
 */
static void tcp_rcv_rtt_update(struct tcp_sock *tp, u32 sample, int win_dep)
{
	u32 new_sample = tp->rcv_rtt_est.rtt;
	long m = sample;

	if (m == 0)
		m = 1;

	if (new_sample != 0) {
		/* If we sample in larger samples in the non-timestamp
		 * case, we could grossly overestimate the RTT especially
		 * with chatty applications or bulk transfer apps which
		 * are stalled on filesystem I/O.
		 *
		 * Also, since we are only going for a minimum in the
S
Stephen Hemminger 已提交
534
		 * non-timestamp case, we do not smooth things out
S
Stephen Hemminger 已提交
535
		 * else with timestamps disabled convergence takes too
L
Linus Torvalds 已提交
536 537 538 539 540
		 * long.
		 */
		if (!win_dep) {
			m -= (new_sample >> 3);
			new_sample += m;
541 542 543 544 545
		} else {
			m <<= 3;
			if (m < new_sample)
				new_sample = m;
		}
L
Linus Torvalds 已提交
546
	} else {
S
Stephen Hemminger 已提交
547
		/* No previous measure. */
L
Linus Torvalds 已提交
548 549 550 551 552 553 554 555 556 557 558 559 560
		new_sample = m << 3;
	}

	if (tp->rcv_rtt_est.rtt != new_sample)
		tp->rcv_rtt_est.rtt = new_sample;
}

static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
{
	if (tp->rcv_rtt_est.time == 0)
		goto new_measure;
	if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
		return;
561
	tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rcv_rtt_est.time, 1);
L
Linus Torvalds 已提交
562 563 564 565 566 567

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

568 569
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
570
{
571
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
572 573
	if (tp->rx_opt.rcv_tsecr &&
	    (TCP_SKB_CB(skb)->end_seq -
574
	     TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss))
L
Linus Torvalds 已提交
575 576 577 578 579 580 581 582 583 584 585
		tcp_rcv_rtt_update(tp, tcp_time_stamp - tp->rx_opt.rcv_tsecr, 0);
}

/*
 * This function should be called every time data is copied to user space.
 * It calculates the appropriate TCP receive buffer space.
 */
void tcp_rcv_space_adjust(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int time;
E
Eric Dumazet 已提交
586
	int copied;
587

L
Linus Torvalds 已提交
588
	time = tcp_time_stamp - tp->rcvq_space.time;
589
	if (time < (tp->rcv_rtt_est.rtt >> 3) || tp->rcv_rtt_est.rtt == 0)
L
Linus Torvalds 已提交
590
		return;
591

E
Eric Dumazet 已提交
592 593 594 595 596 597 598 599 600 601 602 603 604 605 606 607 608
	/* Number of bytes copied to user in last RTT */
	copied = tp->copied_seq - tp->rcvq_space.seq;
	if (copied <= tp->rcvq_space.space)
		goto new_measure;

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

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

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

E
Eric Dumazet 已提交
615 616 617 618 619 620 621 622 623 624 625 626 627
		/* If rate increased by 25%,
		 *	assume slow start, rcvwin = 3 * copied
		 * If rate increased by 50%,
		 *	assume sender can use 2x growth, rcvwin = 4 * copied
		 */
		if (copied >=
		    tp->rcvq_space.space + (tp->rcvq_space.space >> 2)) {
			if (copied >=
			    tp->rcvq_space.space + (tp->rcvq_space.space >> 1))
				rcvwin <<= 1;
			else
				rcvwin += (rcvwin >> 1);
		}
L
Linus Torvalds 已提交
628

E
Eric Dumazet 已提交
629 630 631
		rcvmem = SKB_TRUESIZE(tp->advmss + MAX_TCP_HEADER);
		while (tcp_win_from_space(rcvmem) < tp->advmss)
			rcvmem += 128;
L
Linus Torvalds 已提交
632

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

E
Eric Dumazet 已提交
637 638
			/* Make the window clamp follow along.  */
			tp->window_clamp = rcvwin;
L
Linus Torvalds 已提交
639 640
		}
	}
E
Eric Dumazet 已提交
641
	tp->rcvq_space.space = copied;
642

L
Linus Torvalds 已提交
643 644 645 646 647 648 649 650 651 652 653 654 655 656 657
new_measure:
	tp->rcvq_space.seq = tp->copied_seq;
	tp->rcvq_space.time = tcp_time_stamp;
}

/* There is something which you must keep in mind when you analyze the
 * behavior of the tp->ato delayed ack timeout interval.  When a
 * connection starts up, we want to ack as quickly as possible.  The
 * problem is that "good" TCP's do slow start at the beginning of data
 * transmission.  The means that until we send the first few ACK's the
 * sender will sit on his end and only queue most of his data, because
 * he can only send snd_cwnd unacked packets at any given time.  For
 * each ACK we send, he increments snd_cwnd and transmits more of his
 * queue.  -DaveM
 */
658
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
659
{
660
	struct tcp_sock *tp = tcp_sk(sk);
661
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
662 663
	u32 now;

664
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
665

666
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
667 668

	tcp_rcv_rtt_measure(tp);
669

L
Linus Torvalds 已提交
670 671
	now = tcp_time_stamp;

672
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
673 674 675
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
676 677
		tcp_incr_quickack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
678
	} else {
679
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
680

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

698
	tcp_ecn_check_ce(tp, skb);
L
Linus Torvalds 已提交
699 700

	if (skb->len >= 128)
701
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
702 703 704 705 706 707 708 709 710 711 712
}

/* 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
 */
713
static void tcp_rtt_estimator(struct sock *sk, long mrtt_us)
L
Linus Torvalds 已提交
714
{
715
	struct tcp_sock *tp = tcp_sk(sk);
716 717
	long m = mrtt_us; /* RTT */
	u32 srtt = tp->srtt_us;
L
Linus Torvalds 已提交
718 719 720 721

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

E
Eric Dumazet 已提交
777 778 779 780 781 782
/* Set the sk_pacing_rate to allow proper sizing of TSO packets.
 * Note: TCP stack does not yet implement pacing.
 * FQ packet scheduler can be used to implement cheap but effective
 * TCP pacing, to smooth the burst on large writes when packets
 * in flight is significantly lower than cwnd (or rwin)
 */
783 784 785
int sysctl_tcp_pacing_ss_ratio __read_mostly = 200;
int sysctl_tcp_pacing_ca_ratio __read_mostly = 120;

E
Eric Dumazet 已提交
786 787 788 789 790 791
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) */
792 793 794 795 796 797 798 799 800 801 802 803 804 805
	rate = (u64)tp->mss_cache * ((USEC_PER_SEC / 100) << 3);

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

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

809 810
	if (likely(tp->srtt_us))
		do_div(rate, tp->srtt_us);
E
Eric Dumazet 已提交
811

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

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

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

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

850
__u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst)
L
Linus Torvalds 已提交
851 852 853
{
	__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

854
	if (!cwnd)
855
		cwnd = TCP_INIT_CWND;
L
Linus Torvalds 已提交
856 857 858
	return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
}

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

871
/* Take a notice that peer is sending D-SACKs */
872 873
static void tcp_dsack_seen(struct tcp_sock *tp)
{
874
	tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
875 876
}

877 878
static void tcp_update_reordering(struct sock *sk, const int metric,
				  const int ts)
L
Linus Torvalds 已提交
879
{
880
	struct tcp_sock *tp = tcp_sk(sk);
881
	int mib_idx;
882

883
	if (metric > tp->reordering) {
884
		tp->reordering = min(sysctl_tcp_max_reordering, metric);
L
Linus Torvalds 已提交
885 886

#if FASTRETRANS_DEBUG > 1
887 888 889 890 891 892
		pr_debug("Disorder%d %d %u f%u s%u rr%d\n",
			 tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
			 tp->reordering,
			 tp->fackets_out,
			 tp->sacked_out,
			 tp->undo_marker ? tp->undo_retrans : 0);
L
Linus Torvalds 已提交
893
#endif
894
		tcp_disable_fack(tp);
L
Linus Torvalds 已提交
895
	}
Y
Yuchung Cheng 已提交
896

Y
Yuchung Cheng 已提交
897
	tp->rack.reord = 1;
898 899 900 901 902 903 904 905 906 907 908 909

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

	NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
910 911
}

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

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

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

Y
Yuchung Cheng 已提交
948
void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb)
949 950 951
{
	tcp_verify_retransmit_hint(tp, skb);

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

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

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

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

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

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

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

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

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

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

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

	return dup_sack;
}

1125
struct tcp_sacktag_state {
1126 1127
	int	reord;
	int	fack_count;
1128 1129 1130 1131 1132 1133
	/* Timestamps for earliest and latest never-retransmitted segment
	 * that was SACKed. RTO needs the earliest RTT to stay conservative,
	 * but congestion control should still get an accurate delay signal.
	 */
	struct skb_mstamp first_sackt;
	struct skb_mstamp last_sackt;
1134
	struct skb_mstamp ack_time; /* Timestamp when the S/ACK was received */
1135
	struct rate_sample *rate;
1136
	int	flag;
1137 1138
};

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

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

1163
		if (!in_sack) {
1164
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1165 1166 1167
			if (pkt_len < mss)
				pkt_len = mss;
		} else {
1168
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1169 1170 1171 1172 1173 1174 1175 1176 1177 1178 1179
			if (pkt_len < mss)
				return -EINVAL;
		}

		/* Round if necessary so that SACKs cover only full MSSes
		 * and/or the remaining small portion (if present)
		 */
		if (pkt_len > mss) {
			unsigned int new_len = (pkt_len / mss) * mss;
			if (!in_sack && new_len < pkt_len) {
				new_len += mss;
1180
				if (new_len >= skb->len)
1181 1182 1183 1184
					return 0;
			}
			pkt_len = new_len;
		}
1185
		err = tcp_fragment(sk, skb, pkt_len, mss, GFP_ATOMIC);
1186 1187 1188 1189 1190 1191 1192
		if (err < 0)
			return err;
	}

	return in_sack;
}

1193 1194 1195 1196
/* 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,
1197 1198
			  int dup_sack, int pcount,
			  const struct skb_mstamp *xmit_time)
1199
{
1200
	struct tcp_sock *tp = tcp_sk(sk);
1201
	int fack_count = state->fack_count;
1202 1203 1204

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

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

	if (!(sacked & TCPCB_SACKED_ACKED)) {
1217 1218
		tcp_rack_advance(tp, sacked, end_seq,
				 xmit_time, &state->ack_time);
1219

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

			if (sacked & TCPCB_LOST) {
1247
				sacked &= ~TCPCB_LOST;
1248
				tp->lost_out -= pcount;
1249 1250 1251
			}
		}

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

1257
		fack_count += pcount;
1258 1259

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
1260
		if (!tcp_is_fack(tp) && tp->lost_skb_hint &&
1261
		    before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
1262
			tp->lost_cnt_hint += pcount;
1263 1264 1265 1266 1267 1268 1269 1270 1271

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

	/* D-SACK. We can detect redundant retransmission in S|R and plain R
	 * frames and clear it. undo_retrans is decreased above, L|R frames
	 * are accounted above as well.
	 */
1272 1273
	if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
		sacked &= ~TCPCB_SACKED_RETRANS;
1274
		tp->retrans_out -= pcount;
1275 1276
	}

1277
	return sacked;
1278 1279
}

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

	BUG_ON(!pcount);

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

	if (skb == tp->lost_skb_hint)
1307 1308
		tp->lost_cnt_hint += pcount;

1309 1310 1311
	TCP_SKB_CB(prev)->end_seq += shifted;
	TCP_SKB_CB(skb)->seq += shifted;

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

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

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

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

	/* Whole SKB was eaten :-) */

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

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

1351 1352 1353
	if (skb == tcp_highest_sack(sk))
		tcp_advance_highest_sack(sk, skb);

1354
	tcp_skb_collapse_tstamp(prev, skb);
1355 1356 1357
	if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp.v64))
		TCP_SKB_CB(prev)->tx.delivered_mstamp.v64 = 0;

1358 1359 1360
	tcp_unlink_write_queue(skb, sk);
	sk_wmem_free_skb(sk, skb);

1361
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
1362

E
Eric Dumazet 已提交
1363
	return true;
1364 1365 1366 1367 1368
}

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

/* Shifting pages past head area doesn't work */
1375
static int skb_can_shift(const struct sk_buff *skb)
1376 1377 1378 1379 1380 1381 1382 1383
{
	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,
1384
					  struct tcp_sacktag_state *state,
1385
					  u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1386
					  bool dup_sack)
1387 1388 1389 1390 1391 1392 1393 1394 1395 1396 1397 1398 1399
{
	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 &&
1400
	    (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415
		goto fallback;
	if (!skb_can_shift(skb))
		goto fallback;
	/* This frame is about to be dropped (was ACKed). */
	if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
		goto fallback;

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

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

1416 1417 1418
	if (!tcp_skb_can_collapse_to(prev))
		goto fallback;

1419 1420 1421 1422 1423 1424
	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);
1425
		mss = tcp_skb_seglen(skb);
1426 1427 1428 1429

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

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

1484 1485 1486 1487
	/* tcp_sacktag_one() won't SACK-tag ranges below snd_una */
	if (!after(TCP_SKB_CB(skb)->seq + len, tp->snd_una))
		goto fallback;

1488 1489
	if (!skb_shift(prev, skb, len))
		goto fallback;
I
Ilpo Järvinen 已提交
1490
	if (!tcp_shifted_skb(sk, skb, state, pcount, len, mss, dup_sack))
1491 1492 1493 1494 1495 1496 1497 1498 1499
		goto out;

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

1500 1501 1502
	if (!skb_can_shift(skb) ||
	    (skb == tcp_send_head(sk)) ||
	    ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1503
	    (mss != tcp_skb_seglen(skb)))
1504 1505 1506 1507 1508
		goto out;

	len = skb->len;
	if (skb_shift(prev, skb, len)) {
		pcount += tcp_skb_pcount(skb);
I
Ilpo Järvinen 已提交
1509
		tcp_shifted_skb(sk, skb, state, tcp_skb_pcount(skb), len, mss, 0);
1510 1511 1512
	}

out:
1513
	state->fack_count += pcount;
1514 1515 1516 1517 1518 1519
	return prev;

noop:
	return skb;

fallback:
1520
	NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1521 1522 1523
	return NULL;
}

1524 1525
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
1526
					struct tcp_sacktag_state *state,
1527
					u32 start_seq, u32 end_seq,
E
Eric Dumazet 已提交
1528
					bool dup_sack_in)
1529
{
1530 1531 1532
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *tmp;

1533 1534
	tcp_for_write_queue_from(skb, sk) {
		int in_sack = 0;
E
Eric Dumazet 已提交
1535
		bool dup_sack = dup_sack_in;
1536 1537 1538 1539 1540 1541 1542 1543

		if (skb == tcp_send_head(sk))
			break;

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

1544
		if (next_dup  &&
1545 1546 1547 1548 1549
		    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 已提交
1550
				dup_sack = true;
1551 1552
		}

1553 1554 1555 1556 1557
		/* 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) {
1558 1559
			tmp = tcp_shift_skb_data(sk, skb, state,
						 start_seq, end_seq, dup_sack);
1560
			if (tmp) {
1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571 1572 1573
				if (tmp != skb) {
					skb = tmp;
					continue;
				}

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

1574 1575 1576
		if (unlikely(in_sack < 0))
			break;

1577
		if (in_sack) {
1578 1579 1580 1581 1582 1583 1584
			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 已提交
1585
						tcp_skb_pcount(skb),
1586
						&skb->skb_mstamp);
1587
			tcp_rate_skb_delivered(sk, skb, state->rate);
1588

1589 1590 1591 1592 1593
			if (!before(TCP_SKB_CB(skb)->seq,
				    tcp_highest_sack_seq(tp)))
				tcp_advance_highest_sack(sk, skb);
		}

1594
		state->fack_count += tcp_skb_pcount(skb);
1595 1596 1597 1598 1599 1600 1601 1602
	}
	return skb;
}

/* Avoid all extra work that is being done by sacktag while walking in
 * a normal way
 */
static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,
1603 1604
					struct tcp_sacktag_state *state,
					u32 skip_to_seq)
1605 1606 1607 1608 1609
{
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;

I
Ilpo Järvinen 已提交
1610
		if (after(TCP_SKB_CB(skb)->end_seq, skip_to_seq))
1611
			break;
1612

1613
		state->fack_count += tcp_skb_pcount(skb);
1614 1615 1616 1617 1618 1619 1620
	}
	return skb;
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
1621 1622
						struct tcp_sacktag_state *state,
						u32 skip_to_seq)
1623
{
1624
	if (!next_dup)
1625 1626 1627
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1628 1629 1630 1631
		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);
1632 1633 1634 1635 1636
	}

	return skb;
}

1637
static int tcp_sack_cache_ok(const struct tcp_sock *tp, const struct tcp_sack_block *cache)
1638 1639 1640 1641
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

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

1659 1660
	state->flag = 0;
	state->reord = tp->packets_out;
1661

1662
	if (!tp->sacked_out) {
1663 1664
		if (WARN_ON(tp->fackets_out))
			tp->fackets_out = 0;
1665
		tcp_highest_sack_reset(sk);
1666
	}
L
Linus Torvalds 已提交
1667

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

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

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

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

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

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

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

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

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

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

1737
	skb = tcp_write_queue_head(sk);
1738
	state->fack_count = 0;
1739 1740 1741 1742 1743 1744 1745 1746 1747 1748 1749
	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++;
1750 1751
	}

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

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

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

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

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

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

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

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

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

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

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

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

1834
	tcp_verify_left_out(tp);
1835 1836
out:

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

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

/* If we receive more dupacks than we expected counting segments
 * in assumption of absent reordering, interpret this as reordering.
 * The only another reason could be bug in receiver TCP.
 */
static void tcp_check_reno_reordering(struct sock *sk, const int addend)
{
	struct tcp_sock *tp = tcp_sk(sk);
	if (tcp_limit_reno_sacked(tp))
		tcp_update_reordering(sk, tp->packets_out + addend, 0);
1872 1873 1874 1875 1876 1877 1878
}

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

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

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

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

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

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

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

	/* Reduce ssthresh if it has not yet been made inside this window. */
Y
Yuchung Cheng 已提交
1943 1944
	if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
	    !after(tp->high_seq, tp->snd_una) ||
1945 1946 1947 1948
	    (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
		tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		tcp_ca_event(sk, CA_EVENT_LOSS);
Y
Yuchung Cheng 已提交
1949
		tcp_init_undo(tp);
L
Linus Torvalds 已提交
1950 1951 1952 1953 1954
	}
	tp->snd_cwnd	   = 1;
	tp->snd_cwnd_cnt   = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;

Y
Yuchung Cheng 已提交
1955 1956
	tp->retrans_out = 0;
	tp->lost_out = 0;
1957 1958 1959

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

1961 1962 1963
	skb = tcp_write_queue_head(sk);
	is_reneg = skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED);
	if (is_reneg) {
1964
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
1965 1966
		tp->sacked_out = 0;
		tp->fackets_out = 0;
1967
	}
1968
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
1969

1970 1971 1972
	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
1973

1974 1975 1976 1977
		mark_lost = (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
			     is_reneg);
		if (mark_lost)
			tcp_sum_lost(tp, skb);
L
Linus Torvalds 已提交
1978
		TCP_SKB_CB(skb)->sacked &= (~TCPCB_TAGBITS)|TCPCB_SACKED_ACKED;
1979
		if (mark_lost) {
L
Linus Torvalds 已提交
1980 1981 1982 1983 1984
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
		}
	}
1985
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
1986

1987 1988 1989 1990
	/* 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 &&
1991
	    tp->sacked_out >= net->ipv4.sysctl_tcp_reordering)
1992
		tp->reordering = min_t(unsigned int, tp->reordering,
1993
				       net->ipv4.sysctl_tcp_reordering);
1994
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
1995
	tp->high_seq = tp->snd_nxt;
1996
	tcp_ecn_queue_cwr(tp);
Y
Yuchung Cheng 已提交
1997

1998 1999 2000 2001 2002 2003 2004 2005
	/* F-RTO RFC5682 sec 3.1 step 1: retransmit SND.UNA if no previous
	 * loss recovery is underway except recurring timeout(s) on
	 * the same SND.UNA (sec 3.2). Disable F-RTO on path MTU probing
	 *
	 * In theory F-RTO can be used repeatedly during loss recovery.
	 * In practice this interacts badly with broken middle-boxes that
	 * falsely raise the receive window, which results in repeated
	 * timeouts and stop-and-go behavior.
Y
Yuchung Cheng 已提交
2006
	 */
2007 2008 2009
	tp->frto = sysctl_tcp_frto &&
		   (new_recovery || icsk->icsk_retransmits) &&
		   !inet_csk(sk)->icsk_mtup.probe_size;
L
Linus Torvalds 已提交
2010 2011
}

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

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

2036
static inline int tcp_fackets_out(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2037
{
2038
	return tcp_is_reno(tp) ? tp->sacked_out + 1 : tp->fackets_out;
L
Linus Torvalds 已提交
2039 2040
}

2041 2042 2043 2044 2045 2046 2047 2048 2049 2050 2051 2052 2053 2054 2055
/* Heurestics to calculate number of duplicate ACKs. There's no dupACKs
 * counter when SACK is enabled (without SACK, sacked_out is used for
 * that purpose).
 *
 * Instead, with FACK TCP uses fackets_out that includes both SACKed
 * segments up to the highest received SACK block so far and holes in
 * between them.
 *
 * With reordering, holes may still be in flight, so RFC3517 recovery
 * uses pure sacked_out (total number of SACKed segments) even though
 * it violates the RFC that uses duplicate ACKs, often these are equal
 * but when e.g. out-of-window ACKs or packet duplication occurs,
 * they differ. Since neither occurs due to loss, TCP should really
 * ignore them.
 */
2056
static inline int tcp_dupack_heuristics(const struct tcp_sock *tp)
2057 2058 2059 2060
{
	return tcp_is_fack(tp) ? tp->fackets_out : tp->sacked_out + 1;
}

L
Linus Torvalds 已提交
2061 2062 2063 2064 2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087 2088 2089 2090 2091 2092 2093 2094 2095 2096 2097 2098 2099 2100 2101 2102 2103 2104 2105 2106 2107
/* Linux NewReno/SACK/FACK/ECN state machine.
 * --------------------------------------
 *
 * "Open"	Normal state, no dubious events, fast path.
 * "Disorder"   In all the respects it is "Open",
 *		but requires a bit more attention. It is entered when
 *		we see some SACKs or dupacks. It is split of "Open"
 *		mainly to move some processing from fast path to slow one.
 * "CWR"	CWND was reduced due to some Congestion Notification event.
 *		It can be ECN, ICMP source quench, local device congestion.
 * "Recovery"	CWND was reduced, we are fast-retransmitting.
 * "Loss"	CWND was reduced due to RTO timeout or SACK reneging.
 *
 * tcp_fastretrans_alert() is entered:
 * - each incoming ACK, if state is not "Open"
 * - when arrived ACK is unusual, namely:
 *	* SACK
 *	* Duplicate ACK.
 *	* ECN ECE.
 *
 * Counting packets in flight is pretty simple.
 *
 *	in_flight = packets_out - left_out + retrans_out
 *
 *	packets_out is SND.NXT-SND.UNA counted in packets.
 *
 *	retrans_out is number of retransmitted segments.
 *
 *	left_out is number of segments left network, but not ACKed yet.
 *
 *		left_out = sacked_out + lost_out
 *
 *     sacked_out: Packets, which arrived to receiver out of order
 *		   and hence not ACKed. With SACKs this number is simply
 *		   amount of SACKed data. Even without SACKs
 *		   it is easy to give pretty reliable estimate of this number,
 *		   counting duplicate ACKs.
 *
 *       lost_out: Packets lost by network. TCP has no explicit
 *		   "loss notification" feedback from network (for now).
 *		   It means that this number can be only _guessed_.
 *		   Actually, it is the heuristics to predict lossage that
 *		   distinguishes different algorithms.
 *
 *	F.e. after RTO, when all the queue is considered as lost,
 *	lost_out = packets_out and in_flight = retrans_out.
 *
2108
 *		Essentially, we have now a few algorithms detecting
L
Linus Torvalds 已提交
2109 2110
 *		lost packets.
 *
2111 2112 2113 2114 2115 2116 2117 2118 2119 2120 2121 2122 2123 2124 2125
 *		If the receiver supports SACK:
 *
 *		RFC6675/3517: It is the conventional algorithm. A packet is
 *		considered lost if the number of higher sequence packets
 *		SACKed is greater than or equal the DUPACK thoreshold
 *		(reordering). This is implemented in tcp_mark_head_lost and
 *		tcp_update_scoreboard.
 *
 *		RACK (draft-ietf-tcpm-rack-01): it is a newer algorithm
 *		(2017-) that checks timing instead of counting DUPACKs.
 *		Essentially a packet is considered lost if it's not S/ACKed
 *		after RTT + reordering_window, where both metrics are
 *		dynamically measured and adjusted. This is implemented in
 *		tcp_rack_mark_lost.
 *
Y
Yuchung Cheng 已提交
2126 2127
 *		FACK (Disabled by default. Subsumbed by RACK):
 *		It is the simplest heuristics. As soon as we decided
L
Linus Torvalds 已提交
2128 2129 2130 2131 2132 2133 2134 2135
 *		that something is lost, we decide that _all_ not SACKed
 *		packets until the most forward SACK are lost. I.e.
 *		lost_out = fackets_out - sacked_out and left_out = fackets_out.
 *		It is absolutely correct estimate, if network does not reorder
 *		packets. And it loses any connection to reality when reordering
 *		takes place. We use FACK by default until reordering
 *		is suspected on the path to this destination.
 *
2136 2137 2138
 *		If the receiver does not support SACK:
 *
 *		NewReno (RFC6582): in Recovery we assume that one segment
L
Linus Torvalds 已提交
2139 2140 2141 2142 2143 2144 2145 2146 2147 2148 2149 2150 2151 2152 2153 2154 2155 2156 2157 2158 2159 2160 2161 2162 2163 2164 2165 2166 2167
 *		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 已提交
2168
static bool tcp_time_to_recover(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2169
{
2170
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2171 2172 2173

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

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

E
Eric Dumazet 已提交
2180
	return false;
L
Linus Torvalds 已提交
2181 2182
}

2183 2184 2185 2186 2187
/* Detect loss in event "A" above by marking head of queue up as lost.
 * For FACK or non-SACK(Reno) senders, the first "packets" number of segments
 * are considered lost. For RFC3517 SACK, a segment is considered lost if it
 * has at least tp->reordering SACKed seqments above it; "packets" refers to
 * the maximum SACKed segments to pass before reaching this limit.
2188
 */
I
Ilpo Järvinen 已提交
2189
static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
L
Linus Torvalds 已提交
2190
{
2191
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2192
	struct sk_buff *skb;
2193
	int cnt, oldcnt, lost;
2194
	unsigned int mss;
2195 2196
	/* 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 已提交
2197

2198
	WARN_ON(packets > tp->packets_out);
2199 2200 2201
	if (tp->lost_skb_hint) {
		skb = tp->lost_skb_hint;
		cnt = tp->lost_cnt_hint;
I
Ilpo Järvinen 已提交
2202 2203 2204
		/* Head already handled? */
		if (mark_head && skb != tcp_write_queue_head(sk))
			return;
2205
	} else {
2206
		skb = tcp_write_queue_head(sk);
2207 2208
		cnt = 0;
	}
L
Linus Torvalds 已提交
2209

2210 2211 2212
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2213 2214 2215 2216
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2217

2218
		if (after(TCP_SKB_CB(skb)->end_seq, loss_high))
2219 2220 2221
			break;

		oldcnt = cnt;
2222
		if (tcp_is_fack(tp) || tcp_is_reno(tp) ||
2223 2224 2225
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

2226
		if (cnt > packets) {
2227
			if ((tcp_is_sack(tp) && !tcp_is_fack(tp)) ||
2228
			    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED) ||
2229
			    (oldcnt >= packets))
2230 2231
				break;

2232
			mss = tcp_skb_mss(skb);
2233 2234 2235 2236
			/* If needed, chop off the prefix to mark as lost. */
			lost = (packets - oldcnt) * mss;
			if (lost < skb->len &&
			    tcp_fragment(sk, skb, lost, mss, GFP_ATOMIC) < 0)
2237 2238 2239 2240
				break;
			cnt = packets;
		}

2241
		tcp_skb_mark_lost(tp, skb);
I
Ilpo Järvinen 已提交
2242 2243 2244

		if (mark_head)
			break;
L
Linus Torvalds 已提交
2245
	}
2246
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2247 2248 2249 2250
}

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

2251
static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
L
Linus Torvalds 已提交
2252
{
2253 2254
	struct tcp_sock *tp = tcp_sk(sk);

2255
	if (tcp_is_reno(tp)) {
I
Ilpo Järvinen 已提交
2256
		tcp_mark_head_lost(sk, 1, 1);
2257
	} else if (tcp_is_fack(tp)) {
L
Linus Torvalds 已提交
2258 2259 2260
		int lost = tp->fackets_out - tp->reordering;
		if (lost <= 0)
			lost = 1;
I
Ilpo Järvinen 已提交
2261
		tcp_mark_head_lost(sk, lost, 0);
L
Linus Torvalds 已提交
2262
	} else {
2263
		int sacked_upto = tp->sacked_out - tp->reordering;
I
Ilpo Järvinen 已提交
2264 2265 2266 2267
		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 已提交
2268 2269 2270
	}
}

2271 2272 2273 2274 2275 2276
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);
}

2277 2278 2279 2280 2281 2282 2283 2284 2285 2286
/* 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 已提交
2287 2288 2289
/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
2290
static inline bool tcp_packet_delayed(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2291 2292
{
	return !tp->retrans_stamp ||
2293
	       tcp_tsopt_ecr_before(tp, tp->retrans_stamp);
L
Linus Torvalds 已提交
2294 2295 2296 2297
}

/* Undo procedures. */

2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308 2309 2310 2311 2312 2313 2314 2315 2316 2317 2318 2319 2320 2321 2322 2323 2324 2325 2326
/* We can clear retrans_stamp when there are no retransmissions in the
 * window. It would seem that it is trivially available for us in
 * tp->retrans_out, however, that kind of assumptions doesn't consider
 * what will happen if errors occur when sending retransmission for the
 * second time. ...It could the that such segment has only
 * TCPCB_EVER_RETRANS set at the present time. It seems that checking
 * the head skb is enough except for some reneging corner cases that
 * are not worth the effort.
 *
 * Main reason for all this complexity is the fact that connection dying
 * time now depends on the validity of the retrans_stamp, in particular,
 * that successive retransmissions of a segment must not advance
 * retrans_stamp under any conditions.
 */
static bool tcp_any_retrans_done(const struct sock *sk)
{
	const struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	if (tp->retrans_out)
		return true;

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

	return false;
}

L
Linus Torvalds 已提交
2327
#if FASTRETRANS_DEBUG > 1
2328
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2329
{
2330
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2331
	struct inet_sock *inet = inet_sk(sk);
2332

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

2356
static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
L
Linus Torvalds 已提交
2357
{
2358 2359
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371
	if (unmark_loss) {
		struct sk_buff *skb;

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

L
Linus Torvalds 已提交
2372
	if (tp->prior_ssthresh) {
2373 2374
		const struct inet_connection_sock *icsk = inet_csk(sk);

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

2377
		if (tp->prior_ssthresh > tp->snd_ssthresh) {
L
Linus Torvalds 已提交
2378
			tp->snd_ssthresh = tp->prior_ssthresh;
2379
			tcp_ecn_withdraw_cwr(tp);
L
Linus Torvalds 已提交
2380 2381 2382
		}
	}
	tp->snd_cwnd_stamp = tcp_time_stamp;
2383
	tp->undo_marker = 0;
L
Linus Torvalds 已提交
2384 2385
}

2386
static inline bool tcp_may_undo(const struct tcp_sock *tp)
L
Linus Torvalds 已提交
2387
{
2388
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2389 2390 2391
}

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

L
Linus Torvalds 已提交
2396
	if (tcp_may_undo(tp)) {
2397 2398
		int mib_idx;

L
Linus Torvalds 已提交
2399 2400 2401
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2402
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2403
		tcp_undo_cwnd_reduction(sk, false);
2404
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2405
			mib_idx = LINUX_MIB_TCPLOSSUNDO;
L
Linus Torvalds 已提交
2406
		else
2407 2408
			mib_idx = LINUX_MIB_TCPFULLUNDO;

2409
		NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
2410
	}
2411
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2412 2413 2414
		/* 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. */
2415 2416
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;
E
Eric Dumazet 已提交
2417
		return true;
L
Linus Torvalds 已提交
2418
	}
2419
	tcp_set_ca_state(sk, TCP_CA_Open);
E
Eric Dumazet 已提交
2420
	return false;
L
Linus Torvalds 已提交
2421 2422 2423
}

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

L
Linus Torvalds 已提交
2428
	if (tp->undo_marker && !tp->undo_retrans) {
2429
		DBGUNDO(sk, "D-SACK");
2430
		tcp_undo_cwnd_reduction(sk, false);
2431
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
2432
		return true;
L
Linus Torvalds 已提交
2433
	}
2434
	return false;
L
Linus Torvalds 已提交
2435 2436
}

Y
Yuchung Cheng 已提交
2437 2438
/* 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 已提交
2439
{
2440 2441
	struct tcp_sock *tp = tcp_sk(sk);

Y
Yuchung Cheng 已提交
2442
	if (frto_undo || tcp_may_undo(tp)) {
2443
		tcp_undo_cwnd_reduction(sk, true);
2444

2445
		DBGUNDO(sk, "partial loss");
2446
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
Y
Yuchung Cheng 已提交
2447
		if (frto_undo)
2448
			NET_INC_STATS(sock_net(sk),
2449
					LINUX_MIB_TCPSPURIOUSRTOS);
2450
		inet_csk(sk)->icsk_retransmits = 0;
Y
Yuchung Cheng 已提交
2451
		if (frto_undo || tcp_is_sack(tp))
2452
			tcp_set_ca_state(sk, TCP_CA_Open);
E
Eric Dumazet 已提交
2453
		return true;
L
Linus Torvalds 已提交
2454
	}
E
Eric Dumazet 已提交
2455
	return false;
L
Linus Torvalds 已提交
2456 2457
}

2458
/* The cwnd reduction in CWR and Recovery uses the PRR algorithm in RFC 6937.
2459 2460 2461 2462
 * 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.
2463 2464 2465
 *   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.
2466
 */
2467
static void tcp_init_cwnd_reduction(struct sock *sk)
2468 2469 2470 2471
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->high_seq = tp->snd_nxt;
N
Nandita Dukkipati 已提交
2472
	tp->tlp_high_seq = 0;
2473 2474 2475 2476
	tp->snd_cwnd_cnt = 0;
	tp->prior_cwnd = tp->snd_cwnd;
	tp->prr_delivered = 0;
	tp->prr_out = 0;
2477
	tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);
2478
	tcp_ecn_queue_cwr(tp);
2479 2480
}

2481
void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int flag)
2482 2483 2484 2485 2486
{
	struct tcp_sock *tp = tcp_sk(sk);
	int sndcnt = 0;
	int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);

2487 2488 2489
	if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))
		return;

2490
	tp->prr_delivered += newly_acked_sacked;
2491
	if (delta < 0) {
2492 2493 2494
		u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
			       tp->prior_cwnd - 1;
		sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;
2495 2496
	} else if ((flag & FLAG_RETRANS_DATA_ACKED) &&
		   !(flag & FLAG_LOST_RETRANS)) {
2497 2498 2499
		sndcnt = min_t(int, delta,
			       max_t(int, tp->prr_delivered - tp->prr_out,
				     newly_acked_sacked) + 1);
2500 2501
	} else {
		sndcnt = min(delta, newly_acked_sacked);
2502
	}
2503 2504
	/* Force a fast retransmit upon entering fast recovery */
	sndcnt = max(sndcnt, (tp->prr_out ? 0 : 1));
2505 2506 2507
	tp->snd_cwnd = tcp_packets_in_flight(tp) + sndcnt;
}

2508
static inline void tcp_end_cwnd_reduction(struct sock *sk)
L
Linus Torvalds 已提交
2509
{
2510
	struct tcp_sock *tp = tcp_sk(sk);
2511

2512 2513 2514
	if (inet_csk(sk)->icsk_ca_ops->cong_control)
		return;

2515 2516 2517 2518 2519
	/* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
	if (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR ||
	    (tp->undo_marker && tp->snd_ssthresh < TCP_INFINITE_SSTHRESH)) {
		tp->snd_cwnd = tp->snd_ssthresh;
		tp->snd_cwnd_stamp = tcp_time_stamp;
2520
	}
2521
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2522 2523
}

2524
/* Enter CWR state. Disable cwnd undo since congestion is proven with ECN */
2525
void tcp_enter_cwr(struct sock *sk)
Y
Yuchung Cheng 已提交
2526 2527 2528 2529
{
	struct tcp_sock *tp = tcp_sk(sk);

	tp->prior_ssthresh = 0;
2530
	if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
Y
Yuchung Cheng 已提交
2531
		tp->undo_marker = 0;
2532
		tcp_init_cwnd_reduction(sk);
Y
Yuchung Cheng 已提交
2533 2534 2535
		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}
2536
EXPORT_SYMBOL(tcp_enter_cwr);
Y
Yuchung Cheng 已提交
2537

2538 2539 2540 2541 2542
static void tcp_try_keep_open(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int state = TCP_CA_Open;

2543
	if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
2544 2545 2546 2547 2548 2549 2550 2551
		state = TCP_CA_Disorder;

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

2552
static void tcp_try_to_open(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2553
{
2554 2555
	struct tcp_sock *tp = tcp_sk(sk);

2556 2557
	tcp_verify_left_out(tp);

Y
Yuchung Cheng 已提交
2558
	if (!tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2559 2560
		tp->retrans_stamp = 0;

2561
	if (flag & FLAG_ECE)
2562
		tcp_enter_cwr(sk);
L
Linus Torvalds 已提交
2563

2564
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2565
		tcp_try_keep_open(sk);
L
Linus Torvalds 已提交
2566 2567 2568
	}
}

J
John Heffner 已提交
2569 2570 2571 2572 2573 2574
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;
2575
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
J
John Heffner 已提交
2576 2577
}

2578
static void tcp_mtup_probe_success(struct sock *sk)
J
John Heffner 已提交
2579 2580 2581 2582 2583 2584 2585 2586 2587 2588 2589
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);

	/* FIXME: breaks with very large cwnd */
	tp->prior_ssthresh = tcp_current_ssthresh(sk);
	tp->snd_cwnd = tp->snd_cwnd *
		       tcp_mss_to_mtu(sk, tp->mss_cache) /
		       icsk->icsk_mtup.probe_size;
	tp->snd_cwnd_cnt = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;
2590
	tp->snd_ssthresh = tcp_current_ssthresh(sk);
J
John Heffner 已提交
2591 2592 2593 2594

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

2598 2599 2600 2601 2602 2603 2604 2605 2606
/* 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 已提交
2607
	unsigned int mss = tcp_current_mss(sk);
2608 2609 2610 2611 2612
	u32 prior_lost = tp->lost_out;

	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2613
		if (tcp_skb_seglen(skb) > mss &&
2614 2615 2616 2617 2618 2619 2620 2621 2622 2623 2624 2625 2626 2627 2628 2629 2630 2631 2632 2633 2634 2635 2636 2637 2638 2639 2640 2641 2642 2643 2644 2645 2646
		    !(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)) {
			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
				TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
				tp->retrans_out -= tcp_skb_pcount(skb);
			}
			tcp_skb_mark_lost_uncond_verify(tp, skb);
		}
	}

	tcp_clear_retrans_hints_partial(tp);

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

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

	tcp_verify_left_out(tp);

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

2649
void tcp_enter_recovery(struct sock *sk, bool ece_ack)
2650 2651 2652 2653 2654 2655 2656 2657 2658
{
	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;

2659
	NET_INC_STATS(sock_net(sk), mib_idx);
2660 2661

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

2664
	if (!tcp_in_cwnd_reduction(sk)) {
2665 2666
		if (!ece_ack)
			tp->prior_ssthresh = tcp_current_ssthresh(sk);
2667
		tcp_init_cwnd_reduction(sk);
2668 2669 2670 2671
	}
	tcp_set_ca_state(sk, TCP_CA_Recovery);
}

2672 2673 2674
/* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
 * recovered or spurious. Otherwise retransmits more on partial ACKs.
 */
2675 2676
static void tcp_process_loss(struct sock *sk, int flag, bool is_dupack,
			     int *rexmit)
2677 2678
{
	struct tcp_sock *tp = tcp_sk(sk);
Y
Yuchung Cheng 已提交
2679
	bool recovered = !before(tp->snd_una, tp->high_seq);
2680

2681 2682 2683 2684
	if ((flag & FLAG_SND_UNA_ADVANCED) &&
	    tcp_try_undo_loss(sk, false))
		return;

2685 2686 2687 2688 2689 2690 2691 2692 2693 2694
	/* 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;
2695

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

	if (recovered) {
		/* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
2717 2718 2719
		tcp_try_undo_recovery(sk);
		return;
	}
Y
Yuchung Cheng 已提交
2720 2721 2722 2723 2724 2725 2726 2727 2728
	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);
	}
2729
	*rexmit = REXMIT_LOST;
2730 2731
}

Y
Yuchung Cheng 已提交
2732
/* Undo during fast recovery after partial ACK. */
2733
static bool tcp_try_undo_partial(struct sock *sk, const int acked)
Y
Yuchung Cheng 已提交
2734 2735 2736
{
	struct tcp_sock *tp = tcp_sk(sk);

2737
	if (tp->undo_marker && tcp_packet_delayed(tp)) {
Y
Yuchung Cheng 已提交
2738 2739 2740
		/* Plain luck! Hole if filled with delayed
		 * packet, rather than with a retransmit.
		 */
2741 2742 2743 2744 2745 2746 2747
		tcp_update_reordering(sk, tcp_fackets_out(tp) + acked, 1);

		/* We are getting evidence that the reordering degree is higher
		 * than we realized. If there are no retransmits out then we
		 * can undo. Otherwise we clock out new packets but do not
		 * mark more packets lost or retransmit more.
		 */
2748
		if (tp->retrans_out)
2749 2750
			return true;

Y
Yuchung Cheng 已提交
2751 2752 2753
		if (!tcp_any_retrans_done(sk))
			tp->retrans_stamp = 0;

2754 2755
		DBGUNDO(sk, "partial recovery");
		tcp_undo_cwnd_reduction(sk, true);
2756
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
2757 2758
		tcp_try_keep_open(sk);
		return true;
Y
Yuchung Cheng 已提交
2759
	}
2760
	return false;
Y
Yuchung Cheng 已提交
2761 2762
}

2763 2764 2765 2766 2767 2768
static void tcp_rack_identify_loss(struct sock *sk, int *ack_flag,
				   const struct skb_mstamp *ack_time)
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Use RACK to detect loss */
2769
	if (sysctl_tcp_recovery & TCP_RACK_LOSS_DETECTION) {
2770 2771
		u32 prior_retrans = tp->retrans_out;

2772
		tcp_rack_mark_lost(sk);
2773 2774 2775 2776 2777
		if (prior_retrans > tp->retrans_out)
			*ack_flag |= FLAG_LOST_RETRANS;
	}
}

L
Linus Torvalds 已提交
2778 2779 2780 2781 2782
/* 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.
 *
2783 2784 2785
 * 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 已提交
2786 2787 2788 2789
 *
 * It does _not_ decide what to send, it is made in function
 * tcp_xmit_retransmit_queue().
 */
2790
static void tcp_fastretrans_alert(struct sock *sk, const int acked,
2791 2792
				  bool is_dupack, int *ack_flag, int *rexmit,
				  const struct skb_mstamp *ack_time)
L
Linus Torvalds 已提交
2793
{
2794
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2795
	struct tcp_sock *tp = tcp_sk(sk);
2796
	int fast_rexmit = 0, flag = *ack_flag;
Y
Yuchung Cheng 已提交
2797
	bool do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
2798
				    (tcp_fackets_out(tp) > tp->reordering));
L
Linus Torvalds 已提交
2799

2800
	if (WARN_ON(!tp->packets_out && tp->sacked_out))
L
Linus Torvalds 已提交
2801
		tp->sacked_out = 0;
I
Ilpo Järvinen 已提交
2802
	if (WARN_ON(!tp->sacked_out && tp->fackets_out))
L
Linus Torvalds 已提交
2803 2804
		tp->fackets_out = 0;

2805
	/* Now state machine starts.
L
Linus Torvalds 已提交
2806
	 * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
2807
	if (flag & FLAG_ECE)
L
Linus Torvalds 已提交
2808 2809 2810
		tp->prior_ssthresh = 0;

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

2814
	/* C. Check consistency of the current state. */
2815
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2816

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

		case TCP_CA_Recovery:
2834
			if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
2835
				tcp_reset_reno_sack(tp);
2836
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
2837
				return;
2838
			tcp_end_cwnd_reduction(sk);
L
Linus Torvalds 已提交
2839 2840 2841 2842
			break;
		}
	}

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

2877
		if (icsk->icsk_ca_state <= TCP_CA_Disorder)
2878
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
2879

2880
		tcp_rack_identify_loss(sk, ack_flag, ack_time);
2881
		if (!tcp_time_to_recover(sk, flag)) {
2882
			tcp_try_to_open(sk, flag);
L
Linus Torvalds 已提交
2883 2884 2885
			return;
		}

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

2902
	if (do_lost)
2903
		tcp_update_scoreboard(sk, fast_rexmit);
2904
	*rexmit = REXMIT_LOST;
L
Linus Torvalds 已提交
2905 2906
}

2907 2908
static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us)
{
2909 2910 2911 2912 2913
	struct tcp_sock *tp = tcp_sk(sk);
	u32 wlen = sysctl_tcp_min_rtt_wlen * HZ;

	minmax_running_min(&tp->rtt_min, wlen, tcp_time_stamp,
			   rtt_us ? : jiffies_to_usecs(1));
2914 2915
}

Y
Yuchung Cheng 已提交
2916
static inline bool tcp_ack_update_rtt(struct sock *sk, const int flag,
2917 2918
				      long seq_rtt_us, long sack_rtt_us,
				      long ca_rtt_us)
2919
{
2920 2921 2922 2923 2924 2925 2926
	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).
	 */
2927 2928
	if (seq_rtt_us < 0)
		seq_rtt_us = sack_rtt_us;
Y
Yuchung Cheng 已提交
2929

L
Linus Torvalds 已提交
2930 2931 2932 2933 2934 2935
	/* 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.
	 */
2936
	if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2937
	    flag & FLAG_ACKED)
2938 2939
		seq_rtt_us = ca_rtt_us = jiffies_to_usecs(tcp_time_stamp -
							  tp->rx_opt.rcv_tsecr);
2940
	if (seq_rtt_us < 0)
Y
Yuchung Cheng 已提交
2941
		return false;
L
Linus Torvalds 已提交
2942

2943 2944 2945 2946 2947
	/* ca_rtt_us >= 0 is counting on the invariant that ca_rtt_us is
	 * always taken together with ACK, SACK, or TS-opts. Any negative
	 * values will be skipped with the seq_rtt_us < 0 check above.
	 */
	tcp_update_rtt_min(sk, ca_rtt_us);
2948
	tcp_rtt_estimator(sk, seq_rtt_us);
2949
	tcp_set_rto(sk);
L
Linus Torvalds 已提交
2950

2951 2952
	/* RFC6298: only reset backoff on valid RTT measurement. */
	inet_csk(sk)->icsk_backoff = 0;
Y
Yuchung Cheng 已提交
2953
	return true;
L
Linus Torvalds 已提交
2954 2955
}

2956
/* Compute time elapsed between (last) SYNACK and the ACK completing 3WHS. */
Y
Yuchung Cheng 已提交
2957
void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
2958
{
Y
Yuchung Cheng 已提交
2959
	long rtt_us = -1L;
2960

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

Y
Yuchung Cheng 已提交
2964 2965 2966 2967
		skb_mstamp_get(&now);
		rtt_us = skb_mstamp_us_delta(&now, &tcp_rsk(req)->snt_synack);
	}

2968
	tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us);
2969 2970
}

Y
Yuchung Cheng 已提交
2971

2972
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
L
Linus Torvalds 已提交
2973
{
2974
	const struct inet_connection_sock *icsk = inet_csk(sk);
2975 2976

	icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
2977
	tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
L
Linus Torvalds 已提交
2978 2979 2980 2981 2982
}

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

2988 2989 2990 2991 2992 2993
	/* 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 已提交
2994
	if (!tp->packets_out) {
2995
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
2996
	} else {
2997 2998
		u32 rto = inet_csk(sk)->icsk_rto;
		/* Offset the time elapsed after installing regular RTO */
Y
Yuchung Cheng 已提交
2999
		if (icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
N
Nandita Dukkipati 已提交
3000
		    icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
3001
			struct sk_buff *skb = tcp_write_queue_head(sk);
E
Eric Dumazet 已提交
3002 3003
			const u32 rto_time_stamp =
				tcp_skb_timestamp(skb) + rto;
3004 3005
			s32 delta = (s32)(rto_time_stamp - tcp_time_stamp);
			/* delta may not be positive if the socket is locked
N
Nandita Dukkipati 已提交
3006
			 * when the retrans timer fires and is rescheduled.
3007 3008 3009 3010 3011 3012
			 */
			if (delta > 0)
				rto = delta;
		}
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS, rto,
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
3013
	}
3014 3015
}

3016
/* If we get here, the whole TSO packet has not been acked. */
3017
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
3018 3019
{
	struct tcp_sock *tp = tcp_sk(sk);
3020
	u32 packets_acked;
L
Linus Torvalds 已提交
3021

3022
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
3023 3024

	packets_acked = tcp_skb_pcount(skb);
3025
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
3026 3027 3028 3029 3030
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

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

3034
	return packets_acked;
L
Linus Torvalds 已提交
3035 3036
}

3037 3038 3039 3040 3041 3042
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 */
3043
	if (likely(!TCP_SKB_CB(skb)->txstamp_ack))
3044 3045 3046
		return;

	shinfo = skb_shinfo(skb);
3047
	if (!before(shinfo->tskey, prior_snd_una) &&
3048
	    before(shinfo->tskey, tcp_sk(sk)->snd_una))
3049 3050 3051
		__skb_tstamp_tx(skb, NULL, sk, SCM_TSTAMP_ACK);
}

3052 3053 3054 3055
/* Remove acknowledged frames from the retransmission queue. If our packet
 * is before the ack sequence we can discard it as it's confirmed to have
 * arrived at the other end.
 */
I
Ilpo Järvinen 已提交
3056
static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
3057
			       u32 prior_snd_una, int *acked,
3058
			       struct tcp_sacktag_state *sack)
L
Linus Torvalds 已提交
3059
{
3060
	const struct inet_connection_sock *icsk = inet_csk(sk);
3061
	struct skb_mstamp first_ackt, last_ackt;
3062
	struct skb_mstamp *now = &sack->ack_time;
3063 3064 3065
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_sacked = tp->sacked_out;
	u32 reord = tp->packets_out;
3066
	bool fully_acked = true;
3067
	long sack_rtt_us = -1L;
3068
	long seq_rtt_us = -1L;
3069
	long ca_rtt_us = -1L;
3070
	struct sk_buff *skb;
3071
	u32 pkts_acked = 0;
3072
	u32 last_in_flight = 0;
3073
	bool rtt_update;
3074 3075 3076
	int flag = 0;

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

3078
	while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) {
3079
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3080
		u8 sacked = scb->sacked;
3081
		u32 acked_pcount;
L
Linus Torvalds 已提交
3082

3083
		tcp_ack_tstamp(sk, skb, prior_snd_una);
3084

3085
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
3086
		if (after(scb->end_seq, tp->snd_una)) {
3087 3088 3089 3090
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

3091 3092
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
3093
				break;
E
Eric Dumazet 已提交
3094
			fully_acked = false;
3095
		} else {
3096 3097
			/* Speedup tcp_unlink_write_queue() and next loop */
			prefetchw(skb->next);
3098
			acked_pcount = tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
3099 3100
		}

3101
		if (unlikely(sacked & TCPCB_RETRANS)) {
3102
			if (sacked & TCPCB_SACKED_RETRANS)
3103
				tp->retrans_out -= acked_pcount;
3104
			flag |= FLAG_RETRANS_DATA_ACKED;
3105
		} else if (!(sacked & TCPCB_SACKED_ACKED)) {
3106
			last_ackt = skb->skb_mstamp;
E
Eric Dumazet 已提交
3107
			WARN_ON_ONCE(last_ackt.v64 == 0);
3108 3109 3110
			if (!first_ackt.v64)
				first_ackt = last_ackt;

3111
			last_in_flight = TCP_SKB_CB(skb)->tx.in_flight;
3112 3113 3114
			reord = min(pkts_acked, reord);
			if (!after(scb->end_seq, tp->high_seq))
				flag |= FLAG_ORIG_SACK_ACKED;
3115
		}
3116

Y
Yuchung Cheng 已提交
3117
		if (sacked & TCPCB_SACKED_ACKED) {
3118
			tp->sacked_out -= acked_pcount;
Y
Yuchung Cheng 已提交
3119 3120 3121
		} else if (tcp_is_sack(tp)) {
			tp->delivered += acked_pcount;
			if (!tcp_skb_spurious_retrans(tp, skb))
3122
				tcp_rack_advance(tp, sacked, scb->end_seq,
3123 3124
						 &skb->skb_mstamp,
						 &sack->ack_time);
Y
Yuchung Cheng 已提交
3125
		}
3126
		if (sacked & TCPCB_LOST)
3127
			tp->lost_out -= acked_pcount;
3128

3129 3130
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
3131
		tcp_rate_skb_delivered(sk, skb, sack->rate);
3132

3133 3134 3135 3136 3137 3138 3139
		/* 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.
		 */
3140
		if (likely(!(scb->tcp_flags & TCPHDR_SYN))) {
3141 3142 3143 3144 3145 3146
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

3147 3148 3149
		if (!fully_acked)
			break;

3150
		tcp_unlink_write_queue(skb, sk);
3151
		sk_wmem_free_skb(sk, skb);
3152
		if (unlikely(skb == tp->retransmit_skb_hint))
3153
			tp->retransmit_skb_hint = NULL;
3154
		if (unlikely(skb == tp->lost_skb_hint))
3155
			tp->lost_skb_hint = NULL;
L
Linus Torvalds 已提交
3156 3157
	}

3158 3159 3160
	if (!skb)
		tcp_chrono_stop(sk, TCP_CHRONO_BUSY);

I
Ilpo Järvinen 已提交
3161 3162 3163
	if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
		tp->snd_up = tp->snd_una;

3164 3165 3166
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

3167
	if (likely(first_ackt.v64) && !(flag & FLAG_RETRANS_DATA_ACKED)) {
3168 3169
		seq_rtt_us = skb_mstamp_us_delta(now, &first_ackt);
		ca_rtt_us = skb_mstamp_us_delta(now, &last_ackt);
3170 3171
	}
	if (sack->first_sackt.v64) {
3172 3173
		sack_rtt_us = skb_mstamp_us_delta(now, &sack->first_sackt);
		ca_rtt_us = skb_mstamp_us_delta(now, &sack->last_sackt);
3174
	}
3175
	sack->rate->rtt_us = ca_rtt_us; /* RTT of last (S)ACKed packet, or -1 */
3176 3177
	rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
					ca_rtt_us);
Y
Yuchung Cheng 已提交
3178

3179
	if (flag & FLAG_ACKED) {
3180
		tcp_rearm_rto(sk);
3181 3182 3183 3184 3185
		if (unlikely(icsk->icsk_mtup.probe_size &&
			     !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
			tcp_mtup_probe_success(sk);
		}

3186 3187 3188
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
		} else {
3189 3190
			int delta;

3191 3192 3193
			/* Non-retransmitted hole got filled? That's reordering */
			if (reord < prior_fackets)
				tcp_update_reordering(sk, tp->fackets_out - reord, 0);
3194

3195 3196 3197
			delta = tcp_is_fack(tp) ? pkts_acked :
						  prior_sacked - tp->sacked_out;
			tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3198 3199
		}

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

3202
	} else if (skb && rtt_update && sack_rtt_us >= 0 &&
3203
		   sack_rtt_us > skb_mstamp_us_delta(now, &skb->skb_mstamp)) {
3204 3205 3206 3207 3208
		/* Do not re-arm RTO if the sack RTT is measured from data sent
		 * after when the head was last (re)transmitted. Otherwise the
		 * timeout may continue to extend in loss recovery.
		 */
		tcp_rearm_rto(sk);
L
Linus Torvalds 已提交
3209 3210
	}

3211 3212
	if (icsk->icsk_ca_ops->pkts_acked) {
		struct ack_sample sample = { .pkts_acked = pkts_acked,
3213 3214
					     .rtt_us = ca_rtt_us,
					     .in_flight = last_in_flight };
3215 3216 3217

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

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

static void tcp_ack_probe(struct sock *sk)
{
3248 3249
	const struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3250 3251 3252

	/* Was it a usable window open? */

3253
	if (!after(TCP_SKB_CB(tcp_send_head(sk))->end_seq, tcp_wnd_end(tp))) {
3254 3255
		icsk->icsk_backoff = 0;
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
L
Linus Torvalds 已提交
3256 3257 3258 3259
		/* Socket must be waked up by subsequent tcp_data_snd_check().
		 * This function is not for random using!
		 */
	} else {
3260
		unsigned long when = tcp_probe0_when(sk, TCP_RTO_MAX);
3261

3262
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3263
					  when, TCP_RTO_MAX);
L
Linus Torvalds 已提交
3264 3265 3266
	}
}

3267
static inline bool tcp_ack_is_dubious(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3268
{
E
Eric Dumazet 已提交
3269 3270
	return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
		inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
L
Linus Torvalds 已提交
3271 3272
}

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

3285
	return flag & FLAG_DATA_ACKED;
L
Linus Torvalds 已提交
3286 3287
}

Y
Yuchung Cheng 已提交
3288 3289 3290 3291 3292 3293
/* 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,
3294
			     int flag, const struct rate_sample *rs)
Y
Yuchung Cheng 已提交
3295
{
3296 3297 3298 3299 3300 3301 3302
	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 已提交
3303 3304 3305 3306 3307 3308 3309 3310 3311 3312
	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 已提交
3313 3314 3315
/* Check that window update is acceptable.
 * The function assumes that snd_una<=ack<=snd_next.
 */
3316
static inline bool tcp_may_update_window(const struct tcp_sock *tp,
3317 3318
					const u32 ack, const u32 ack_seq,
					const u32 nwin)
L
Linus Torvalds 已提交
3319
{
E
Eric Dumazet 已提交
3320
	return	after(ack, tp->snd_una) ||
L
Linus Torvalds 已提交
3321
		after(ack_seq, tp->snd_wl1) ||
E
Eric Dumazet 已提交
3322
		(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);
L
Linus Torvalds 已提交
3323 3324
}

3325 3326 3327 3328 3329
/* 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;

3330
	sock_owned_by_me((struct sock *)tp);
3331 3332 3333 3334
	tp->bytes_acked += delta;
	tp->snd_una = ack;
}

3335 3336 3337 3338 3339
/* 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;

3340
	sock_owned_by_me((struct sock *)tp);
3341 3342 3343 3344
	tp->bytes_received += delta;
	tp->rcv_nxt = seq;
}

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

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

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

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

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

3373 3374 3375
			if (tcp_send_head(sk))
				tcp_slow_start_after_idle_check(sk);

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

3383
	tcp_snd_una_update(tp, ack);
L
Linus Torvalds 已提交
3384 3385 3386 3387

	return flag;
}

3388 3389 3390 3391 3392 3393 3394 3395 3396 3397 3398 3399 3400 3401 3402 3403 3404
static bool __tcp_oow_rate_limited(struct net *net, int mib_idx,
				   u32 *last_oow_ack_time)
{
	if (*last_oow_ack_time) {
		s32 elapsed = (s32)(tcp_time_stamp - *last_oow_ack_time);

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

	*last_oow_ack_time = tcp_time_stamp;

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

3405 3406 3407 3408 3409 3410 3411 3412 3413 3414 3415 3416 3417
/* 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)
3418
		return false;
3419

3420
	return __tcp_oow_rate_limited(net, mib_idx, last_oow_ack_time);
3421 3422
}

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

	/* First check our per-socket dupack rate limit. */
3433 3434 3435
	if (__tcp_oow_rate_limited(sock_net(sk),
				   LINUX_MIB_TCPACKSKIPPEDCHALLENGE,
				   &tp->last_oow_ack_time))
3436
		return;
3437

3438
	/* Then check host-wide RFC 5961 rate limit. */
3439
	now = jiffies / HZ;
3440
	if (now != challenge_timestamp) {
3441 3442
		u32 half = (sysctl_tcp_challenge_ack_limit + 1) >> 1;

3443
		challenge_timestamp = now;
3444 3445
		WRITE_ONCE(challenge_count, half +
			   prandom_u32_max(sysctl_tcp_challenge_ack_limit));
3446
	}
3447 3448 3449
	count = READ_ONCE(challenge_count);
	if (count > 0) {
		WRITE_ONCE(challenge_count, count - 1);
3450
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPCHALLENGEACK);
3451 3452 3453 3454
		tcp_send_ack(sk);
	}
}

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

3485
	if (before(ack, tp->tlp_high_seq))
N
Nandita Dukkipati 已提交
3486 3487
		return;

3488 3489 3490 3491 3492 3493 3494 3495 3496 3497 3498
	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);
3499
		NET_INC_STATS(sock_net(sk),
3500
				LINUX_MIB_TCPLOSSPROBERECOVERY);
3501 3502 3503
	} 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 已提交
3504 3505 3506 3507
		tp->tlp_high_seq = 0;
	}
}

3508 3509 3510 3511 3512 3513 3514 3515
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);
}

3516 3517 3518 3519 3520 3521 3522 3523 3524 3525 3526 3527 3528 3529 3530 3531 3532 3533 3534 3535 3536
/* 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 已提交
3537
/* This routine deals with incoming acks, but not outgoing ones. */
3538
static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
L
Linus Torvalds 已提交
3539
{
3540
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3541
	struct tcp_sock *tp = tcp_sk(sk);
3542
	struct tcp_sacktag_state sack_state;
3543
	struct rate_sample rs = { .prior_delivered = 0 };
L
Linus Torvalds 已提交
3544 3545 3546
	u32 prior_snd_una = tp->snd_una;
	u32 ack_seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;
3547
	bool is_dupack = false;
3548
	u32 prior_fackets;
3549
	int prior_packets = tp->packets_out;
3550 3551
	u32 delivered = tp->delivered;
	u32 lost = tp->lost;
3552
	int acked = 0; /* Number of packets newly acked */
3553
	int rexmit = REXMIT_NONE; /* Flag to (re)transmit to recover losses */
3554

3555
	sack_state.first_sackt.v64 = 0;
3556
	sack_state.rate = &rs;
L
Linus Torvalds 已提交
3557

3558 3559 3560
	/* We very likely will need to access write queue head. */
	prefetchw(sk->sk_write_queue.next);

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

3573 3574 3575 3576 3577 3578
	/* 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;

3579
	skb_mstamp_get(&sack_state.ack_time);
3580

Y
Yuchung Cheng 已提交
3581
	if (icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)
3582 3583
		tcp_rearm_rto(sk);

3584
	if (after(ack, prior_snd_una)) {
3585
		flag |= FLAG_SND_UNA_ADVANCED;
3586 3587
		icsk->icsk_retransmits = 0;
	}
3588

3589
	prior_fackets = tp->fackets_out;
3590
	rs.prior_in_flight = tcp_packets_in_flight(tp);
3591

3592 3593 3594 3595 3596 3597
	/* 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);

3598
	if (!(flag & FLAG_SLOWPATH) && after(ack, prior_snd_una)) {
L
Linus Torvalds 已提交
3599 3600 3601 3602
		/* Window is constant, pure forward advance.
		 * No more checks are required.
		 * Note, we use the fact that SND.UNA>=SND.WL2.
		 */
3603
		tcp_update_wl(tp, ack_seq);
3604
		tcp_snd_una_update(tp, ack);
L
Linus Torvalds 已提交
3605 3606
		flag |= FLAG_WIN_UPDATE;

3607
		tcp_in_ack_event(sk, CA_ACK_WIN_UPDATE);
3608

3609
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPACKS);
L
Linus Torvalds 已提交
3610
	} else {
3611 3612
		u32 ack_ev_flags = CA_ACK_SLOWPATH;

L
Linus Torvalds 已提交
3613 3614 3615
		if (ack_seq != TCP_SKB_CB(skb)->end_seq)
			flag |= FLAG_DATA;
		else
3616
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPUREACKS);
L
Linus Torvalds 已提交
3617

3618
		flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);
L
Linus Torvalds 已提交
3619 3620

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

3624
		if (tcp_ecn_rcv_ecn_echo(tp, tcp_hdr(skb))) {
L
Linus Torvalds 已提交
3625
			flag |= FLAG_ECE;
3626 3627 3628 3629 3630
			ack_ev_flags |= CA_ACK_ECE;
		}

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

3632
		tcp_in_ack_event(sk, ack_ev_flags);
L
Linus Torvalds 已提交
3633 3634 3635 3636 3637 3638
	}

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

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

3648
	if (tcp_ack_is_dubious(sk, flag)) {
3649
		is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
3650 3651
		tcp_fastretrans_alert(sk, acked, is_dupack, &flag, &rexmit,
				      &sack_state.ack_time);
L
Linus Torvalds 已提交
3652
	}
N
Nandita Dukkipati 已提交
3653 3654 3655
	if (tp->tlp_high_seq)
		tcp_process_tlp_ack(sk, ack, flag);

3656 3657
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
		sk_dst_confirm(sk);
N
Nandita Dukkipati 已提交
3658 3659 3660

	if (icsk->icsk_pending == ICSK_TIME_RETRANS)
		tcp_schedule_loss_probe(sk);
3661 3662
	delivered = tp->delivered - delivered;	/* freshly ACKed or SACKed */
	lost = tp->lost - lost;			/* freshly marked lost */
3663 3664 3665
	tcp_rate_gen(sk, delivered, lost, &sack_state.ack_time,
		     sack_state.rate);
	tcp_cong_control(sk, ack, delivered, flag, sack_state.rate);
3666
	tcp_xmit_recovery(sk, rexmit);
L
Linus Torvalds 已提交
3667 3668 3669
	return 1;

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

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

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

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

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

3706 3707 3708 3709 3710 3711 3712 3713 3714 3715 3716 3717 3718 3719 3720 3721 3722
static void tcp_parse_fastopen_option(int len, const unsigned char *cookie,
				      bool syn, struct tcp_fastopen_cookie *foc,
				      bool exp_opt)
{
	/* Valid only in SYN or SYN-ACK with an even length.  */
	if (!foc || !syn || len < 0 || (len & 1))
		return;

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

L
Linus Torvalds 已提交
3723 3724 3725 3726
/* Look for tcp options. Normally only called on SYN and SYNACK packets.
 * But, this can also be called on packets in the established flow when
 * the fast version below fails.
 */
C
Christoph Paasch 已提交
3727 3728
void tcp_parse_options(const struct sk_buff *skb,
		       struct tcp_options_received *opt_rx, int estab,
Y
Yuchung Cheng 已提交
3729
		       struct tcp_fastopen_cookie *foc)
L
Linus Torvalds 已提交
3730
{
3731 3732
	const unsigned char *ptr;
	const struct tcphdr *th = tcp_hdr(skb);
3733
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3734

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

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

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

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

Y
Yuchung Cheng 已提交
3819 3820
			case TCPOPT_EXP:
				/* Fast Open option shares code 254 using a
3821
				 * 16 bits magic number.
Y
Yuchung Cheng 已提交
3822
				 */
3823 3824 3825 3826 3827 3828
				if (opsize >= TCPOLEN_EXP_FASTOPEN_BASE &&
				    get_unaligned_be16(ptr) ==
				    TCPOPT_FASTOPEN_MAGIC)
					tcp_parse_fastopen_option(opsize -
						TCPOLEN_EXP_FASTOPEN_BASE,
						ptr + 2, th->syn, foc, true);
Y
Yuchung Cheng 已提交
3829 3830 3831
				break;

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

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

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

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

C
Christoph Paasch 已提交
3876
	tcp_parse_options(skb, &tp->rx_opt, 1, NULL);
3877
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
3878 3879
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;

E
Eric Dumazet 已提交
3880
	return true;
L
Linus Torvalds 已提交
3881 3882
}

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

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

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

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

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

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

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

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

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

4011 4012
	tcp_done(sk);

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

4035
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4036 4037 4038 4039 4040

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

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

4048 4049 4050 4051 4052 4053 4054 4055 4056
	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 已提交
4057

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

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

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

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

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

4117
	if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
4118 4119
		int mib_idx;

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

4125
		NET_INC_STATS(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
4126 4127 4128 4129 4130 4131 4132

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

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

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

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

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

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

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

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

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

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

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

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

	*fragstolen = false;

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

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

	atomic_add(delta, &sk->sk_rmem_alloc);
	sk_mem_charge(sk, delta);
4299
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
4300 4301 4302 4303 4304 4305
	TCP_SKB_CB(to)->end_seq = TCP_SKB_CB(from)->end_seq;
	TCP_SKB_CB(to)->ack_seq = TCP_SKB_CB(from)->ack_seq;
	TCP_SKB_CB(to)->tcp_flags |= TCP_SKB_CB(from)->tcp_flags;
	return true;
}

4306 4307 4308 4309 4310 4311
static void tcp_drop(struct sock *sk, struct sk_buff *skb)
{
	sk_drops_add(sk, skb);
	__kfree_skb(skb);
}

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

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

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

4347 4348
		tail = skb_peek_tail(&sk->sk_receive_queue);
		eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
4349
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
4350
		fin = TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN;
4351 4352
		if (!eaten)
			__skb_queue_tail(&sk->sk_receive_queue, skb);
4353
		else
4354
			kfree_skb_partial(skb, fragstolen);
4355 4356 4357 4358 4359 4360 4361 4362

		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 已提交
4363 4364 4365
	}
}

E
Eric Dumazet 已提交
4366
static bool tcp_prune_ofo_queue(struct sock *sk);
L
Linus Torvalds 已提交
4367 4368
static int tcp_prune_queue(struct sock *sk);

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

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

4378
		while (!sk_rmem_schedule(sk, skb, size)) {
4379 4380
			if (!tcp_prune_ofo_queue(sk))
				return -1;
4381 4382 4383 4384 4385
		}
	}
	return 0;
}

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

4394
	tcp_ecn_check_ce(tp, skb);
E
Eric Dumazet 已提交
4395

4396
	if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
4397
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
4398
		tcp_drop(sk, skb);
E
Eric Dumazet 已提交
4399 4400 4401 4402 4403 4404 4405
		return;
	}

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

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

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

4426 4427 4428 4429 4430 4431 4432 4433 4434 4435
	/* 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.
	 */
	if (tcp_try_coalesce(sk, tp->ooo_last_skb, skb, &fragstolen)) {
coalesce_done:
		tcp_grow_window(sk, skb);
		kfree_skb_partial(skb, fragstolen);
		skb = NULL;
		goto add_sack;
	}
4436 4437 4438 4439 4440 4441
	/* 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;
	}
4442 4443 4444 4445 4446 4447 4448 4449 4450

	/* Find place to insert this segment. Handle overlaps on the way. */
	parent = NULL;
	while (*p) {
		parent = *p;
		skb1 = rb_entry(parent, struct sk_buff, rbnode);
		if (before(seq, TCP_SKB_CB(skb1)->seq)) {
			p = &parent->rb_left;
			continue;
E
Eric Dumazet 已提交
4451
		}
4452 4453 4454 4455 4456 4457 4458 4459 4460 4461 4462 4463 4464 4465 4466 4467 4468 4469 4470 4471 4472 4473 4474 4475 4476
		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);
4477
				goto merge_right;
4478 4479 4480
			}
		} else if (tcp_try_coalesce(sk, skb1, skb, &fragstolen)) {
			goto coalesce_done;
E
Eric Dumazet 已提交
4481
		}
4482
		p = &parent->rb_right;
E
Eric Dumazet 已提交
4483
	}
4484
insert:
4485 4486 4487
	/* 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 已提交
4488

4489
merge_right:
4490 4491 4492
	/* Remove other segments covered by skb. */
	while ((q = rb_next(&skb->rbnode)) != NULL) {
		skb1 = rb_entry(q, struct sk_buff, rbnode);
E
Eric Dumazet 已提交
4493 4494 4495 4496 4497 4498 4499 4500

		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;
		}
4501
		rb_erase(&skb1->rbnode, &tp->out_of_order_queue);
E
Eric Dumazet 已提交
4502 4503
		tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
				 TCP_SKB_CB(skb1)->end_seq);
4504
		NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
4505
		tcp_drop(sk, skb1);
E
Eric Dumazet 已提交
4506
	}
4507 4508 4509
	/* If there is no skb after us, we are the last_skb ! */
	if (!q)
		tp->ooo_last_skb = skb;
E
Eric Dumazet 已提交
4510 4511 4512 4513 4514

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

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

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

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

4546 4547 4548
	if (size == 0)
		return 0;

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

4561 4562 4563 4564
	skb_put(skb, size - data_len);
	skb->data_len = data_len;
	skb->len = size;

4565
	if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
4566 4567
		goto err_free;

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

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

err_free:
	kfree_skb(skb);
err:
4585 4586
	return err;

4587 4588
}

L
Linus Torvalds 已提交
4589 4590 4591
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
	struct tcp_sock *tp = tcp_sk(sk);
4592
	bool fragstolen = false;
4593
	int eaten = -1;
L
Linus Torvalds 已提交
4594

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

4602
	tcp_ecn_accept_cwr(tp, skb);
L
Linus Torvalds 已提交
4603

4604
	tp->rx_opt.dsack = 0;
L
Linus Torvalds 已提交
4605 4606 4607 4608 4609 4610 4611 4612 4613 4614 4615 4616 4617 4618

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

		/* Ok. In sequence. In window. */
		if (tp->ucopy.task == current &&
		    tp->copied_seq == tp->rcv_nxt && tp->ucopy.len &&
		    sock_owned_by_user(sk) && !tp->urg_data) {
			int chunk = min_t(unsigned int, skb->len,
4619
					  tp->ucopy.len);
L
Linus Torvalds 已提交
4620 4621 4622

			__set_current_state(TASK_RUNNING);

4623
			if (!skb_copy_datagram_msg(skb, 0, tp->ucopy.msg, chunk)) {
L
Linus Torvalds 已提交
4624 4625
				tp->ucopy.len -= chunk;
				tp->copied_seq += chunk;
4626
				eaten = (chunk == skb->len);
L
Linus Torvalds 已提交
4627 4628 4629 4630 4631 4632
				tcp_rcv_space_adjust(sk);
			}
		}

		if (eaten <= 0) {
queue_and_out:
4633 4634 4635 4636 4637 4638
			if (eaten < 0) {
				if (skb_queue_len(&sk->sk_receive_queue) == 0)
					sk_forced_mem_schedule(sk, skb->truesize);
				else if (tcp_try_rmem_schedule(sk, skb, skb->truesize))
					goto drop;
			}
4639
			eaten = tcp_queue_rcv(sk, skb, 0, &fragstolen);
L
Linus Torvalds 已提交
4640
		}
4641
		tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
S
Stephen Hemminger 已提交
4642
		if (skb->len)
4643
			tcp_event_data_recv(sk, skb);
4644
		if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
4645
			tcp_fin(sk);
L
Linus Torvalds 已提交
4646

4647
		if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4648 4649 4650 4651 4652
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
4653
			if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4654
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
4655 4656 4657 4658 4659
		}

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

4660
		tcp_fast_path_check(sk);
L
Linus Torvalds 已提交
4661

4662 4663
		if (eaten > 0)
			kfree_skb_partial(skb, fragstolen);
4664
		if (!sock_flag(sk, SOCK_DEAD))
4665
			sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
4666 4667 4668 4669 4670
		return;
	}

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

out_of_window:
4675 4676
		tcp_enter_quickack_mode(sk);
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4677
drop:
4678
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
4679 4680 4681 4682 4683 4684 4685
		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;

4686
	tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4687 4688 4689 4690 4691 4692 4693

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

4694
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
4695

L
Linus Torvalds 已提交
4696 4697 4698 4699 4700 4701 4702 4703
		/* 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 已提交
4704
	tcp_data_queue_ofo(sk, skb);
L
Linus Torvalds 已提交
4705 4706
}

4707 4708 4709 4710 4711 4712 4713 4714
static struct sk_buff *tcp_skb_next(struct sk_buff *skb, struct sk_buff_head *list)
{
	if (list)
		return !skb_queue_is_last(list, skb) ? skb->next : NULL;

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

4715
static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
4716 4717
					struct sk_buff_head *list,
					struct rb_root *root)
4718
{
4719
	struct sk_buff *next = tcp_skb_next(skb, list);
4720

4721 4722 4723 4724
	if (list)
		__skb_unlink(skb, list);
	else
		rb_erase(&skb->rbnode, root);
4725 4726

	__kfree_skb(skb);
4727
	NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
4728 4729 4730 4731

	return next;
}

4732 4733 4734 4735 4736 4737 4738 4739 4740 4741 4742 4743 4744 4745 4746 4747 4748 4749 4750
/* Insert skb into rb tree, ordered by TCP_SKB_CB(skb)->seq */
static void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb)
{
	struct rb_node **p = &root->rb_node;
	struct rb_node *parent = NULL;
	struct sk_buff *skb1;

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

L
Linus Torvalds 已提交
4751 4752
/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
4753
 *
4754
 * If tail is NULL, this means until the end of the queue.
4755
 *
L
Linus Torvalds 已提交
4756 4757 4758 4759
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
4760 4761
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 已提交
4762
{
4763 4764
	struct sk_buff *skb = head, *n;
	struct sk_buff_head tmp;
4765
	bool end_of_skbs;
L
Linus Torvalds 已提交
4766

S
Stephen Hemminger 已提交
4767
	/* First, check that queue is collapsible and find
4768 4769
	 * the point where collapsing can be useful.
	 */
4770
restart:
4771 4772 4773
	for (end_of_skbs = true; skb != NULL && skb != tail; skb = n) {
		n = tcp_skb_next(skb, list);

L
Linus Torvalds 已提交
4774 4775
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
4776
			skb = tcp_collapse_one(sk, skb, list, root);
4777 4778 4779
			if (!skb)
				break;
			goto restart;
L
Linus Torvalds 已提交
4780 4781 4782 4783 4784 4785 4786
		}

		/* The first skb to collapse is:
		 * - not SYN/FIN and
		 * - bloated or contains data before "start" or
		 *   overlaps to the next one.
		 */
4787
		if (!(TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)) &&
L
Linus Torvalds 已提交
4788
		    (tcp_win_from_space(skb->truesize) > skb->len ||
4789 4790
		     before(TCP_SKB_CB(skb)->seq, start))) {
			end_of_skbs = false;
L
Linus Torvalds 已提交
4791
			break;
4792 4793
		}

4794 4795 4796 4797
		if (n && n != tail &&
		    TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(n)->seq) {
			end_of_skbs = false;
			break;
4798
		}
L
Linus Torvalds 已提交
4799 4800 4801 4802

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

4807 4808
	__skb_queue_head_init(&tmp);

L
Linus Torvalds 已提交
4809
	while (before(start, end)) {
4810
		int copy = min_t(int, SKB_MAX_ORDER(0, 0), end - start);
L
Linus Torvalds 已提交
4811 4812
		struct sk_buff *nskb;

4813
		nskb = alloc_skb(copy, GFP_ATOMIC);
L
Linus Torvalds 已提交
4814
		if (!nskb)
4815
			break;
4816

L
Linus Torvalds 已提交
4817 4818
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
4819 4820 4821 4822
		if (list)
			__skb_queue_before(list, skb, nskb);
		else
			__skb_queue_tail(&tmp, nskb); /* defer rbtree insertion */
4823
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4824 4825 4826 4827 4828 4829

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

4830
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4831 4832 4833 4834 4835 4836 4837 4838 4839
			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)) {
4840
				skb = tcp_collapse_one(sk, skb, list, root);
4841 4842
				if (!skb ||
				    skb == tail ||
4843
				    (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
4844
					goto end;
L
Linus Torvalds 已提交
4845 4846 4847
			}
		}
	}
4848 4849 4850
end:
	skb_queue_walk_safe(&tmp, skb, n)
		tcp_rbtree_insert(root, skb);
L
Linus Torvalds 已提交
4851 4852 4853 4854 4855 4856 4857 4858
}

/* 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);
4859 4860
	struct sk_buff *skb, *head;
	struct rb_node *p;
L
Linus Torvalds 已提交
4861 4862
	u32 start, end;

4863 4864 4865 4866 4867 4868 4869 4870 4871 4872
	p = rb_first(&tp->out_of_order_queue);
	skb = rb_entry_safe(p, struct sk_buff, rbnode);
new_range:
	if (!skb) {
		p = rb_last(&tp->out_of_order_queue);
		/* Note: This is possible p is NULL here. We do not
		 * use rb_entry_safe(), as ooo_last_skb is valid only
		 * if rbtree is not empty.
		 */
		tp->ooo_last_skb = rb_entry(p, struct sk_buff, rbnode);
L
Linus Torvalds 已提交
4873
		return;
4874
	}
L
Linus Torvalds 已提交
4875 4876
	start = TCP_SKB_CB(skb)->seq;
	end = TCP_SKB_CB(skb)->end_seq;
4877

4878 4879
	for (head = skb;;) {
		skb = tcp_skb_next(skb, NULL);
L
Linus Torvalds 已提交
4880

4881 4882 4883
		/* Range is terminated when we see a gap or when
		 * we are at the queue end.
		 */
4884
		if (!skb ||
L
Linus Torvalds 已提交
4885 4886
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
4887
			tcp_collapse(sk, NULL, &tp->out_of_order_queue,
D
David S. Miller 已提交
4888
				     head, skb, start, end);
4889 4890 4891 4892
			goto new_range;
		}

		if (unlikely(before(TCP_SKB_CB(skb)->seq, start)))
L
Linus Torvalds 已提交
4893
			start = TCP_SKB_CB(skb)->seq;
4894
		if (after(TCP_SKB_CB(skb)->end_seq, end))
L
Linus Torvalds 已提交
4895 4896 4897 4898
			end = TCP_SKB_CB(skb)->end_seq;
	}
}

4899
/*
4900 4901 4902 4903 4904 4905 4906 4907
 * 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.
4908
 */
E
Eric Dumazet 已提交
4909
static bool tcp_prune_ofo_queue(struct sock *sk)
4910 4911
{
	struct tcp_sock *tp = tcp_sk(sk);
4912
	struct rb_node *node, *prev;
4913

4914
	if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
4915
		return false;
4916

4917
	NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
4918 4919 4920 4921 4922
	node = &tp->ooo_last_skb->rbnode;
	do {
		prev = rb_prev(node);
		rb_erase(node, &tp->out_of_order_queue);
		tcp_drop(sk, rb_entry(node, struct sk_buff, rbnode));
4923
		sk_mem_reclaim(sk);
4924 4925 4926
		if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
		    !tcp_under_memory_pressure(sk))
			break;
4927 4928 4929
		node = prev;
	} while (node);
	tp->ooo_last_skb = rb_entry(prev, struct sk_buff, rbnode);
4930 4931 4932 4933 4934 4935 4936 4937 4938

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

L
Linus Torvalds 已提交
4941 4942 4943 4944 4945 4946 4947 4948 4949
/* 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)
{
4950
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
4951 4952 4953

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

4954
	NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
L
Linus Torvalds 已提交
4955 4956

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
4957
		tcp_clamp_window(sk);
4958
	else if (tcp_under_memory_pressure(sk))
L
Linus Torvalds 已提交
4959 4960 4961
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

	tcp_collapse_ofo_queue(sk);
4962
	if (!skb_queue_empty(&sk->sk_receive_queue))
4963
		tcp_collapse(sk, &sk->sk_receive_queue, NULL,
4964 4965 4966
			     skb_peek(&sk->sk_receive_queue),
			     NULL,
			     tp->copied_seq, tp->rcv_nxt);
4967
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4968 4969 4970 4971 4972 4973 4974

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

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

4975
	tcp_prune_ofo_queue(sk);
L
Linus Torvalds 已提交
4976 4977 4978 4979 4980 4981 4982 4983

	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.
	 */
4984
	NET_INC_STATS(sock_net(sk), LINUX_MIB_RCVPRUNED);
L
Linus Torvalds 已提交
4985 4986 4987 4988 4989 4990

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

E
Eric Dumazet 已提交
4991
static bool tcp_should_expand_sndbuf(const struct sock *sk)
4992
{
4993
	const struct tcp_sock *tp = tcp_sk(sk);
4994

4995 4996 4997 4998
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
E
Eric Dumazet 已提交
4999
		return false;
5000 5001

	/* If we are under global TCP memory pressure, do not expand.  */
5002
	if (tcp_under_memory_pressure(sk))
E
Eric Dumazet 已提交
5003
		return false;
5004 5005

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

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

E
Eric Dumazet 已提交
5013
	return true;
5014
}
L
Linus Torvalds 已提交
5015 5016 5017 5018 5019 5020 5021 5022 5023 5024 5025

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

5026
	if (tcp_should_expand_sndbuf(sk)) {
E
Eric Dumazet 已提交
5027
		tcp_sndbuf_expand(sk);
L
Linus Torvalds 已提交
5028 5029 5030 5031 5032 5033
		tp->snd_cwnd_stamp = tcp_time_stamp;
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
5034
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
5035 5036 5037
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
5038
		/* pairs with tcp_poll() */
5039
		smp_mb();
L
Linus Torvalds 已提交
5040
		if (sk->sk_socket &&
5041
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
L
Linus Torvalds 已提交
5042
			tcp_new_space(sk);
5043 5044 5045
			if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
				tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
		}
L
Linus Torvalds 已提交
5046 5047 5048
	}
}

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

S
Stephen Hemminger 已提交
5080
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
5081
{
5082
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
5083 5084 5085 5086 5087 5088 5089 5090
		/* 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 已提交
5091
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
5092 5093 5094 5095 5096 5097
 *	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).
 */
5098

5099
static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
L
Linus Torvalds 已提交
5100 5101 5102 5103 5104 5105 5106 5107 5108 5109 5110 5111 5112 5113 5114 5115 5116 5117 5118 5119 5120 5121 5122 5123 5124 5125 5126 5127 5128 5129 5130 5131 5132 5133 5134 5135
{
	struct tcp_sock *tp = tcp_sk(sk);
	u32 ptr = ntohs(th->urg_ptr);

	if (ptr && !sysctl_tcp_stdurg)
		ptr--;
	ptr += ntohl(th->seq);

	/* Ignore urgent data that we've already seen and read. */
	if (after(tp->copied_seq, ptr))
		return;

	/* Do not replay urg ptr.
	 *
	 * NOTE: interesting situation not covered by specs.
	 * Misbehaving sender may send urg ptr, pointing to segment,
	 * which we already have in ofo queue. We are not able to fetch
	 * such data and will stay in TCP_URG_NOTYET until will be eaten
	 * by recvmsg(). Seems, we are not obliged to handle such wicked
	 * situations. But it is worth to think about possibility of some
	 * DoSes using some hypothetical application level deadlock.
	 */
	if (before(ptr, tp->rcv_nxt))
		return;

	/* Do we already have a newer (or duplicate) urgent pointer? */
	if (tp->urg_data && !after(ptr, tp->urg_seq))
		return;

	/* Tell the world about our new urgent pointer. */
	sk_send_sigurg(sk);

	/* We may be adding urgent data when the last byte read was
	 * urgent. To do this requires some care. We cannot just ignore
	 * tp->copied_seq since we would read the last urgent byte again
	 * as data, nor can we alter copied_seq until this data arrives
S
Stephen Hemminger 已提交
5136
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
5137 5138 5139 5140 5141 5142 5143 5144 5145 5146 5147
	 *
	 * 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 &&
5148
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
5149 5150 5151
		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 已提交
5152
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
5153 5154 5155 5156
			__kfree_skb(skb);
		}
	}

5157 5158
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
L
Linus Torvalds 已提交
5159 5160 5161 5162 5163 5164

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

/* This is the 'fast' part of urgent handling. */
5165
static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
L
Linus Torvalds 已提交
5166 5167 5168 5169 5170
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
5171
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
5172 5173 5174 5175 5176 5177

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

5178
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
5179 5180 5181 5182 5183 5184
		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))
5185
				sk->sk_data_ready(sk);
L
Linus Torvalds 已提交
5186 5187 5188 5189 5190 5191 5192 5193 5194 5195
		}
	}
}

static int tcp_copy_to_iovec(struct sock *sk, struct sk_buff *skb, int hlen)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int chunk = skb->len - hlen;
	int err;

5196
	if (skb_csum_unnecessary(skb))
5197
		err = skb_copy_datagram_msg(skb, hlen, tp->ucopy.msg, chunk);
L
Linus Torvalds 已提交
5198
	else
5199
		err = skb_copy_and_csum_datagram_msg(skb, hlen, tp->ucopy.msg);
L
Linus Torvalds 已提交
5200 5201 5202 5203 5204 5205 5206 5207 5208 5209

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

	return err;
}

5210 5211 5212 5213 5214 5215 5216 5217 5218 5219 5220 5221 5222 5223 5224 5225 5226
/* 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));
}

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

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

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

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

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

E
Eric Dumazet 已提交
5330
	return true;
5331 5332

discard:
5333
	tcp_drop(sk, skb);
E
Eric Dumazet 已提交
5334
	return false;
5335 5336
}

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

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

	tp->rx_opt.saw_tstamp = 0;

	/*	pred_flags is 0xS?10 << 16 + snd_wnd
S
Stephen Hemminger 已提交
5386
	 *	if header_prediction is to be made
L
Linus Torvalds 已提交
5387 5388
	 *	'S' will always be tp->tcp_header_len >> 2
	 *	'?' will be 0 for the fast path, otherwise pred_flags is 0 to
5389
	 *  turn it off	(when there are holes in the receive
L
Linus Torvalds 已提交
5390 5391 5392 5393 5394
	 *	 space for instance)
	 *	PSH flag is ignored.
	 */

	if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
5395 5396
	    TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
	    !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
L
Linus Torvalds 已提交
5397 5398 5399 5400 5401 5402 5403 5404 5405 5406
		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! */
5407
			if (!tcp_parse_aligned_timestamp(tp, th))
L
Linus Torvalds 已提交
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
				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);
5437
				__kfree_skb(skb);
5438
				tcp_data_snd_check(sk);
5439
				return;
L
Linus Torvalds 已提交
5440
			} else { /* Header too small */
5441
				TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5442 5443 5444 5445
				goto discard;
			}
		} else {
			int eaten = 0;
5446
			bool fragstolen = false;
L
Linus Torvalds 已提交
5447

D
Dan Williams 已提交
5448 5449 5450 5451 5452
			if (tp->ucopy.task == current &&
			    tp->copied_seq == tp->rcv_nxt &&
			    len - tcp_header_len <= tp->ucopy.len &&
			    sock_owned_by_user(sk)) {
				__set_current_state(TASK_RUNNING);
L
Linus Torvalds 已提交
5453

D
Dan Williams 已提交
5454
				if (!tcp_copy_to_iovec(sk, skb, tcp_header_len)) {
L
Linus Torvalds 已提交
5455 5456 5457 5458 5459 5460 5461 5462 5463 5464
					/* 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);

5465
					tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5466 5467

					__skb_pull(skb, tcp_header_len);
5468
					tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
5469
					NET_INC_STATS(sock_net(sk),
5470
							LINUX_MIB_TCPHPHITSTOUSER);
D
Dan Williams 已提交
5471
					eaten = 1;
L
Linus Torvalds 已提交
5472 5473 5474
				}
			}
			if (!eaten) {
5475
				if (tcp_checksum_complete(skb))
L
Linus Torvalds 已提交
5476 5477
					goto csum_error;

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

L
Linus Torvalds 已提交
5481 5482 5483 5484 5485 5486 5487 5488 5489
				/* 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);

5490
				tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5491

5492
				NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPHITS);
L
Linus Torvalds 已提交
5493 5494

				/* Bulk data transfer: receiver */
5495 5496
				eaten = tcp_queue_rcv(sk, skb, tcp_header_len,
						      &fragstolen);
L
Linus Torvalds 已提交
5497 5498
			}

5499
			tcp_event_data_recv(sk, skb);
L
Linus Torvalds 已提交
5500 5501 5502 5503

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

D
Dan Williams 已提交
5509
			__tcp_ack_snd_check(sk, 0);
L
Linus Torvalds 已提交
5510 5511
no_ack:
			if (eaten)
5512
				kfree_skb_partial(skb, fragstolen);
5513
			sk->sk_data_ready(sk);
5514
			return;
L
Linus Torvalds 已提交
5515 5516 5517 5518
		}
	}

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

5522
	if (!th->ack && !th->rst && !th->syn)
5523 5524
		goto discard;

L
Linus Torvalds 已提交
5525 5526 5527 5528
	/*
	 *	Standard slow path.
	 */

E
Eric Dumazet 已提交
5529
	if (!tcp_validate_incoming(sk, skb, th, 1))
5530
		return;
L
Linus Torvalds 已提交
5531 5532

step5:
5533
	if (tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT) < 0)
5534
		goto discard;
L
Linus Torvalds 已提交
5535

5536
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5537 5538 5539 5540 5541 5542 5543

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

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

5544
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5545
	tcp_ack_snd_check(sk);
5546
	return;
L
Linus Torvalds 已提交
5547 5548

csum_error:
5549 5550
	TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
	TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5551 5552

discard:
5553
	tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5554
}
E
Eric Dumazet 已提交
5555
EXPORT_SYMBOL(tcp_rcv_established);
L
Linus Torvalds 已提交
5556

P
Pavel Emelyanov 已提交
5557 5558 5559 5560 5561 5562
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);
5563
	icsk->icsk_ack.lrcvtime = tcp_time_stamp;
P
Pavel Emelyanov 已提交
5564

5565
	if (skb) {
E
Eric Dumazet 已提交
5566
		icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
P
Pavel Emelyanov 已提交
5567
		security_inet_conn_established(sk, skb);
D
David S. Miller 已提交
5568
	}
P
Pavel Emelyanov 已提交
5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583 5584 5585 5586 5587 5588 5589 5590 5591 5592 5593

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

	tcp_init_metrics(sk);

	tcp_init_congestion_control(sk);

	/* Prevent spurious tcp_cwnd_restart() on first data
	 * packet.
	 */
	tp->lsndtime = tcp_time_stamp;

	tcp_init_buffer_space(sk);

	if (sock_flag(sk, SOCK_KEEPOPEN))
		inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));

	if (!tp->rx_opt.snd_wscale)
		__tcp_fast_path_on(tp, tp->snd_wnd);
	else
		tp->pred_flags = 0;

}

5594 5595 5596 5597
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);
5598
	struct sk_buff *data = tp->syn_data ? tcp_write_queue_head(sk) : NULL;
5599 5600
	u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
	bool syn_drop = false;
5601 5602 5603 5604 5605 5606 5607

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

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

5612 5613
	if (!tp->syn_fastopen) {
		/* Ignore an unsolicited cookie */
5614
		cookie->len = -1;
5615 5616 5617 5618 5619 5620 5621 5622 5623 5624 5625 5626 5627 5628
	} 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;
	}
5629

5630
	tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
5631 5632

	if (data) { /* Retransmit unacked data in SYN */
5633 5634
		tcp_for_write_queue_from(data, sk) {
			if (data == tcp_send_head(sk) ||
5635
			    __tcp_retransmit_skb(sk, data, 1))
5636 5637
				break;
		}
5638
		tcp_rearm_rto(sk);
5639
		NET_INC_STATS(sock_net(sk),
5640
				LINUX_MIB_TCPFASTOPENACTIVEFAIL);
5641 5642
		return true;
	}
Y
Yuchung Cheng 已提交
5643
	tp->syn_data_acked = tp->syn_data;
5644
	if (tp->syn_data_acked)
5645
		NET_INC_STATS(sock_net(sk),
5646
				LINUX_MIB_TCPFASTOPENACTIVE);
5647 5648 5649

	tcp_fastopen_add_skb(sk, synack);

5650 5651 5652
	return false;
}

L
Linus Torvalds 已提交
5653
static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
5654
					 const struct tcphdr *th)
L
Linus Torvalds 已提交
5655
{
5656
	struct inet_connection_sock *icsk = inet_csk(sk);
5657
	struct tcp_sock *tp = tcp_sk(sk);
5658
	struct tcp_fastopen_cookie foc = { .len = -1 };
5659
	int saved_clamp = tp->rx_opt.mss_clamp;
5660
	bool fastopen_fail;
L
Linus Torvalds 已提交
5661

C
Christoph Paasch 已提交
5662
	tcp_parse_options(skb, &tp->rx_opt, 0, &foc);
5663
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
5664
		tp->rx_opt.rcv_tsecr -= tp->tsoffset;
L
Linus Torvalds 已提交
5665 5666 5667 5668 5669 5670 5671 5672 5673 5674

	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)"
		 */
5675 5676
		if (!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
		    after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt))
L
Linus Torvalds 已提交
5677 5678 5679 5680 5681
			goto reset_and_undo;

		if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
		    !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp,
			     tcp_time_stamp)) {
5682
			NET_INC_STATS(sock_net(sk),
5683
					LINUX_MIB_PAWSACTIVEREJECTED);
L
Linus Torvalds 已提交
5684 5685 5686 5687 5688 5689 5690 5691 5692 5693 5694 5695 5696 5697 5698 5699 5700 5701 5702 5703 5704 5705 5706 5707 5708 5709 5710 5711 5712 5713 5714 5715 5716
			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..."
		 */

5717
		tcp_ecn_rcv_synack(tp, th);
L
Linus Torvalds 已提交
5718

5719
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
L
Linus Torvalds 已提交
5720 5721 5722 5723 5724 5725 5726 5727 5728 5729 5730 5731 5732 5733 5734 5735 5736 5737 5738 5739 5740 5741 5742 5743 5744 5745 5746 5747
		tcp_ack(sk, skb, FLAG_SLOWPATH);

		/* Ok.. it's good. Set up sequence numbers and
		 * move to established.
		 */
		tp->rcv_nxt = TCP_SKB_CB(skb)->seq + 1;
		tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1;

		/* RFC1323: The window in SYN & SYN/ACK segments is
		 * never scaled.
		 */
		tp->snd_wnd = ntohs(th->window);

		if (!tp->rx_opt.wscale_ok) {
			tp->rx_opt.snd_wscale = tp->rx_opt.rcv_wscale = 0;
			tp->window_clamp = min(tp->window_clamp, 65535U);
		}

		if (tp->rx_opt.saw_tstamp) {
			tp->rx_opt.tstamp_ok	   = 1;
			tp->tcp_header_len =
				sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
			tp->advmss	    -= TCPOLEN_TSTAMP_ALIGNED;
			tcp_store_ts_recent(tp);
		} else {
			tp->tcp_header_len = sizeof(struct tcphdr);
		}

5748 5749
		if (tcp_is_sack(tp) && sysctl_tcp_fack)
			tcp_enable_fack(tp);
L
Linus Torvalds 已提交
5750

J
John Heffner 已提交
5751
		tcp_mtup_init(sk);
5752
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5753 5754 5755 5756 5757 5758
		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;
5759

R
Ralf Baechle 已提交
5760
		smp_mb();
L
Linus Torvalds 已提交
5761

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

5764 5765
		fastopen_fail = (tp->syn_fastopen || tp->syn_data) &&
				tcp_rcv_fastopen_synack(sk, skb, &foc);
5766

5767 5768 5769 5770 5771 5772
		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;
5773 5774 5775
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
5776 5777 5778 5779 5780 5781 5782
			/* 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
			 */
5783 5784
			inet_csk_schedule_ack(sk);
			tcp_enter_quickack_mode(sk);
5785 5786
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
5787 5788

discard:
5789
			tcp_drop(sk, skb);
L
Linus Torvalds 已提交
5790 5791 5792 5793 5794 5795 5796 5797 5798 5799 5800 5801 5802 5803 5804 5805 5806 5807 5808 5809
			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. */
5810
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
I
Ilpo Järvinen 已提交
5811
	    tcp_paws_reject(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5812 5813 5814 5815 5816 5817 5818 5819 5820 5821 5822 5823 5824 5825 5826 5827 5828 5829 5830
		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;
5831
		tp->copied_seq = tp->rcv_nxt;
L
Linus Torvalds 已提交
5832 5833 5834 5835 5836 5837 5838 5839 5840
		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;

5841
		tcp_ecn_rcv_syn(tp, th);
L
Linus Torvalds 已提交
5842

J
John Heffner 已提交
5843
		tcp_mtup_init(sk);
5844
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5845 5846 5847 5848 5849
		tcp_initialize_rcv_mss(sk);

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
5850 5851 5852
		 * 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 已提交
5853 5854 5855 5856 5857 5858 5859 5860 5861 5862 5863 5864 5865 5866 5867 5868 5869 5870 5871 5872 5873 5874 5875 5876 5877 5878 5879 5880 5881
		 *
		 * 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
5882
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5883 5884 5885
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5886

5887
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
5888 5889
{
	struct tcp_sock *tp = tcp_sk(sk);
5890
	struct inet_connection_sock *icsk = inet_csk(sk);
5891
	const struct tcphdr *th = tcp_hdr(skb);
5892
	struct request_sock *req;
L
Linus Torvalds 已提交
5893
	int queued = 0;
5894
	bool acceptable;
L
Linus Torvalds 已提交
5895 5896 5897 5898 5899 5900

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

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5901
		if (th->ack)
L
Linus Torvalds 已提交
5902 5903
			return 1;

S
Stephen Hemminger 已提交
5904
		if (th->rst)
L
Linus Torvalds 已提交
5905 5906
			goto discard;

S
Stephen Hemminger 已提交
5907
		if (th->syn) {
E
Eric Dumazet 已提交
5908 5909
			if (th->fin)
				goto discard;
5910 5911 5912 5913 5914 5915
			/* 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 已提交
5916

5917 5918
			if (!acceptable)
				return 1;
5919
			consume_skb(skb);
5920
			return 0;
L
Linus Torvalds 已提交
5921 5922 5923 5924
		}
		goto discard;

	case TCP_SYN_SENT:
5925
		tp->rx_opt.saw_tstamp = 0;
E
Eric Dumazet 已提交
5926
		skb_mstamp_get(&tp->tcp_mstamp);
5927
		queued = tcp_rcv_synsent_state_process(sk, skb, th);
L
Linus Torvalds 已提交
5928 5929 5930 5931 5932 5933
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
5934
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5935 5936 5937
		return 0;
	}

E
Eric Dumazet 已提交
5938
	skb_mstamp_get(&tp->tcp_mstamp);
5939
	tp->rx_opt.saw_tstamp = 0;
5940
	req = tp->fastopen_rsk;
5941
	if (req) {
5942
		WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
5943 5944
		    sk->sk_state != TCP_FIN_WAIT1);

5945
		if (!tcp_check_req(sk, skb, req, true))
5946
			goto discard;
5947
	}
5948

5949
	if (!th->ack && !th->rst && !th->syn)
5950 5951
		goto discard;

5952
	if (!tcp_validate_incoming(sk, skb, th, 0))
E
Eric Dumazet 已提交
5953
		return 0;
L
Linus Torvalds 已提交
5954 5955

	/* step 5: check the ACK field */
5956 5957
	acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH |
				      FLAG_UPDATE_TS_RECENT) > 0;
5958

5959 5960
	switch (sk->sk_state) {
	case TCP_SYN_RECV:
5961 5962
		if (!acceptable)
			return 1;
L
Linus Torvalds 已提交
5963

Y
Yuchung Cheng 已提交
5964 5965 5966
		if (!tp->srtt_us)
			tcp_synack_rtt_meas(sk, req);

5967 5968 5969 5970
		/* Once we leave TCP_SYN_RECV, we no longer need req
		 * so release it.
		 */
		if (req) {
5971
			inet_csk(sk)->icsk_retransmits = 0;
5972 5973 5974 5975 5976 5977 5978 5979
			reqsk_fastopen_remove(sk, req, false);
		} else {
			/* Make sure socket is routed, for correct metrics. */
			icsk->icsk_af_ops->rebuild_header(sk);
			tcp_init_congestion_control(sk);

			tcp_mtup_init(sk);
			tp->copied_seq = tp->rcv_nxt;
E
Eric Dumazet 已提交
5980
			tcp_init_buffer_space(sk);
5981 5982 5983 5984
		}
		smp_mb();
		tcp_set_state(sk, TCP_ESTABLISHED);
		sk->sk_state_change(sk);
L
Linus Torvalds 已提交
5985

5986 5987 5988 5989 5990 5991 5992 5993 5994 5995 5996 5997 5998 5999 6000 6001 6002 6003 6004 6005 6006 6007
		/* Note, that this wakeup is only for marginal crossed SYN case.
		 * Passively open sockets are not waked up, because
		 * sk->sk_sleep == NULL and sk->sk_socket == NULL.
		 */
		if (sk->sk_socket)
			sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);

		tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
		tp->snd_wnd = ntohs(th->window) << tp->rx_opt.snd_wscale;
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);

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

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

6013 6014
		if (!inet_csk(sk)->icsk_ca_ops->cong_control)
			tcp_update_pacing_rate(sk);
6015

6016 6017 6018 6019 6020
		/* Prevent spurious tcp_cwnd_restart() on first data packet */
		tp->lsndtime = tcp_time_stamp;

		tcp_initialize_rcv_mss(sk);
		tcp_fast_path_on(tp);
6021 6022
		break;

6023 6024 6025
	case TCP_FIN_WAIT1: {
		int tmo;

6026 6027 6028 6029 6030
		/* 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.
		 */
6031
		if (req) {
6032 6033 6034 6035 6036
			/* Return RST if ack_seq is invalid.
			 * Note that RFC793 only says to generate a
			 * DUPACK for it but for TCP Fast Open it seems
			 * better to treat this case like TCP_SYN_RECV
			 * above.
6037
			 */
6038 6039 6040 6041 6042 6043
			if (!acceptable)
				return 1;
			/* We no longer need the request sock. */
			reqsk_fastopen_remove(sk, req, false);
			tcp_rearm_rto(sk);
		}
6044 6045
		if (tp->snd_una != tp->write_seq)
			break;
6046

6047 6048
		tcp_set_state(sk, TCP_FIN_WAIT2);
		sk->sk_shutdown |= SEND_SHUTDOWN;
6049

6050
		sk_dst_confirm(sk);
6051

6052 6053 6054 6055 6056
		if (!sock_flag(sk, SOCK_DEAD)) {
			/* Wake up lingering close() */
			sk->sk_state_change(sk);
			break;
		}
L
Linus Torvalds 已提交
6057

6058 6059 6060 6061 6062 6063 6064 6065 6066
		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)
6067
				tcp_fastopen_active_disable(sk);
6068
			tcp_done(sk);
6069
			NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
6070 6071 6072 6073 6074 6075 6076 6077 6078 6079 6080 6081 6082 6083 6084 6085 6086
			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;
6087 6088
		}
		break;
6089
	}
L
Linus Torvalds 已提交
6090

6091 6092 6093 6094 6095 6096
	case TCP_CLOSING:
		if (tp->snd_una == tp->write_seq) {
			tcp_time_wait(sk, TCP_TIME_WAIT, 0);
			goto discard;
		}
		break;
L
Linus Torvalds 已提交
6097

6098 6099 6100 6101 6102
	case TCP_LAST_ACK:
		if (tp->snd_una == tp->write_seq) {
			tcp_update_metrics(sk);
			tcp_done(sk);
			goto discard;
L
Linus Torvalds 已提交
6103
		}
6104
		break;
6105
	}
L
Linus Torvalds 已提交
6106 6107 6108 6109 6110 6111 6112 6113 6114 6115 6116 6117 6118 6119

	/* step 6: check the URG bit */
	tcp_urg(sk, skb, th);

	/* step 7: process the segment text */
	switch (sk->sk_state) {
	case TCP_CLOSE_WAIT:
	case TCP_CLOSING:
	case TCP_LAST_ACK:
		if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))
			break;
	case TCP_FIN_WAIT1:
	case TCP_FIN_WAIT2:
		/* RFC 793 says to queue data in these states,
6120
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
6121 6122 6123 6124 6125
		 * 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)) {
6126
				NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
6127 6128 6129 6130 6131
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
6132
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
6133 6134 6135 6136 6137 6138 6139
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
6140
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
6141 6142 6143
		tcp_ack_snd_check(sk);
	}

6144
	if (!queued) {
L
Linus Torvalds 已提交
6145
discard:
6146
		tcp_drop(sk, skb);
L
Linus Torvalds 已提交
6147 6148 6149 6150
	}
	return 0;
}
EXPORT_SYMBOL(tcp_rcv_state_process);
O
Octavian Purdila 已提交
6151 6152 6153 6154 6155 6156

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)
6157 6158
		net_dbg_ratelimited("drop open request from %pI4/%u\n",
				    &ireq->ir_rmt_addr, port);
6159 6160
#if IS_ENABLED(CONFIG_IPV6)
	else if (family == AF_INET6)
6161 6162
		net_dbg_ratelimited("drop open request from %pI6/%u\n",
				    &ireq->ir_v6_rmt_addr, port);
6163
#endif
O
Octavian Purdila 已提交
6164 6165
}

6166 6167 6168 6169 6170
/* 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 已提交
6171
 * TCP ECN negotiation.
6172 6173
 *
 * Exception: tcp_ca wants ECN. This is required for DCTCP
6174 6175 6176
 * congestion control: Linux DCTCP asserts ECT on all packets,
 * including SYN, which is most optimal solution; however,
 * others, such as FreeBSD do not.
6177 6178 6179
 */
static void tcp_ecn_create_request(struct request_sock *req,
				   const struct sk_buff *skb,
6180 6181
				   const struct sock *listen_sk,
				   const struct dst_entry *dst)
6182 6183 6184 6185
{
	const struct tcphdr *th = tcp_hdr(skb);
	const struct net *net = sock_net(listen_sk);
	bool th_ecn = th->ece && th->cwr;
6186
	bool ect, ecn_ok;
6187
	u32 ecn_ok_dst;
6188 6189 6190 6191 6192

	if (!th_ecn)
		return;

	ect = !INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield);
6193 6194
	ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
	ecn_ok = net->ipv4.sysctl_tcp_ecn || ecn_ok_dst;
6195

6196 6197
	if ((!ect && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
	    (ecn_ok_dst & DST_FEATURE_ECN_CA))
6198 6199 6200
		inet_rsk(req)->ecn_ok = 1;
}

6201 6202 6203 6204 6205 6206
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);

6207
	req->rsk_rcv_wnd = 0;		/* So that tcp_send_synack() knows! */
6208 6209 6210
	req->cookie_ts = 0;
	tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
	tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->seq + 1;
Y
Yuchung Cheng 已提交
6211
	skb_mstamp_get(&tcp_rsk(req)->snt_synack);
6212 6213 6214 6215 6216 6217 6218 6219 6220 6221 6222 6223 6224 6225
	tcp_rsk(req)->last_oow_ack_time = 0;
	req->mss = rx_opt->mss_clamp;
	req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
	ireq->tstamp_ok = rx_opt->tstamp_ok;
	ireq->sack_ok = rx_opt->sack_ok;
	ireq->snd_wscale = rx_opt->snd_wscale;
	ireq->wscale_ok = rx_opt->wscale_ok;
	ireq->acked = 0;
	ireq->ecn_ok = 0;
	ireq->ir_rmt_port = tcp_hdr(skb)->source;
	ireq->ir_num = ntohs(tcp_hdr(skb)->dest);
	ireq->ir_mark = inet_request_mark(sk, skb);
}

E
Eric Dumazet 已提交
6226
struct request_sock *inet_reqsk_alloc(const struct request_sock_ops *ops,
6227 6228
				      struct sock *sk_listener,
				      bool attach_listener)
E
Eric Dumazet 已提交
6229
{
6230 6231
	struct request_sock *req = reqsk_alloc(ops, sk_listener,
					       attach_listener);
E
Eric Dumazet 已提交
6232 6233 6234 6235 6236 6237

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

		kmemcheck_annotate_bitfield(ireq, flags);
		ireq->opt = NULL;
6238 6239 6240
#if IS_ENABLED(CONFIG_IPV6)
		ireq->pktopts = NULL;
#endif
E
Eric Dumazet 已提交
6241 6242 6243
		atomic64_set(&ireq->ir_cookie, 0);
		ireq->ireq_state = TCP_NEW_SYN_RECV;
		write_pnet(&ireq->ireq_net, sock_net(sk_listener));
6244
		ireq->ireq_family = sk_listener->sk_family;
E
Eric Dumazet 已提交
6245 6246 6247 6248 6249 6250
	}

	return req;
}
EXPORT_SYMBOL(inet_reqsk_alloc);

6251 6252 6253
/*
 * Return true if a syncookie should be sent
 */
6254
static bool tcp_syn_flood_action(const struct sock *sk,
6255 6256 6257
				 const struct sk_buff *skb,
				 const char *proto)
{
6258
	struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
6259 6260
	const char *msg = "Dropping request";
	bool want_cookie = false;
6261
	struct net *net = sock_net(sk);
6262 6263

#ifdef CONFIG_SYN_COOKIES
6264
	if (net->ipv4.sysctl_tcp_syncookies) {
6265 6266
		msg = "Sending cookies";
		want_cookie = true;
6267
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
6268 6269
	} else
#endif
6270
		__NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
6271

6272
	if (!queue->synflood_warned &&
6273
	    net->ipv4.sysctl_tcp_syncookies != 2 &&
6274
	    xchg(&queue->synflood_warned, 1) == 0)
6275 6276
		pr_info("%s: Possible SYN flooding on port %d. %s.  Check SNMP counters.\n",
			proto, ntohs(tcp_hdr(skb)->dest), msg);
6277

6278 6279 6280
	return want_cookie;
}

6281 6282 6283 6284 6285 6286 6287 6288 6289 6290 6291 6292 6293 6294 6295 6296 6297
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 已提交
6298 6299 6300 6301
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)
{
6302 6303
	struct tcp_fastopen_cookie foc = { .len = -1 };
	__u32 isn = TCP_SKB_CB(skb)->tcp_tw_isn;
O
Octavian Purdila 已提交
6304 6305
	struct tcp_options_received tmp_opt;
	struct tcp_sock *tp = tcp_sk(sk);
6306
	struct net *net = sock_net(sk);
6307
	struct sock *fastopen_sk = NULL;
O
Octavian Purdila 已提交
6308
	struct dst_entry *dst = NULL;
6309 6310
	struct request_sock *req;
	bool want_cookie = false;
O
Octavian Purdila 已提交
6311 6312 6313 6314 6315 6316
	struct flowi fl;

	/* TW buckets are converted to open requests without
	 * limitations, they conserve resources and peer is
	 * evidently real one.
	 */
6317
	if ((net->ipv4.sysctl_tcp_syncookies == 2 ||
O
Octavian Purdila 已提交
6318 6319 6320 6321 6322 6323
	     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;
	}

6324
	if (sk_acceptq_is_full(sk)) {
6325
		NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
O
Octavian Purdila 已提交
6326 6327 6328
		goto drop;
	}

6329
	req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
O
Octavian Purdila 已提交
6330 6331 6332 6333
	if (!req)
		goto drop;

	tcp_rsk(req)->af_specific = af_ops;
6334
	tcp_rsk(req)->ts_off = 0;
O
Octavian Purdila 已提交
6335 6336 6337 6338 6339 6340 6341 6342 6343 6344 6345

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

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

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

6348
	/* Note: tcp_v6_init_req() might override ir_iif for link locals */
6349
	inet_rsk(req)->ir_iif = inet_request_bound_dev_if(sk, skb);
6350

O
Octavian Purdila 已提交
6351 6352 6353 6354 6355
	af_ops->init_req(req, sk, skb);

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

6356
	if (isn && tmp_opt.tstamp_ok)
6357
		af_ops->init_seq_tsoff(skb, &tcp_rsk(req)->ts_off);
6358

6359
	if (!want_cookie && !isn) {
O
Octavian Purdila 已提交
6360
		/* Kill the following clause, if you dislike this way. */
6361 6362 6363 6364
		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 已提交
6365 6366 6367 6368 6369 6370 6371 6372 6373 6374 6375 6376
			/* 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;
		}

6377
		isn = af_ops->init_seq_tsoff(skb, &tcp_rsk(req)->ts_off);
O
Octavian Purdila 已提交
6378 6379
	}
	if (!dst) {
6380
		dst = af_ops->route_req(sk, &fl, req);
O
Octavian Purdila 已提交
6381 6382 6383 6384
		if (!dst)
			goto drop_and_free;
	}

6385 6386 6387 6388
	tcp_ecn_create_request(req, skb, sk, dst);

	if (want_cookie) {
		isn = cookie_init_sequence(af_ops, sk, skb, &req->mss);
6389
		tcp_rsk(req)->ts_off = 0;
6390 6391 6392 6393 6394
		req->cookie_ts = tmp_opt.tstamp_ok;
		if (!tmp_opt.tstamp_ok)
			inet_rsk(req)->ecn_ok = 0;
	}

O
Octavian Purdila 已提交
6395
	tcp_rsk(req)->snt_isn = isn;
6396
	tcp_rsk(req)->txhash = net_tx_rndhash();
O
Octavian Purdila 已提交
6397
	tcp_openreq_init_rwin(req, sk, dst);
6398 6399
	if (!want_cookie) {
		tcp_reqsk_record_syn(sk, req, skb);
6400
		fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc, dst);
6401
	}
6402
	if (fastopen_sk) {
6403
		af_ops->send_synack(fastopen_sk, dst, &fl, req,
6404
				    &foc, TCP_SYNACK_FASTOPEN);
6405 6406 6407 6408
		/* 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);
6409 6410
		sock_put(fastopen_sk);
	} else {
6411
		tcp_rsk(req)->tfo_listener = false;
6412 6413
		if (!want_cookie)
			inet_csk_reqsk_queue_hash_add(sk, req, TCP_TIMEOUT_INIT);
6414 6415 6416
		af_ops->send_synack(sk, dst, &fl, req, &foc,
				    !want_cookie ? TCP_SYNACK_NORMAL :
						   TCP_SYNACK_COOKIE);
6417 6418 6419 6420
		if (want_cookie) {
			reqsk_free(req);
			return 0;
		}
O
Octavian Purdila 已提交
6421
	}
6422
	reqsk_put(req);
O
Octavian Purdila 已提交
6423 6424 6425 6426 6427 6428 6429
	return 0;

drop_and_release:
	dst_release(dst);
drop_and_free:
	reqsk_free(req);
drop:
6430
	tcp_listendrop(sk);
O
Octavian Purdila 已提交
6431 6432 6433
	return 0;
}
EXPORT_SYMBOL(tcp_conn_request);