tcp_input.c 168.4 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 64
 *		Andi Kleen:		Process packets with PSH set in the
 *					fast path.
 *		J Hadi Salim:		ECN support
 *	 	Andrei Gurtov,
 *		Pasi Sarolahti,
 *		Panu Kuhlberg:		Experimental audit of TCP (re)transmission
 *					engine. Lots of bugs are found.
 *		Pasi Sarolahti:		F-RTO for dealing with spurious RTOs
 */

#include <linux/mm.h>
65
#include <linux/slab.h>
L
Linus Torvalds 已提交
66 67
#include <linux/module.h>
#include <linux/sysctl.h>
68
#include <linux/kernel.h>
69
#include <net/dst.h>
L
Linus Torvalds 已提交
70 71 72 73
#include <net/tcp.h>
#include <net/inet_common.h>
#include <linux/ipsec.h>
#include <asm/unaligned.h>
C
Chris Leech 已提交
74
#include <net/netdma.h>
L
Linus Torvalds 已提交
75

76 77 78 79 80
int sysctl_tcp_timestamps __read_mostly = 1;
int sysctl_tcp_window_scaling __read_mostly = 1;
int sysctl_tcp_sack __read_mostly = 1;
int sysctl_tcp_fack __read_mostly = 1;
int sysctl_tcp_reordering __read_mostly = TCP_FASTRETRANS_THRESH;
E
Eric Dumazet 已提交
81
EXPORT_SYMBOL(sysctl_tcp_reordering);
82
int sysctl_tcp_ecn __read_mostly = 2;
E
Eric Dumazet 已提交
83
EXPORT_SYMBOL(sysctl_tcp_ecn);
84 85 86
int sysctl_tcp_dsack __read_mostly = 1;
int sysctl_tcp_app_win __read_mostly = 31;
int sysctl_tcp_adv_win_scale __read_mostly = 2;
E
Eric Dumazet 已提交
87
EXPORT_SYMBOL(sysctl_tcp_adv_win_scale);
L
Linus Torvalds 已提交
88

89 90 91
int sysctl_tcp_stdurg __read_mostly;
int sysctl_tcp_rfc1337 __read_mostly;
int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
92
int sysctl_tcp_frto __read_mostly = 2;
93
int sysctl_tcp_frto_response __read_mostly;
94
int sysctl_tcp_nometrics_save __read_mostly;
L
Linus Torvalds 已提交
95

A
Andreas Petlund 已提交
96 97
int sysctl_tcp_thin_dupack __read_mostly;

98 99
int sysctl_tcp_moderate_rcvbuf __read_mostly = 1;
int sysctl_tcp_abc __read_mostly;
L
Linus Torvalds 已提交
100 101 102 103 104 105 106 107 108 109

#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				*/
#define FLAG_DATA_LOST		0x80 /* SACK detected data lossage.		*/
#define FLAG_SLOWPATH		0x100 /* Do not skip RFC checks for window update.*/
I
Ilpo Järvinen 已提交
110
#define FLAG_ONLY_ORIG_SACKED	0x200 /* SACKs only non-rexmit sent before RTO */
111
#define FLAG_SND_UNA_ADVANCED	0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
112
#define FLAG_DSACKING_ACK	0x800 /* SACK blocks contained D-SACK info */
113
#define FLAG_NONHEAD_RETRANS_ACKED	0x1000 /* Non-head rexmitted data was ACKed */
114
#define FLAG_SACK_RENEGING	0x2000 /* snd_una advanced to a sacked seq */
L
Linus Torvalds 已提交
115 116 117 118 119

#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)
120
#define FLAG_ANY_PROGRESS	(FLAG_FORWARD_PROGRESS|FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
121 122

#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
/* Adapt the MSS value used to make delayed ack decision to the
L
Linus Torvalds 已提交
126
 * real world.
127
 */
128
static void tcp_measure_rcv_mss(struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
129
{
130
	struct inet_connection_sock *icsk = inet_csk(sk);
131
	const unsigned int lss = icsk->icsk_ack.last_seg_size;
132
	unsigned int len;
L
Linus Torvalds 已提交
133

134
	icsk->icsk_ack.last_seg_size = 0;
L
Linus Torvalds 已提交
135 136 137 138

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

174
static void tcp_incr_quickack(struct sock *sk)
L
Linus Torvalds 已提交
175
{
176 177
	struct inet_connection_sock *icsk = inet_csk(sk);
	unsigned quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
L
Linus Torvalds 已提交
178

179 180
	if (quickacks == 0)
		quickacks = 2;
181 182
	if (quickacks > icsk->icsk_ack.quick)
		icsk->icsk_ack.quick = min(quickacks, TCP_MAX_QUICKACKS);
L
Linus Torvalds 已提交
183 184
}

185
static void tcp_enter_quickack_mode(struct sock *sk)
L
Linus Torvalds 已提交
186
{
187 188 189 190
	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 已提交
191 192 193 194 195 196
}

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

197
static inline int tcp_in_quickack_mode(const struct sock *sk)
L
Linus Torvalds 已提交
198
{
199 200
	const struct inet_connection_sock *icsk = inet_csk(sk);
	return icsk->icsk_ack.quick && !icsk->icsk_ack.pingpong;
L
Linus Torvalds 已提交
201 202
}

203 204
static inline void TCP_ECN_queue_cwr(struct tcp_sock *tp)
{
205
	if (tp->ecn_flags & TCP_ECN_OK)
206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221
		tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
}

static inline void TCP_ECN_accept_cwr(struct tcp_sock *tp, struct sk_buff *skb)
{
	if (tcp_hdr(skb)->cwr)
		tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

static inline void TCP_ECN_withdraw_cwr(struct tcp_sock *tp)
{
	tp->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
}

static inline void TCP_ECN_check_ce(struct tcp_sock *tp, struct sk_buff *skb)
{
222
	if (tp->ecn_flags & TCP_ECN_OK) {
223 224 225 226 227 228 229 230 231 232 233 234
		if (INET_ECN_is_ce(TCP_SKB_CB(skb)->flags))
			tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
		/* Funny extension: if ECT is not set on a segment,
		 * it is surely retransmit. It is not in ECN RFC,
		 * but Linux follows this rule. */
		else if (INET_ECN_is_not_ect((TCP_SKB_CB(skb)->flags)))
			tcp_enter_quickack_mode((struct sock *)tp);
	}
}

static inline void TCP_ECN_rcv_synack(struct tcp_sock *tp, struct tcphdr *th)
{
235
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || th->cwr))
236 237 238 239 240
		tp->ecn_flags &= ~TCP_ECN_OK;
}

static inline void TCP_ECN_rcv_syn(struct tcp_sock *tp, struct tcphdr *th)
{
241
	if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
242 243 244 245 246
		tp->ecn_flags &= ~TCP_ECN_OK;
}

static inline int TCP_ECN_rcv_ecn_echo(struct tcp_sock *tp, struct tcphdr *th)
{
247
	if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
248 249 250 251
		return 1;
	return 0;
}

L
Linus Torvalds 已提交
252 253 254 255 256 257 258 259 260 261
/* Buffer size and advertised window tuning.
 *
 * 1. Tuning sk->sk_sndbuf, when connection enters established state.
 */

static void tcp_fixup_sndbuf(struct sock *sk)
{
	int sndmem = tcp_sk(sk)->rx_opt.mss_clamp + MAX_TCP_HEADER + 16 +
		     sizeof(struct sk_buff);

E
Eric Dumazet 已提交
262 263 264 265 266
	if (sk->sk_sndbuf < 3 * sndmem) {
		sk->sk_sndbuf = 3 * sndmem;
		if (sk->sk_sndbuf > sysctl_tcp_wmem[2])
			sk->sk_sndbuf = sysctl_tcp_wmem[2];
	}
L
Linus Torvalds 已提交
267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289
}

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

/* Slow part of check#2. */
295
static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb)
L
Linus Torvalds 已提交
296
{
297
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
298
	/* Optimize this! */
299 300
	int truesize = tcp_win_from_space(skb->truesize) >> 1;
	int window = tcp_win_from_space(sysctl_tcp_rmem[2]) >> 1;
L
Linus Torvalds 已提交
301 302 303

	while (tp->rcv_ssthresh <= window) {
		if (truesize <= skb->len)
304
			return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
L
Linus Torvalds 已提交
305 306 307 308 309 310 311

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

312
static void tcp_grow_window(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
313
{
314 315
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
316 317 318 319 320 321 322 323 324 325
	/* Check #1 */
	if (tp->rcv_ssthresh < tp->window_clamp &&
	    (int)tp->rcv_ssthresh < tcp_space(sk) &&
	    !tcp_memory_pressure) {
		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)
326
			incr = 2 * tp->advmss;
L
Linus Torvalds 已提交
327
		else
328
			incr = __tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
329 330

		if (incr) {
331 332
			tp->rcv_ssthresh = min(tp->rcv_ssthresh + incr,
					       tp->window_clamp);
333
			inet_csk(sk)->icsk_ack.quick |= 1;
L
Linus Torvalds 已提交
334 335 336 337 338 339 340 341 342 343 344 345
		}
	}
}

/* 3. Tuning rcvbuf, when connection enters established state. */

static void tcp_fixup_rcvbuf(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int rcvmem = tp->advmss + MAX_TCP_HEADER + 16 + sizeof(struct sk_buff);

	/* Try to select rcvbuf so that 4 mss-sized segments
S
Stephen Hemminger 已提交
346
	 * will fit to window and corresponding skbs will fit to our rcvbuf.
L
Linus Torvalds 已提交
347 348 349 350 351 352 353 354
	 * (was 3; 4 is minimum to allow fast retransmit to work.)
	 */
	while (tcp_win_from_space(rcvmem) < tp->advmss)
		rcvmem += 128;
	if (sk->sk_rcvbuf < 4 * rcvmem)
		sk->sk_rcvbuf = min(4 * rcvmem, sysctl_tcp_rmem[2]);
}

S
Stephen Hemminger 已提交
355
/* 4. Try to fixup all. It is made immediately after connection enters
L
Linus Torvalds 已提交
356 357 358 359 360 361 362 363 364 365 366 367 368 369 370 371 372 373 374 375 376 377 378 379 380 381 382 383 384 385 386 387 388 389 390 391
 *    established state.
 */
static void tcp_init_buffer_space(struct sock *sk)
{
	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))
		tcp_fixup_sndbuf(sk);

	tp->rcvq_space.space = tp->rcv_wnd;

	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. */
392
static void tcp_clamp_window(struct sock *sk)
L
Linus Torvalds 已提交
393
{
394
	struct tcp_sock *tp = tcp_sk(sk);
395
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
396

397
	icsk->icsk_ack.quick = 0;
L
Linus Torvalds 已提交
398

399 400 401
	if (sk->sk_rcvbuf < sysctl_tcp_rmem[2] &&
	    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
	    !tcp_memory_pressure &&
E
Eric Dumazet 已提交
402
	    atomic_long_read(&tcp_memory_allocated) < sysctl_tcp_mem[0]) {
403 404
		sk->sk_rcvbuf = min(atomic_read(&sk->sk_rmem_alloc),
				    sysctl_tcp_rmem[2]);
L
Linus Torvalds 已提交
405
	}
406
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf)
407
		tp->rcv_ssthresh = min(tp->window_clamp, 2U * tp->advmss);
L
Linus Torvalds 已提交
408 409
}

S
Stephen Hemminger 已提交
410 411 412 413 414 415 416 417 418 419 420 421
/* 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)
{
	struct tcp_sock *tp = tcp_sk(sk);
	unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);

422
	hint = min(hint, tp->rcv_wnd / 2);
423
	hint = min(hint, TCP_MSS_DEFAULT);
S
Stephen Hemminger 已提交
424 425 426 427
	hint = max(hint, TCP_MIN_MSS);

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

L
Linus Torvalds 已提交
430 431 432 433
/* 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.
434
 * <http://public.lanl.gov/radiant/pubs.html#DRS>
L
Linus Torvalds 已提交
435 436
 *
 * More detail on this code can be found at
437
 * <http://staff.psc.edu/jheffner/>,
L
Linus Torvalds 已提交
438 439 440 441 442 443 444 445 446 447 448 449 450 451 452 453 454 455
 * 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 已提交
456
		 * non-timestamp case, we do not smooth things out
S
Stephen Hemminger 已提交
457
		 * else with timestamps disabled convergence takes too
L
Linus Torvalds 已提交
458 459 460 461 462 463 464 465
		 * long.
		 */
		if (!win_dep) {
			m -= (new_sample >> 3);
			new_sample += m;
		} else if (m < new_sample)
			new_sample = m << 3;
	} else {
S
Stephen Hemminger 已提交
466
		/* No previous measure. */
L
Linus Torvalds 已提交
467 468 469 470 471 472 473 474 475 476 477 478 479
		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;
480
	tcp_rcv_rtt_update(tp, jiffies - tp->rcv_rtt_est.time, 1);
L
Linus Torvalds 已提交
481 482 483 484 485 486

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

487 488
static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
					  const struct sk_buff *skb)
L
Linus Torvalds 已提交
489
{
490
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
491 492
	if (tp->rx_opt.rcv_tsecr &&
	    (TCP_SKB_CB(skb)->end_seq -
493
	     TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss))
L
Linus Torvalds 已提交
494 495 496 497 498 499 500 501 502 503 504 505
		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;
	int space;
506

L
Linus Torvalds 已提交
507 508
	if (tp->rcvq_space.time == 0)
		goto new_measure;
509

L
Linus Torvalds 已提交
510
	time = tcp_time_stamp - tp->rcvq_space.time;
511
	if (time < (tp->rcv_rtt_est.rtt >> 3) || tp->rcv_rtt_est.rtt == 0)
L
Linus Torvalds 已提交
512
		return;
513

L
Linus Torvalds 已提交
514 515 516 517 518 519 520 521 522
	space = 2 * (tp->copied_seq - tp->rcvq_space.seq);

	space = max(tp->rcvq_space.space, space);

	if (tp->rcvq_space.space != space) {
		int rcvmem;

		tp->rcvq_space.space = space;

523 524
		if (sysctl_tcp_moderate_rcvbuf &&
		    !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
L
Linus Torvalds 已提交
525 526 527 528 529 530 531 532 533 534 535 536 537 538 539 540 541 542 543 544 545 546 547
			int new_clamp = space;

			/* Receive space grows, normalize in order to
			 * take into account packet headers and sk_buff
			 * structure overhead.
			 */
			space /= tp->advmss;
			if (!space)
				space = 1;
			rcvmem = (tp->advmss + MAX_TCP_HEADER +
				  16 + sizeof(struct sk_buff));
			while (tcp_win_from_space(rcvmem) < tp->advmss)
				rcvmem += 128;
			space *= rcvmem;
			space = min(space, sysctl_tcp_rmem[2]);
			if (space > sk->sk_rcvbuf) {
				sk->sk_rcvbuf = space;

				/* Make the window clamp follow along.  */
				tp->window_clamp = new_clamp;
			}
		}
	}
548

L
Linus Torvalds 已提交
549 550 551 552 553 554 555 556 557 558 559 560 561 562 563
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
 */
564
static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
565
{
566
	struct tcp_sock *tp = tcp_sk(sk);
567
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
568 569
	u32 now;

570
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
571

572
	tcp_measure_rcv_mss(sk, skb);
L
Linus Torvalds 已提交
573 574

	tcp_rcv_rtt_measure(tp);
575

L
Linus Torvalds 已提交
576 577
	now = tcp_time_stamp;

578
	if (!icsk->icsk_ack.ato) {
L
Linus Torvalds 已提交
579 580 581
		/* The _first_ data packet received, initialize
		 * delayed ACK engine.
		 */
582 583
		tcp_incr_quickack(sk);
		icsk->icsk_ack.ato = TCP_ATO_MIN;
L
Linus Torvalds 已提交
584
	} else {
585
		int m = now - icsk->icsk_ack.lrcvtime;
L
Linus Torvalds 已提交
586

587
		if (m <= TCP_ATO_MIN / 2) {
L
Linus Torvalds 已提交
588
			/* The fastest case is the first. */
589 590 591 592 593 594
			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 已提交
595
			/* Too long gap. Apparently sender failed to
L
Linus Torvalds 已提交
596 597
			 * restart window, so that we send ACKs quickly.
			 */
598
			tcp_incr_quickack(sk);
599
			sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
600 601
		}
	}
602
	icsk->icsk_ack.lrcvtime = now;
L
Linus Torvalds 已提交
603 604 605 606

	TCP_ECN_check_ce(tp, skb);

	if (skb->len >= 128)
607
		tcp_grow_window(sk, skb);
L
Linus Torvalds 已提交
608 609 610 611 612 613 614 615 616 617 618
}

/* 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
 */
619
static void tcp_rtt_estimator(struct sock *sk, const __u32 mrtt)
L
Linus Torvalds 已提交
620
{
621
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
622 623 624 625 626
	long m = mrtt; /* RTT */

	/*	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.
627
	 *	This is designed to be as fast as possible
L
Linus Torvalds 已提交
628 629 630 631 632 633 634
	 *	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 已提交
635
	 * too slowly, when it should be increased quickly, decrease too quickly
L
Linus Torvalds 已提交
636 637 638 639
	 * 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)
	 */
S
Stephen Hemminger 已提交
640
	if (m == 0)
L
Linus Torvalds 已提交
641 642 643 644 645 646 647 648 649 650 651 652 653 654 655 656 657 658 659 660 661 662 663 664 665 666 667 668
		m = 1;
	if (tp->srtt != 0) {
		m -= (tp->srtt >> 3);	/* m is now error in rtt est */
		tp->srtt += m;		/* rtt = 7/8 rtt + 1/8 new */
		if (m < 0) {
			m = -m;		/* m is now abs(error) */
			m -= (tp->mdev >> 2);   /* similar update on mdev */
			/* 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 {
			m -= (tp->mdev >> 2);   /* similar update on mdev */
		}
		tp->mdev += m;	    	/* mdev = 3/4 mdev + 1/4 new */
		if (tp->mdev > tp->mdev_max) {
			tp->mdev_max = tp->mdev;
			if (tp->mdev_max > tp->rttvar)
				tp->rttvar = tp->mdev_max;
		}
		if (after(tp->snd_una, tp->rtt_seq)) {
			if (tp->mdev_max < tp->rttvar)
669
				tp->rttvar -= (tp->rttvar - tp->mdev_max) >> 2;
L
Linus Torvalds 已提交
670
			tp->rtt_seq = tp->snd_nxt;
671
			tp->mdev_max = tcp_rto_min(sk);
L
Linus Torvalds 已提交
672 673 674
		}
	} else {
		/* no previous measure. */
675 676
		tp->srtt = m << 3;	/* take the measured time to be rtt */
		tp->mdev = m << 1;	/* make sure rto = 3*rtt */
677
		tp->mdev_max = tp->rttvar = max(tp->mdev, tcp_rto_min(sk));
L
Linus Torvalds 已提交
678 679 680 681 682 683 684
		tp->rtt_seq = tp->snd_nxt;
	}
}

/* Calculate rto without backoff.  This is the second half of Van Jacobson's
 * routine referred to above.
 */
685
static inline void tcp_set_rto(struct sock *sk)
L
Linus Torvalds 已提交
686
{
687
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
688 689 690 691 692 693 694 695
	/* 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 已提交
696
	 *    ACKs in some circumstances.
L
Linus Torvalds 已提交
697
	 */
698
	inet_csk(sk)->icsk_rto = __tcp_set_rto(tp);
L
Linus Torvalds 已提交
699 700 701 702

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

706 707 708
	/* NOTE: clamping at TCP_RTO_MIN is not required, current algo
	 * guarantees that rto is higher.
	 */
709
	tcp_bound_rto(sk);
L
Linus Torvalds 已提交
710 711 712 713 714 715 716 717 718 719 720 721 722 723 724 725
}

/* Save metrics learned by this TCP session.
   This function is called only, when TCP finishes successfully
   i.e. when it enters TIME-WAIT or goes from LAST-ACK to CLOSE.
 */
void tcp_update_metrics(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct dst_entry *dst = __sk_dst_get(sk);

	if (sysctl_tcp_nometrics_save)
		return;

	dst_confirm(dst);

726
	if (dst && (dst->flags & DST_HOST)) {
727
		const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
728
		int m;
S
Stephen Hemminger 已提交
729
		unsigned long rtt;
L
Linus Torvalds 已提交
730

731
		if (icsk->icsk_backoff || !tp->srtt) {
L
Linus Torvalds 已提交
732 733 734 735 736
			/* This session failed to estimate rtt. Why?
			 * Probably, no packets returned in time.
			 * Reset our results.
			 */
			if (!(dst_metric_locked(dst, RTAX_RTT)))
737
				dst_metric_set(dst, RTAX_RTT, 0);
L
Linus Torvalds 已提交
738 739 740
			return;
		}

S
Stephen Hemminger 已提交
741 742
		rtt = dst_metric_rtt(dst, RTAX_RTT);
		m = rtt - tp->srtt;
L
Linus Torvalds 已提交
743 744 745 746 747 748 749

		/* If newly calculated rtt larger than stored one,
		 * store new one. Otherwise, use EWMA. Remember,
		 * rtt overestimation is always better than underestimation.
		 */
		if (!(dst_metric_locked(dst, RTAX_RTT))) {
			if (m <= 0)
S
Stephen Hemminger 已提交
750
				set_dst_metric_rtt(dst, RTAX_RTT, tp->srtt);
L
Linus Torvalds 已提交
751
			else
S
Stephen Hemminger 已提交
752
				set_dst_metric_rtt(dst, RTAX_RTT, rtt - (m >> 3));
L
Linus Torvalds 已提交
753 754 755
		}

		if (!(dst_metric_locked(dst, RTAX_RTTVAR))) {
S
Stephen Hemminger 已提交
756
			unsigned long var;
L
Linus Torvalds 已提交
757 758 759 760 761 762 763 764
			if (m < 0)
				m = -m;

			/* Scale deviation to rttvar fixed point */
			m >>= 1;
			if (m < tp->mdev)
				m = tp->mdev;

S
Stephen Hemminger 已提交
765 766 767
			var = dst_metric_rtt(dst, RTAX_RTTVAR);
			if (m >= var)
				var = m;
L
Linus Torvalds 已提交
768
			else
S
Stephen Hemminger 已提交
769 770 771
				var -= (var - m) >> 2;

			set_dst_metric_rtt(dst, RTAX_RTTVAR, var);
L
Linus Torvalds 已提交
772 773
		}

I
Ilpo Järvinen 已提交
774
		if (tcp_in_initial_slowstart(tp)) {
L
Linus Torvalds 已提交
775 776 777 778
			/* Slow start still did not finish. */
			if (dst_metric(dst, RTAX_SSTHRESH) &&
			    !dst_metric_locked(dst, RTAX_SSTHRESH) &&
			    (tp->snd_cwnd >> 1) > dst_metric(dst, RTAX_SSTHRESH))
779
				dst_metric_set(dst, RTAX_SSTHRESH, tp->snd_cwnd >> 1);
L
Linus Torvalds 已提交
780 781
			if (!dst_metric_locked(dst, RTAX_CWND) &&
			    tp->snd_cwnd > dst_metric(dst, RTAX_CWND))
782
				dst_metric_set(dst, RTAX_CWND, tp->snd_cwnd);
L
Linus Torvalds 已提交
783
		} else if (tp->snd_cwnd > tp->snd_ssthresh &&
784
			   icsk->icsk_ca_state == TCP_CA_Open) {
L
Linus Torvalds 已提交
785 786
			/* Cong. avoidance phase, cwnd is reliable. */
			if (!dst_metric_locked(dst, RTAX_SSTHRESH))
787 788
				dst_metric_set(dst, RTAX_SSTHRESH,
					       max(tp->snd_cwnd >> 1, tp->snd_ssthresh));
L
Linus Torvalds 已提交
789
			if (!dst_metric_locked(dst, RTAX_CWND))
790 791 792
				dst_metric_set(dst, RTAX_CWND,
					       (dst_metric(dst, RTAX_CWND) +
						tp->snd_cwnd) >> 1);
L
Linus Torvalds 已提交
793 794 795 796 797
		} else {
			/* Else slow start did not finish, cwnd is non-sense,
			   ssthresh may be also invalid.
			 */
			if (!dst_metric_locked(dst, RTAX_CWND))
798 799 800
				dst_metric_set(dst, RTAX_CWND,
					       (dst_metric(dst, RTAX_CWND) +
						tp->snd_ssthresh) >> 1);
801
			if (dst_metric(dst, RTAX_SSTHRESH) &&
L
Linus Torvalds 已提交
802
			    !dst_metric_locked(dst, RTAX_SSTHRESH) &&
803
			    tp->snd_ssthresh > dst_metric(dst, RTAX_SSTHRESH))
804
				dst_metric_set(dst, RTAX_SSTHRESH, tp->snd_ssthresh);
L
Linus Torvalds 已提交
805 806 807
		}

		if (!dst_metric_locked(dst, RTAX_REORDERING)) {
808
			if (dst_metric(dst, RTAX_REORDERING) < tp->reordering &&
L
Linus Torvalds 已提交
809
			    tp->reordering != sysctl_tcp_reordering)
810
				dst_metric_set(dst, RTAX_REORDERING, tp->reordering);
L
Linus Torvalds 已提交
811 812 813 814 815 816 817 818
		}
	}
}

__u32 tcp_init_cwnd(struct tcp_sock *tp, struct dst_entry *dst)
{
	__u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);

819
	if (!cwnd)
820
		cwnd = TCP_INIT_CWND;
L
Linus Torvalds 已提交
821 822 823
	return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
}

S
Stephen Hemminger 已提交
824
/* Set slow start threshold and cwnd not falling to slow start */
825
void tcp_enter_cwr(struct sock *sk, const int set_ssthresh)
S
Stephen Hemminger 已提交
826 827
{
	struct tcp_sock *tp = tcp_sk(sk);
828
	const struct inet_connection_sock *icsk = inet_csk(sk);
S
Stephen Hemminger 已提交
829 830 831

	tp->prior_ssthresh = 0;
	tp->bytes_acked = 0;
832
	if (icsk->icsk_ca_state < TCP_CA_CWR) {
S
Stephen Hemminger 已提交
833
		tp->undo_marker = 0;
834 835
		if (set_ssthresh)
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
S
Stephen Hemminger 已提交
836 837 838 839 840 841 842 843 844 845 846
		tp->snd_cwnd = min(tp->snd_cwnd,
				   tcp_packets_in_flight(tp) + 1U);
		tp->snd_cwnd_cnt = 0;
		tp->high_seq = tp->snd_nxt;
		tp->snd_cwnd_stamp = tcp_time_stamp;
		TCP_ECN_queue_cwr(tp);

		tcp_set_ca_state(sk, TCP_CA_CWR);
	}
}

847 848 849 850 851 852
/*
 * Packet counting of FACK is based on in-order assumptions, therefore TCP
 * disables it when reordering is detected
 */
static void tcp_disable_fack(struct tcp_sock *tp)
{
853 854 855
	/* RFC3517 uses different metric in lost marker => reset on change */
	if (tcp_is_fack(tp))
		tp->lost_skb_hint = NULL;
856 857 858
	tp->rx_opt.sack_ok &= ~2;
}

859
/* Take a notice that peer is sending D-SACKs */
860 861 862 863 864
static void tcp_dsack_seen(struct tcp_sock *tp)
{
	tp->rx_opt.sack_ok |= 4;
}

L
Linus Torvalds 已提交
865 866 867 868 869 870 871 872 873 874 875 876 877 878 879 880 881 882
/* Initialize metrics on socket. */

static void tcp_init_metrics(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct dst_entry *dst = __sk_dst_get(sk);

	if (dst == NULL)
		goto reset;

	dst_confirm(dst);

	if (dst_metric_locked(dst, RTAX_CWND))
		tp->snd_cwnd_clamp = dst_metric(dst, RTAX_CWND);
	if (dst_metric(dst, RTAX_SSTHRESH)) {
		tp->snd_ssthresh = dst_metric(dst, RTAX_SSTHRESH);
		if (tp->snd_ssthresh > tp->snd_cwnd_clamp)
			tp->snd_ssthresh = tp->snd_cwnd_clamp;
883 884 885 886 887
	} else {
		/* ssthresh may have been reduced unnecessarily during.
		 * 3WHS. Restore it back to its initial default.
		 */
		tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
L
Linus Torvalds 已提交
888 889 890
	}
	if (dst_metric(dst, RTAX_REORDERING) &&
	    tp->reordering != dst_metric(dst, RTAX_REORDERING)) {
891
		tcp_disable_fack(tp);
L
Linus Torvalds 已提交
892 893 894
		tp->reordering = dst_metric(dst, RTAX_REORDERING);
	}

895
	if (dst_metric(dst, RTAX_RTT) == 0 || tp->srtt == 0)
L
Linus Torvalds 已提交
896 897 898 899 900 901 902 903
		goto reset;

	/* Initial rtt is determined from SYN,SYN-ACK.
	 * The segment is small and rtt may appear much
	 * less than real one. Use per-dst memory
	 * to make it more realistic.
	 *
	 * A bit of theory. RTT is time passed after "normal" sized packet
S
Stephen Hemminger 已提交
904
	 * is sent until it is ACKed. In normal circumstances sending small
L
Linus Torvalds 已提交
905 906 907 908 909 910 911
	 * packets force peer to delay ACKs and calculation is correct too.
	 * The algorithm is adaptive and, provided we follow specs, it
	 * NEVER underestimate RTT. BUT! If peer tries to make some clever
	 * tricks sort of "quick acks" for time long enough to decrease RTT
	 * to low value, and then abruptly stops to do it and starts to delay
	 * ACKs, wait for troubles.
	 */
S
Stephen Hemminger 已提交
912 913
	if (dst_metric_rtt(dst, RTAX_RTT) > tp->srtt) {
		tp->srtt = dst_metric_rtt(dst, RTAX_RTT);
L
Linus Torvalds 已提交
914 915
		tp->rtt_seq = tp->snd_nxt;
	}
S
Stephen Hemminger 已提交
916 917
	if (dst_metric_rtt(dst, RTAX_RTTVAR) > tp->mdev) {
		tp->mdev = dst_metric_rtt(dst, RTAX_RTTVAR);
918
		tp->mdev_max = tp->rttvar = max(tp->mdev, tcp_rto_min(sk));
L
Linus Torvalds 已提交
919
	}
920
	tcp_set_rto(sk);
L
Linus Torvalds 已提交
921
reset:
922 923 924 925 926 927
	if (tp->srtt == 0) {
		/* RFC2988bis: We've failed to get a valid RTT sample from
		 * 3WHS. This is most likely due to retransmission,
		 * including spurious one. Reset the RTO back to 3secs
		 * from the more aggressive 1sec to avoid more spurious
		 * retransmission.
928
		 */
929 930
		tp->mdev = tp->mdev_max = tp->rttvar = TCP_TIMEOUT_FALLBACK;
		inet_csk(sk)->icsk_rto = TCP_TIMEOUT_FALLBACK;
L
Linus Torvalds 已提交
931
	}
932 933 934 935 936 937 938 939 940
	/* Cut cwnd down to 1 per RFC5681 if SYN or SYN-ACK has been
	 * retransmitted. In light of RFC2988bis' more aggressive 1sec
	 * initRTO, we only reset cwnd when more than 1 SYN/SYN-ACK
	 * retransmission has occurred.
	 */
	if (tp->total_retrans > 1)
		tp->snd_cwnd = 1;
	else
		tp->snd_cwnd = tcp_init_cwnd(tp, dst);
941
	tp->snd_cwnd_stamp = tcp_time_stamp;
L
Linus Torvalds 已提交
942 943
}

944 945
static void tcp_update_reordering(struct sock *sk, const int metric,
				  const int ts)
L
Linus Torvalds 已提交
946
{
947
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
948
	if (metric > tp->reordering) {
949 950
		int mib_idx;

L
Linus Torvalds 已提交
951 952 953 954
		tp->reordering = min(TCP_MAX_REORDERING, metric);

		/* This exciting event is worth to be remembered. 8) */
		if (ts)
955
			mib_idx = LINUX_MIB_TCPTSREORDER;
956
		else if (tcp_is_reno(tp))
957
			mib_idx = LINUX_MIB_TCPRENOREORDER;
958
		else if (tcp_is_fack(tp))
959
			mib_idx = LINUX_MIB_TCPFACKREORDER;
L
Linus Torvalds 已提交
960
		else
961 962
			mib_idx = LINUX_MIB_TCPSACKREORDER;

963
		NET_INC_STATS_BH(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
964 965
#if FASTRETRANS_DEBUG > 1
		printk(KERN_DEBUG "Disorder%d %d %u f%u s%u rr%d\n",
966
		       tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
L
Linus Torvalds 已提交
967 968 969 970 971
		       tp->reordering,
		       tp->fackets_out,
		       tp->sacked_out,
		       tp->undo_marker ? tp->undo_retrans : 0);
#endif
972
		tcp_disable_fack(tp);
L
Linus Torvalds 已提交
973 974 975
	}
}

976
/* This must be called before lost_out is incremented */
977 978
static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
{
979
	if ((tp->retransmit_skb_hint == NULL) ||
980 981
	    before(TCP_SKB_CB(skb)->seq,
		   TCP_SKB_CB(tp->retransmit_skb_hint)->seq))
982 983 984 985 986
		tp->retransmit_skb_hint = skb;

	if (!tp->lost_out ||
	    after(TCP_SKB_CB(skb)->end_seq, tp->retransmit_high))
		tp->retransmit_high = TCP_SKB_CB(skb)->end_seq;
987 988
}

989 990 991 992 993 994 995 996 997 998
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);
		TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
	}
}

999 1000
static void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp,
					    struct sk_buff *skb)
1001 1002 1003 1004 1005 1006 1007 1008 1009
{
	tcp_verify_retransmit_hint(tp, skb);

	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 已提交
1010 1011 1012 1013 1014 1015 1016 1017 1018 1019 1020 1021 1022 1023 1024 1025 1026 1027 1028 1029 1030 1031 1032 1033 1034 1035 1036 1037 1038 1039 1040 1041 1042 1043 1044 1045 1046 1047 1048 1049 1050 1051 1052 1053 1054 1055 1056
/* 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())
 * 3. Loss detection event of one of three flavors:
 *	A. Scoreboard estimator decided the packet is lost.
 *	   A'. Reno "three dupacks" marks head of queue lost.
 *	   A''. Its FACK modfication, head until snd.fack is lost.
 *	B. SACK arrives sacking data transmitted after never retransmitted
 *	   hole was sent out.
 *	C. SACK arrives sacking SND.NXT at the moment, when the
 *	   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 已提交
1057 1058 1059 1060 1061 1062 1063
 *
 * 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
1064 1065 1066 1067 1068 1069 1070 1071 1072
 * 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 已提交
1073 1074 1075 1076 1077 1078 1079 1080 1081 1082 1083 1084 1085 1086 1087 1088 1089 1090 1091 1092 1093 1094
 *
 * 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
1095
 * again, D-SACK block must not to go across snd_una (for the same reason as
I
Ilpo Järvinen 已提交
1096 1097 1098 1099 1100 1101 1102 1103 1104
 * 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 已提交
1105
 */
I
Ilpo Järvinen 已提交
1106 1107 1108 1109 1110 1111 1112 1113 1114 1115 1116
static int tcp_is_sackblock_valid(struct tcp_sock *tp, int is_dsack,
				  u32 start_seq, u32 end_seq)
{
	/* Too far in future, or reversed (interpretation is ambiguous) */
	if (after(end_seq, tp->snd_nxt) || !before(start_seq, end_seq))
		return 0;

	/* Nasty start_seq wrap-around check (see comments above) */
	if (!before(start_seq, tp->snd_nxt))
		return 0;

1117
	/* In outstanding window? ...This is valid exit for D-SACKs too.
I
Ilpo Järvinen 已提交
1118 1119 1120 1121 1122 1123 1124 1125 1126 1127 1128 1129 1130 1131 1132 1133 1134 1135 1136 1137 1138 1139 1140 1141 1142
	 * start_seq == snd_una is non-sensical (see comments above)
	 */
	if (after(start_seq, tp->snd_una))
		return 1;

	if (!is_dsack || !tp->undo_marker)
		return 0;

	/* ...Then it's D-SACK, and must reside below snd_una completely */
	if (!after(end_seq, tp->snd_una))
		return 0;

	if (!before(start_seq, tp->undo_marker))
		return 1;

	/* Too old */
	if (!after(end_seq, tp->undo_marker))
		return 0;

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

1143 1144 1145
/* Check for lost retransmit. This superb idea is borrowed from "ratehalving".
 * Event "C". Later note: FACK people cheated me again 8), we have to account
 * for reordering! Ugly, but should help.
1146 1147 1148
 *
 * Search retransmitted skbs from write_queue that were sent when snd_nxt was
 * less than what is now known to be received by the other end (derived from
1149 1150
 * highest SACK block). Also calculate the lowest snd_nxt among the remaining
 * retransmitted skbs to avoid some costly processing per ACKs.
1151
 */
1152
static void tcp_mark_lost_retrans(struct sock *sk)
1153
{
1154
	const struct inet_connection_sock *icsk = inet_csk(sk);
1155 1156
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;
1157
	int cnt = 0;
1158
	u32 new_low_seq = tp->snd_nxt;
1159
	u32 received_upto = tcp_highest_sack_seq(tp);
1160 1161 1162 1163

	if (!tcp_is_fack(tp) || !tp->retrans_out ||
	    !after(received_upto, tp->lost_retrans_low) ||
	    icsk->icsk_ca_state != TCP_CA_Recovery)
1164
		return;
1165 1166 1167 1168 1169 1170

	tcp_for_write_queue(skb, sk) {
		u32 ack_seq = TCP_SKB_CB(skb)->ack_seq;

		if (skb == tcp_send_head(sk))
			break;
1171
		if (cnt == tp->retrans_out)
1172 1173 1174 1175
			break;
		if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
			continue;

1176 1177 1178
		if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS))
			continue;

1179 1180 1181 1182 1183 1184 1185 1186 1187 1188 1189 1190
		/* TODO: We would like to get rid of tcp_is_fack(tp) only
		 * constraint here (see above) but figuring out that at
		 * least tp->reordering SACK blocks reside between ack_seq
		 * and received_upto is not easy task to do cheaply with
		 * the available datastructures.
		 *
		 * Whether FACK should check here for tp->reordering segs
		 * in-between one could argue for either way (it would be
		 * rather simple to implement as we could count fack_count
		 * during the walk and do tp->fackets_out - fack_count).
		 */
		if (after(received_upto, ack_seq)) {
1191 1192 1193
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
			tp->retrans_out -= tcp_skb_pcount(skb);

1194
			tcp_skb_mark_lost_uncond_verify(tp, skb);
1195
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPLOSTRETRANSMIT);
1196
		} else {
1197
			if (before(ack_seq, new_low_seq))
1198
				new_low_seq = ack_seq;
1199
			cnt += tcp_skb_pcount(skb);
1200 1201
		}
	}
1202 1203 1204

	if (tp->retrans_out)
		tp->lost_retrans_low = new_low_seq;
1205
}
I
Ilpo Järvinen 已提交
1206

1207
static int tcp_check_dsack(struct sock *sk, struct sk_buff *ack_skb,
1208 1209 1210
			   struct tcp_sack_block_wire *sp, int num_sacks,
			   u32 prior_snd_una)
{
1211
	struct tcp_sock *tp = tcp_sk(sk);
1212 1213
	u32 start_seq_0 = get_unaligned_be32(&sp[0].start_seq);
	u32 end_seq_0 = get_unaligned_be32(&sp[0].end_seq);
1214 1215 1216 1217
	int dup_sack = 0;

	if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
		dup_sack = 1;
1218
		tcp_dsack_seen(tp);
1219
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
1220
	} else if (num_sacks > 1) {
1221 1222
		u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
		u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
1223 1224 1225 1226

		if (!after(end_seq_0, end_seq_1) &&
		    !before(start_seq_0, start_seq_1)) {
			dup_sack = 1;
1227
			tcp_dsack_seen(tp);
1228 1229
			NET_INC_STATS_BH(sock_net(sk),
					LINUX_MIB_TCPDSACKOFORECV);
1230 1231 1232 1233
		}
	}

	/* D-SACK for already forgotten data... Do dumb counting. */
Y
Yuchung Cheng 已提交
1234
	if (dup_sack && tp->undo_marker && tp->undo_retrans &&
1235 1236 1237 1238 1239 1240 1241
	    !after(end_seq_0, prior_snd_una) &&
	    after(end_seq_0, tp->undo_marker))
		tp->undo_retrans--;

	return dup_sack;
}

1242 1243 1244 1245 1246 1247
struct tcp_sacktag_state {
	int reord;
	int fack_count;
	int flag;
};

1248 1249 1250 1251 1252
/* 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).
1253 1254
 *
 * FIXME: this could be merged to shift decision code
1255
 */
1256 1257
static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
				 u32 start_seq, u32 end_seq)
1258 1259 1260
{
	int in_sack, err;
	unsigned int pkt_len;
1261
	unsigned int mss;
1262 1263 1264 1265 1266 1267

	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)) {
1268
		mss = tcp_skb_mss(skb);
1269 1270
		in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);

1271
		if (!in_sack) {
1272
			pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1273 1274 1275
			if (pkt_len < mss)
				pkt_len = mss;
		} else {
1276
			pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1277 1278 1279 1280 1281 1282 1283 1284 1285 1286 1287 1288 1289 1290 1291 1292 1293
			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;
				if (new_len > skb->len)
					return 0;
			}
			pkt_len = new_len;
		}
		err = tcp_fragment(sk, skb, pkt_len, mss);
1294 1295 1296 1297 1298 1299 1300
		if (err < 0)
			return err;
	}

	return in_sack;
}

1301 1302 1303
static u8 tcp_sacktag_one(struct sk_buff *skb, struct sock *sk,
			  struct tcp_sacktag_state *state,
			  int dup_sack, int pcount)
1304
{
1305
	struct tcp_sock *tp = tcp_sk(sk);
1306
	u8 sacked = TCP_SKB_CB(skb)->sacked;
1307
	int fack_count = state->fack_count;
1308 1309 1310

	/* Account D-SACK for retransmitted packet. */
	if (dup_sack && (sacked & TCPCB_RETRANS)) {
Y
Yuchung Cheng 已提交
1311 1312
		if (tp->undo_marker && tp->undo_retrans &&
		    after(TCP_SKB_CB(skb)->end_seq, tp->undo_marker))
1313
			tp->undo_retrans--;
1314
		if (sacked & TCPCB_SACKED_ACKED)
1315
			state->reord = min(fack_count, state->reord);
1316 1317 1318 1319
	}

	/* Nothing to do; acked frame is about to be dropped (was ACKed). */
	if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
1320
		return sacked;
1321 1322 1323 1324 1325 1326 1327 1328

	if (!(sacked & TCPCB_SACKED_ACKED)) {
		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) {
1329
				sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
1330 1331
				tp->lost_out -= pcount;
				tp->retrans_out -= pcount;
1332 1333 1334 1335 1336 1337 1338 1339
			}
		} else {
			if (!(sacked & TCPCB_RETRANS)) {
				/* New sack for not retransmitted frame,
				 * which was in hole. It is reordering.
				 */
				if (before(TCP_SKB_CB(skb)->seq,
					   tcp_highest_sack_seq(tp)))
1340 1341
					state->reord = min(fack_count,
							   state->reord);
1342 1343 1344

				/* SACK enhanced F-RTO (RFC4138; Appendix B) */
				if (!after(TCP_SKB_CB(skb)->end_seq, tp->frto_highmark))
1345
					state->flag |= FLAG_ONLY_ORIG_SACKED;
1346 1347 1348
			}

			if (sacked & TCPCB_LOST) {
1349
				sacked &= ~TCPCB_LOST;
1350
				tp->lost_out -= pcount;
1351 1352 1353
			}
		}

1354 1355
		sacked |= TCPCB_SACKED_ACKED;
		state->flag |= FLAG_DATA_SACKED;
1356
		tp->sacked_out += pcount;
1357

1358
		fack_count += pcount;
1359 1360 1361 1362 1363

		/* Lost marker hint past SACKed? Tweak RFC3517 cnt */
		if (!tcp_is_fack(tp) && (tp->lost_skb_hint != NULL) &&
		    before(TCP_SKB_CB(skb)->seq,
			   TCP_SKB_CB(tp->lost_skb_hint)->seq))
1364
			tp->lost_cnt_hint += pcount;
1365 1366 1367 1368 1369 1370 1371 1372 1373

		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.
	 */
1374 1375
	if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
		sacked &= ~TCPCB_SACKED_RETRANS;
1376
		tp->retrans_out -= pcount;
1377 1378
	}

1379
	return sacked;
1380 1381
}

1382
static int tcp_shifted_skb(struct sock *sk, struct sk_buff *skb,
1383
			   struct tcp_sacktag_state *state,
I
Ilpo Järvinen 已提交
1384 1385
			   unsigned int pcount, int shifted, int mss,
			   int dup_sack)
1386 1387
{
	struct tcp_sock *tp = tcp_sk(sk);
1388
	struct sk_buff *prev = tcp_write_queue_prev(sk, skb);
1389 1390 1391

	BUG_ON(!pcount);

1392 1393 1394 1395 1396
	/* Tweak before seqno plays */
	if (!tcp_is_fack(tp) && tcp_is_sack(tp) && tp->lost_skb_hint &&
	    !before(TCP_SKB_CB(tp->lost_skb_hint)->seq, TCP_SKB_CB(skb)->seq))
		tp->lost_cnt_hint += pcount;

1397 1398 1399 1400 1401 1402 1403 1404 1405 1406 1407 1408 1409 1410 1411 1412 1413 1414 1415 1416 1417 1418 1419
	TCP_SKB_CB(prev)->end_seq += shifted;
	TCP_SKB_CB(skb)->seq += shifted;

	skb_shinfo(prev)->gso_segs += pcount;
	BUG_ON(skb_shinfo(skb)->gso_segs < pcount);
	skb_shinfo(skb)->gso_segs -= pcount;

	/* 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.
	 */
	if (!skb_shinfo(prev)->gso_size) {
		skb_shinfo(prev)->gso_size = mss;
		skb_shinfo(prev)->gso_type = sk->sk_gso_type;
	}

	/* CHECKME: To clear or not to clear? Mimics normal skb currently */
	if (skb_shinfo(skb)->gso_segs <= 1) {
		skb_shinfo(skb)->gso_size = 0;
		skb_shinfo(skb)->gso_type = 0;
	}

1420
	/* We discard results */
I
Ilpo Järvinen 已提交
1421
	tcp_sacktag_one(skb, sk, state, dup_sack, pcount);
1422 1423 1424 1425 1426 1427

	/* 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));
1428
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKSHIFTED);
1429 1430 1431 1432 1433
		return 0;
	}

	/* Whole SKB was eaten :-) */

1434 1435 1436 1437 1438 1439 1440 1441 1442
	if (skb == tp->retransmit_skb_hint)
		tp->retransmit_skb_hint = prev;
	if (skb == tp->scoreboard_skb_hint)
		tp->scoreboard_skb_hint = prev;
	if (skb == tp->lost_skb_hint) {
		tp->lost_skb_hint = prev;
		tp->lost_cnt_hint -= tcp_skb_pcount(prev);
	}

1443 1444 1445 1446 1447 1448 1449
	TCP_SKB_CB(skb)->flags |= TCP_SKB_CB(prev)->flags;
	if (skb == tcp_highest_sack(sk))
		tcp_advance_highest_sack(sk, skb);

	tcp_unlink_write_queue(skb, sk);
	sk_wmem_free_skb(sk, skb);

1450 1451
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKMERGED);

1452 1453 1454 1455 1456 1457
	return 1;
}

/* I wish gso_size would have a bit more sane initialization than
 * something-or-zero which complicates things
 */
1458
static int tcp_skb_seglen(struct sk_buff *skb)
1459
{
1460
	return tcp_skb_pcount(skb) == 1 ? skb->len : tcp_skb_mss(skb);
1461 1462 1463 1464 1465 1466 1467 1468 1469 1470 1471 1472
}

/* Shifting pages past head area doesn't work */
static int skb_can_shift(struct sk_buff *skb)
{
	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,
1473
					  struct tcp_sacktag_state *state,
1474
					  u32 start_seq, u32 end_seq,
1475
					  int dup_sack)
1476 1477 1478 1479 1480 1481 1482 1483 1484 1485 1486 1487 1488
{
	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 &&
1489
	    (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1490 1491 1492 1493 1494 1495 1496 1497 1498 1499 1500 1501 1502 1503 1504 1505 1506 1507 1508 1509 1510
		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;

	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);
1511
		mss = tcp_skb_seglen(skb);
1512 1513 1514 1515

		/* TODO: Fix DSACKs to not fragment already SACKed and we can
		 * drop this restriction as unnecessary
		 */
1516
		if (mss != tcp_skb_seglen(prev))
1517 1518 1519 1520 1521 1522 1523 1524 1525 1526 1527 1528 1529 1530 1531 1532 1533 1534 1535 1536 1537 1538 1539 1540 1541 1542 1543 1544 1545 1546 1547 1548 1549 1550 1551 1552 1553 1554 1555 1556
			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
		 */
1557
		if (mss != tcp_skb_seglen(prev))
1558 1559 1560 1561 1562 1563 1564 1565 1566 1567 1568 1569 1570 1571
			goto fallback;

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

	if (!skb_shift(prev, skb, len))
		goto fallback;
I
Ilpo Järvinen 已提交
1572
	if (!tcp_shifted_skb(sk, skb, state, pcount, len, mss, dup_sack))
1573 1574 1575 1576 1577 1578 1579 1580 1581
		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);

1582 1583 1584
	if (!skb_can_shift(skb) ||
	    (skb == tcp_send_head(sk)) ||
	    ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1585
	    (mss != tcp_skb_seglen(skb)))
1586 1587 1588 1589 1590
		goto out;

	len = skb->len;
	if (skb_shift(prev, skb, len)) {
		pcount += tcp_skb_pcount(skb);
I
Ilpo Järvinen 已提交
1591
		tcp_shifted_skb(sk, skb, state, tcp_skb_pcount(skb), len, mss, 0);
1592 1593 1594
	}

out:
1595
	state->fack_count += pcount;
1596 1597 1598 1599 1600 1601
	return prev;

noop:
	return skb;

fallback:
1602
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1603 1604 1605
	return NULL;
}

1606 1607
static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
					struct tcp_sack_block *next_dup,
1608
					struct tcp_sacktag_state *state,
1609
					u32 start_seq, u32 end_seq,
1610
					int dup_sack_in)
1611
{
1612 1613 1614
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *tmp;

1615 1616 1617 1618 1619 1620 1621 1622 1623 1624 1625 1626 1627 1628 1629 1630 1631 1632 1633 1634
	tcp_for_write_queue_from(skb, sk) {
		int in_sack = 0;
		int dup_sack = dup_sack_in;

		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;

		if ((next_dup != NULL) &&
		    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)
				dup_sack = 1;
		}

1635 1636 1637 1638 1639
		/* 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) {
1640 1641
			tmp = tcp_shift_skb_data(sk, skb, state,
						 start_seq, end_seq, dup_sack);
1642 1643 1644 1645 1646 1647 1648 1649 1650 1651 1652 1653 1654 1655
			if (tmp != NULL) {
				if (tmp != skb) {
					skb = tmp;
					continue;
				}

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

1656 1657 1658
		if (unlikely(in_sack < 0))
			break;

1659
		if (in_sack) {
1660 1661 1662 1663
			TCP_SKB_CB(skb)->sacked = tcp_sacktag_one(skb, sk,
								  state,
								  dup_sack,
								  tcp_skb_pcount(skb));
1664

1665 1666 1667 1668 1669
			if (!before(TCP_SKB_CB(skb)->seq,
				    tcp_highest_sack_seq(tp)))
				tcp_advance_highest_sack(sk, skb);
		}

1670
		state->fack_count += tcp_skb_pcount(skb);
1671 1672 1673 1674 1675 1676 1677 1678
	}
	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,
1679 1680
					struct tcp_sacktag_state *state,
					u32 skip_to_seq)
1681 1682 1683 1684 1685
{
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;

I
Ilpo Järvinen 已提交
1686
		if (after(TCP_SKB_CB(skb)->end_seq, skip_to_seq))
1687
			break;
1688

1689
		state->fack_count += tcp_skb_pcount(skb);
1690 1691 1692 1693 1694 1695 1696
	}
	return skb;
}

static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
						struct sock *sk,
						struct tcp_sack_block *next_dup,
1697 1698
						struct tcp_sacktag_state *state,
						u32 skip_to_seq)
1699 1700 1701 1702 1703
{
	if (next_dup == NULL)
		return skb;

	if (before(next_dup->start_seq, skip_to_seq)) {
1704 1705 1706 1707
		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);
1708 1709 1710 1711 1712 1713 1714 1715 1716 1717
	}

	return skb;
}

static int tcp_sack_cache_ok(struct tcp_sock *tp, struct tcp_sack_block *cache)
{
	return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
}

L
Linus Torvalds 已提交
1718
static int
1719 1720
tcp_sacktag_write_queue(struct sock *sk, struct sk_buff *ack_skb,
			u32 prior_snd_una)
L
Linus Torvalds 已提交
1721
{
1722
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
1723
	struct tcp_sock *tp = tcp_sk(sk);
1724 1725
	unsigned char *ptr = (skb_transport_header(ack_skb) +
			      TCP_SKB_CB(ack_skb)->sacked);
1726
	struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);
1727
	struct tcp_sack_block sp[TCP_NUM_SACKS];
1728
	struct tcp_sack_block *cache;
1729
	struct tcp_sacktag_state state;
1730
	struct sk_buff *skb;
1731
	int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);
1732
	int used_sacks;
1733
	int found_dup_sack = 0;
1734
	int i, j;
1735
	int first_sack_index;
L
Linus Torvalds 已提交
1736

1737 1738 1739
	state.flag = 0;
	state.reord = tp->packets_out;

1740
	if (!tp->sacked_out) {
1741 1742
		if (WARN_ON(tp->fackets_out))
			tp->fackets_out = 0;
1743
		tcp_highest_sack_reset(sk);
1744
	}
L
Linus Torvalds 已提交
1745

1746
	found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,
1747 1748
					 num_sacks, prior_snd_una);
	if (found_dup_sack)
1749
		state.flag |= FLAG_DSACKING_ACK;
1750 1751 1752 1753 1754 1755 1756 1757

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

1758 1759 1760
	if (!tp->packets_out)
		goto out;

1761 1762 1763 1764 1765
	used_sacks = 0;
	first_sack_index = 0;
	for (i = 0; i < num_sacks; i++) {
		int dup_sack = !i && found_dup_sack;

1766 1767
		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);
1768 1769 1770 1771

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

1774 1775
			if (dup_sack) {
				if (!tp->undo_marker)
1776
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;
1777
				else
1778
					mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;
1779 1780 1781 1782 1783
			} 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;
1784
				mib_idx = LINUX_MIB_TCPSACKDISCARD;
1785
			}
1786

1787
			NET_INC_STATS_BH(sock_net(sk), mib_idx);
1788 1789 1790 1791 1792 1793 1794 1795 1796 1797 1798 1799
			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++;
	}

1800 1801
	/* order SACK blocks to allow in order walk of the retrans queue */
	for (i = used_sacks - 1; i > 0; i--) {
1802 1803
		for (j = 0; j < i; j++) {
			if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1804
				swap(sp[j], sp[j + 1]);
1805

1806 1807
				/* Track where the first SACK block goes to */
				if (j == first_sack_index)
1808
					first_sack_index = j + 1;
1809 1810 1811 1812
			}
		}
	}

1813
	skb = tcp_write_queue_head(sk);
1814
	state.fack_count = 0;
1815 1816 1817 1818 1819 1820 1821 1822 1823 1824 1825
	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++;
1826 1827
	}

1828
	while (i < used_sacks) {
1829 1830
		u32 start_seq = sp[i].start_seq;
		u32 end_seq = sp[i].end_seq;
1831
		int dup_sack = (found_dup_sack && (i == first_sack_index));
1832
		struct tcp_sack_block *next_dup = NULL;
1833

1834 1835
		if (found_dup_sack && ((i + 1) == first_sack_index))
			next_dup = &sp[i + 1];
L
Linus Torvalds 已提交
1836 1837 1838

		/* Event "B" in the comment above. */
		if (after(end_seq, tp->high_seq))
1839
			state.flag |= FLAG_DATA_LOST;
L
Linus Torvalds 已提交
1840

1841 1842 1843 1844 1845 1846 1847 1848 1849 1850 1851
		/* 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)) {
1852 1853
				skb = tcp_sacktag_skip(skb, sk, &state,
						       start_seq);
1854
				skb = tcp_sacktag_walk(skb, sk, next_dup,
1855
						       &state,
1856 1857
						       start_seq,
						       cache->start_seq,
1858
						       dup_sack);
1859
			}
1860

1861
			/* Rest of the block already fully processed? */
1862
			if (!after(end_seq, cache->end_seq))
1863
				goto advance_sp;
1864

1865
			skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
1866 1867
						       &state,
						       cache->end_seq);
1868

1869
			/* ...tail remains todo... */
1870
			if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1871
				/* ...but better entrypoint exists! */
1872 1873 1874
				skb = tcp_highest_sack(sk);
				if (skb == NULL)
					break;
1875
				state.fack_count = tp->fackets_out;
1876 1877
				cache++;
				goto walk;
1878 1879
			}

1880
			skb = tcp_sacktag_skip(skb, sk, &state, cache->end_seq);
1881 1882 1883 1884
			/* Check overlap against next cached too (past this one already) */
			cache++;
			continue;
		}
L
Linus Torvalds 已提交
1885

1886 1887 1888 1889
		if (!before(start_seq, tcp_highest_sack_seq(tp))) {
			skb = tcp_highest_sack(sk);
			if (skb == NULL)
				break;
1890
			state.fack_count = tp->fackets_out;
L
Linus Torvalds 已提交
1891
		}
1892
		skb = tcp_sacktag_skip(skb, sk, &state, start_seq);
1893 1894

walk:
1895 1896
		skb = tcp_sacktag_walk(skb, sk, next_dup, &state,
				       start_seq, end_seq, dup_sack);
1897

1898
advance_sp:
1899 1900 1901 1902
		/* SACK enhanced FRTO (RFC4138, Appendix B): Clearing correct
		 * due to in-order walk
		 */
		if (after(end_seq, tp->frto_highmark))
1903
			state.flag &= ~FLAG_ONLY_ORIG_SACKED;
1904 1905

		i++;
L
Linus Torvalds 已提交
1906 1907
	}

1908 1909 1910 1911 1912 1913 1914 1915
	/* 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];

1916
	tcp_mark_lost_retrans(sk);
L
Linus Torvalds 已提交
1917

1918 1919
	tcp_verify_left_out(tp);

1920
	if ((state.reord < tp->fackets_out) &&
1921
	    ((icsk->icsk_ca_state != TCP_CA_Loss) || tp->undo_marker) &&
1922
	    (!tp->frto_highmark || after(tp->snd_una, tp->frto_highmark)))
1923
		tcp_update_reordering(sk, tp->fackets_out - state.reord, 0);
L
Linus Torvalds 已提交
1924

1925 1926
out:

L
Linus Torvalds 已提交
1927
#if FASTRETRANS_DEBUG > 0
1928 1929 1930 1931
	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 已提交
1932
#endif
1933
	return state.flag;
L
Linus Torvalds 已提交
1934 1935
}

1936 1937
/* Limits sacked_out so that sum with lost_out isn't ever larger than
 * packets_out. Returns zero if sacked_out adjustement wasn't necessary.
1938
 */
1939
static int tcp_limit_reno_sacked(struct tcp_sock *tp)
1940 1941 1942 1943 1944 1945 1946 1947
{
	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;
1948
		return 1;
1949
	}
1950 1951 1952 1953 1954 1955 1956 1957 1958 1959 1960 1961
	return 0;
}

/* 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);
1962 1963 1964 1965 1966 1967 1968 1969 1970
}

/* 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);
	tp->sacked_out++;
	tcp_check_reno_reordering(sk, 0);
1971
	tcp_verify_left_out(tp);
1972 1973 1974 1975 1976 1977 1978 1979 1980 1981
}

/* 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. */
1982
		if (acked - 1 >= tp->sacked_out)
1983 1984
			tp->sacked_out = 0;
		else
1985
			tp->sacked_out -= acked - 1;
1986 1987
	}
	tcp_check_reno_reordering(sk, acked);
1988
	tcp_verify_left_out(tp);
1989 1990 1991 1992 1993 1994 1995
}

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

1996 1997 1998 1999 2000
static int tcp_is_sackfrto(const struct tcp_sock *tp)
{
	return (sysctl_tcp_frto == 0x2) && !tcp_is_reno(tp);
}

2001 2002 2003
/* F-RTO can only be used if TCP has never retransmitted anything other than
 * head (SACK enhanced variant from Appendix B of RFC4138 is more robust here)
 */
2004
int tcp_use_frto(struct sock *sk)
2005 2006
{
	const struct tcp_sock *tp = tcp_sk(sk);
2007
	const struct inet_connection_sock *icsk = inet_csk(sk);
2008 2009
	struct sk_buff *skb;

2010
	if (!sysctl_tcp_frto)
2011
		return 0;
2012

2013 2014 2015 2016
	/* MTU probe and F-RTO won't really play nicely along currently */
	if (icsk->icsk_mtup.probe_size)
		return 0;

2017
	if (tcp_is_sackfrto(tp))
I
Ilpo Järvinen 已提交
2018 2019
		return 1;

2020 2021 2022 2023
	/* Avoid expensive walking of rexmit queue if possible */
	if (tp->retrans_out > 1)
		return 0;

2024
	skb = tcp_write_queue_head(sk);
2025 2026
	if (tcp_skb_is_last(sk, skb))
		return 1;
2027 2028 2029 2030
	skb = tcp_write_queue_next(sk, skb);	/* Skips head */
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2031
		if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
2032 2033
			return 0;
		/* Short-circuit when first non-SACKed skb has been checked */
2034
		if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
2035 2036 2037
			break;
	}
	return 1;
2038 2039
}

2040 2041
/* RTO occurred, but do not yet enter Loss state. Instead, defer RTO
 * recovery a bit and use heuristics in tcp_process_frto() to detect if
2042 2043 2044 2045 2046
 * the RTO was spurious. Only clear SACKED_RETRANS of the head here to
 * keep retrans_out counting accurate (with SACK F-RTO, other than head
 * may still have that bit set); TCPCB_LOST and remaining SACKED_RETRANS
 * bits are handled if the Loss state is really to be entered (in
 * tcp_enter_frto_loss).
2047 2048 2049 2050
 *
 * Do like tcp_enter_loss() would; when RTO expires the second time it
 * does:
 *  "Reduce ssthresh if it has not yet been made inside this window."
L
Linus Torvalds 已提交
2051 2052 2053
 */
void tcp_enter_frto(struct sock *sk)
{
2054
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2055 2056 2057
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

2058
	if ((!tp->frto_counter && icsk->icsk_ca_state <= TCP_CA_Disorder) ||
2059
	    tp->snd_una == tp->high_seq ||
2060 2061
	    ((icsk->icsk_ca_state == TCP_CA_Loss || tp->frto_counter) &&
	     !icsk->icsk_retransmits)) {
2062
		tp->prior_ssthresh = tcp_current_ssthresh(sk);
2063
		/* Our state is too optimistic in ssthresh() call because cwnd
2064
		 * is not reduced until tcp_enter_frto_loss() when previous F-RTO
2065 2066 2067 2068 2069 2070 2071 2072 2073 2074 2075 2076 2077 2078 2079 2080 2081 2082 2083 2084 2085 2086 2087
		 * recovery has not yet completed. Pattern would be this: RTO,
		 * Cumulative ACK, RTO (2xRTO for the same segment does not end
		 * up here twice).
		 * RFC4138 should be more specific on what to do, even though
		 * RTO is quite unlikely to occur after the first Cumulative ACK
		 * due to back-off and complexity of triggering events ...
		 */
		if (tp->frto_counter) {
			u32 stored_cwnd;
			stored_cwnd = tp->snd_cwnd;
			tp->snd_cwnd = 2;
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
			tp->snd_cwnd = stored_cwnd;
		} else {
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
		}
		/* ... in theory, cong.control module could do "any tricks" in
		 * ssthresh(), which means that ca_state, lost bits and lost_out
		 * counter would have to be faked before the call occurs. We
		 * consider that too expensive, unlikely and hacky, so modules
		 * using these in ssthresh() must deal these incompatibility
		 * issues if they receives CA_EVENT_FRTO and frto_counter != 0
		 */
2088
		tcp_ca_event(sk, CA_EVENT_FRTO);
L
Linus Torvalds 已提交
2089 2090 2091 2092 2093
	}

	tp->undo_marker = tp->snd_una;
	tp->undo_retrans = 0;

2094
	skb = tcp_write_queue_head(sk);
2095 2096
	if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
		tp->undo_marker = 0;
2097
	if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
2098
		TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
2099
		tp->retrans_out -= tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
2100
	}
2101
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2102

2103 2104 2105
	/* Too bad if TCP was application limited */
	tp->snd_cwnd = min(tp->snd_cwnd, tcp_packets_in_flight(tp) + 1);

I
Ilpo Järvinen 已提交
2106 2107 2108
	/* Earlier loss recovery underway (see RFC4138; Appendix B).
	 * The last condition is necessary at least in tp->frto_counter case.
	 */
2109
	if (tcp_is_sackfrto(tp) && (tp->frto_counter ||
I
Ilpo Järvinen 已提交
2110 2111 2112 2113 2114 2115
	    ((1 << icsk->icsk_ca_state) & (TCPF_CA_Recovery|TCPF_CA_Loss))) &&
	    after(tp->high_seq, tp->snd_una)) {
		tp->frto_highmark = tp->high_seq;
	} else {
		tp->frto_highmark = tp->snd_nxt;
	}
2116 2117
	tcp_set_ca_state(sk, TCP_CA_Disorder);
	tp->high_seq = tp->snd_nxt;
2118
	tp->frto_counter = 1;
L
Linus Torvalds 已提交
2119 2120 2121 2122 2123 2124
}

/* Enter Loss state after F-RTO was applied. Dupack arrived after RTO,
 * which indicates that we should follow the traditional RTO recovery,
 * i.e. mark everything lost and do go-back-N retransmission.
 */
2125
static void tcp_enter_frto_loss(struct sock *sk, int allowed_segments, int flag)
L
Linus Torvalds 已提交
2126 2127 2128 2129 2130
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	tp->lost_out = 0;
2131
	tp->retrans_out = 0;
2132
	if (tcp_is_reno(tp))
2133
		tcp_reset_reno_sack(tp);
L
Linus Torvalds 已提交
2134

2135 2136 2137
	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2138 2139

		TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
2140 2141 2142 2143
		/*
		 * Count the retransmission made on RTO correctly (only when
		 * waiting for the first ACK and did not get it)...
		 */
2144
		if ((tp->frto_counter == 1) && !(flag & FLAG_DATA_ACKED)) {
2145 2146 2147
			/* For some reason this R-bit might get cleared? */
			if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS)
				tp->retrans_out += tcp_skb_pcount(skb);
2148 2149 2150
			/* ...enter this if branch just for the first segment */
			flag |= FLAG_DATA_ACKED;
		} else {
2151 2152
			if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
				tp->undo_marker = 0;
2153
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
2154
		}
L
Linus Torvalds 已提交
2155

2156 2157 2158 2159 2160 2161 2162 2163 2164 2165
		/* Marking forward transmissions that were made after RTO lost
		 * can cause unnecessary retransmissions in some scenarios,
		 * SACK blocks will mitigate that in some but not in all cases.
		 * We used to not mark them but it was causing break-ups with
		 * receivers that do only in-order receival.
		 *
		 * TODO: we could detect presence of such receiver and select
		 * different behavior per flow.
		 */
		if (!(TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)) {
2166 2167
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
2168
			tp->retransmit_high = TCP_SKB_CB(skb)->end_seq;
L
Linus Torvalds 已提交
2169 2170
		}
	}
2171
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2172

2173
	tp->snd_cwnd = tcp_packets_in_flight(tp) + allowed_segments;
L
Linus Torvalds 已提交
2174 2175 2176
	tp->snd_cwnd_cnt = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;
	tp->frto_counter = 0;
2177
	tp->bytes_acked = 0;
L
Linus Torvalds 已提交
2178 2179

	tp->reordering = min_t(unsigned int, tp->reordering,
2180
			       sysctl_tcp_reordering);
2181
	tcp_set_ca_state(sk, TCP_CA_Loss);
2182
	tp->high_seq = tp->snd_nxt;
L
Linus Torvalds 已提交
2183
	TCP_ECN_queue_cwr(tp);
2184

2185
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
2186 2187
}

2188
static void tcp_clear_retrans_partial(struct tcp_sock *tp)
L
Linus Torvalds 已提交
2189 2190 2191 2192 2193 2194 2195 2196
{
	tp->retrans_out = 0;
	tp->lost_out = 0;

	tp->undo_marker = 0;
	tp->undo_retrans = 0;
}

2197 2198 2199 2200 2201 2202 2203 2204
void tcp_clear_retrans(struct tcp_sock *tp)
{
	tcp_clear_retrans_partial(tp);

	tp->fackets_out = 0;
	tp->sacked_out = 0;
}

L
Linus Torvalds 已提交
2205 2206 2207 2208 2209 2210
/* Enter Loss state. If "how" is not zero, forget all SACK information
 * and reset tags completely, otherwise preserve SACKs. If receiver
 * dropped its ofo queue, we will know this due to reneging detection.
 */
void tcp_enter_loss(struct sock *sk, int how)
{
2211
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2212 2213 2214 2215
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	/* Reduce ssthresh if it has not yet been made inside this window. */
2216 2217 2218 2219 2220
	if (icsk->icsk_ca_state <= TCP_CA_Disorder || tp->snd_una == tp->high_seq ||
	    (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);
L
Linus Torvalds 已提交
2221 2222 2223 2224 2225
	}
	tp->snd_cwnd	   = 1;
	tp->snd_cwnd_cnt   = 0;
	tp->snd_cwnd_stamp = tcp_time_stamp;

2226
	tp->bytes_acked = 0;
2227 2228 2229 2230
	tcp_clear_retrans_partial(tp);

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

2232 2233 2234
	if (!how) {
		/* Push undo marker, if it was plain RTO and nothing
		 * was retransmitted. */
L
Linus Torvalds 已提交
2235
		tp->undo_marker = tp->snd_una;
2236
	} else {
2237 2238
		tp->sacked_out = 0;
		tp->fackets_out = 0;
2239
	}
2240
	tcp_clear_all_retrans_hints(tp);
L
Linus Torvalds 已提交
2241

2242 2243 2244
	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2245

2246
		if (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS)
L
Linus Torvalds 已提交
2247 2248 2249 2250 2251 2252
			tp->undo_marker = 0;
		TCP_SKB_CB(skb)->sacked &= (~TCPCB_TAGBITS)|TCPCB_SACKED_ACKED;
		if (!(TCP_SKB_CB(skb)->sacked&TCPCB_SACKED_ACKED) || how) {
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
			TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
			tp->lost_out += tcp_skb_pcount(skb);
2253
			tp->retransmit_high = TCP_SKB_CB(skb)->end_seq;
L
Linus Torvalds 已提交
2254 2255
		}
	}
2256
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2257 2258

	tp->reordering = min_t(unsigned int, tp->reordering,
2259
			       sysctl_tcp_reordering);
2260
	tcp_set_ca_state(sk, TCP_CA_Loss);
L
Linus Torvalds 已提交
2261 2262
	tp->high_seq = tp->snd_nxt;
	TCP_ECN_queue_cwr(tp);
2263
	/* Abort F-RTO algorithm if one is in progress */
2264
	tp->frto_counter = 0;
L
Linus Torvalds 已提交
2265 2266
}

2267 2268 2269 2270 2271 2272 2273
/* 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).
 *
 * Do processing similar to RTO timeout.
 */
static int tcp_check_sack_reneging(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2274
{
2275
	if (flag & FLAG_SACK_RENEGING) {
2276
		struct inet_connection_sock *icsk = inet_csk(sk);
2277
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
L
Linus Torvalds 已提交
2278 2279

		tcp_enter_loss(sk, 1);
2280
		icsk->icsk_retransmits++;
2281
		tcp_retransmit_skb(sk, tcp_write_queue_head(sk));
2282
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2283
					  icsk->icsk_rto, TCP_RTO_MAX);
L
Linus Torvalds 已提交
2284 2285 2286 2287 2288 2289 2290
		return 1;
	}
	return 0;
}

static inline int tcp_fackets_out(struct tcp_sock *tp)
{
2291
	return tcp_is_reno(tp) ? tp->sacked_out + 1 : tp->fackets_out;
L
Linus Torvalds 已提交
2292 2293
}

2294 2295 2296 2297 2298 2299 2300 2301 2302 2303 2304 2305 2306 2307 2308
/* 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.
 */
2309
static inline int tcp_dupack_heuristics(struct tcp_sock *tp)
2310 2311 2312 2313
{
	return tcp_is_fack(tp) ? tp->fackets_out : tp->sacked_out + 1;
}

2314
static inline int tcp_skb_timedout(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
2315
{
E
Eric Dumazet 已提交
2316
	return tcp_time_stamp - TCP_SKB_CB(skb)->when > inet_csk(sk)->icsk_rto;
L
Linus Torvalds 已提交
2317 2318
}

2319
static inline int tcp_head_timedout(struct sock *sk)
L
Linus Torvalds 已提交
2320
{
2321 2322
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2323
	return tp->packets_out &&
2324
	       tcp_skb_timedout(sk, tcp_write_queue_head(sk));
L
Linus Torvalds 已提交
2325 2326 2327 2328 2329 2330 2331 2332 2333 2334 2335 2336 2337 2338 2339 2340 2341 2342 2343 2344 2345 2346 2347 2348 2349 2350 2351 2352 2353 2354 2355 2356 2357 2358 2359 2360 2361 2362 2363 2364 2365 2366 2367 2368 2369 2370 2371 2372 2373 2374 2375 2376 2377 2378 2379 2380 2381 2382 2383 2384 2385 2386 2387 2388 2389 2390 2391 2392 2393 2394 2395 2396 2397 2398 2399 2400 2401 2402 2403 2404 2405 2406 2407 2408 2409 2410 2411 2412 2413 2414 2415 2416 2417 2418 2419
}

/* 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.
 *
 *		Essentially, we have now two algorithms counting
 *		lost packets.
 *
 *		FACK: It is the simplest heuristics. As soon as we decided
 *		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.
 *
 *		NewReno: when Recovery is entered, we assume that one segment
 *		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.
 *
 *  Imagine, that's all! Forget about all this shamanism about CWND inflation
 *  deflation etc. CWND is real congestion window, never inflated, changes
 *  only according to classic VJ rules.
 *
 * 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?
 */
2420
static int tcp_time_to_recover(struct sock *sk)
L
Linus Torvalds 已提交
2421
{
2422
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2423 2424
	__u32 packets_out;

2425
	/* Do not perform any recovery during F-RTO algorithm */
2426 2427 2428
	if (tp->frto_counter)
		return 0;

L
Linus Torvalds 已提交
2429 2430 2431 2432 2433
	/* Trick#1: The loss is proven. */
	if (tp->lost_out)
		return 1;

	/* Not-A-Trick#2 : Classic rule... */
2434
	if (tcp_dupack_heuristics(tp) > tp->reordering)
L
Linus Torvalds 已提交
2435 2436 2437 2438 2439
		return 1;

	/* Trick#3 : when we use RFC2988 timer restart, fast
	 * retransmit can be triggered by timeout of queue head.
	 */
2440
	if (tcp_is_fack(tp) && tcp_head_timedout(sk))
L
Linus Torvalds 已提交
2441 2442 2443 2444 2445 2446 2447 2448
		return 1;

	/* Trick#4: It is still not OK... But will it be useful to delay
	 * recovery more?
	 */
	packets_out = tp->packets_out;
	if (packets_out <= tp->reordering &&
	    tp->sacked_out >= max_t(__u32, packets_out/2, sysctl_tcp_reordering) &&
2449
	    !tcp_may_send_now(sk)) {
L
Linus Torvalds 已提交
2450 2451 2452 2453 2454 2455
		/* We have nothing to send. This connection is limited
		 * either by receiver window or by application.
		 */
		return 1;
	}

A
Andreas Petlund 已提交
2456 2457 2458 2459 2460 2461 2462 2463 2464 2465
	/* If a thin stream is detected, retransmit after first
	 * received dupack. Employ only if SACK is supported in order
	 * to avoid possible corner-case series of spurious retransmissions
	 * Use only if there are no unsent data.
	 */
	if ((tp->thin_dupack || sysctl_tcp_thin_dupack) &&
	    tcp_stream_is_thin(tp) && tcp_dupack_heuristics(tp) > 1 &&
	    tcp_is_sack(tp) && !tcp_send_head(sk))
		return 1;

L
Linus Torvalds 已提交
2466 2467 2468
	return 0;
}

2469 2470 2471 2472 2473 2474 2475 2476 2477 2478 2479 2480 2481 2482 2483 2484 2485 2486 2487 2488 2489 2490 2491 2492 2493 2494 2495 2496 2497 2498 2499 2500 2501 2502 2503 2504 2505 2506
/* New heuristics: it is possible only after we switched to restart timer
 * each time when something is ACKed. Hence, we can detect timed out packets
 * during fast retransmit without falling to slow start.
 *
 * Usefulness of this as is very questionable, since we should know which of
 * the segments is the next to timeout which is relatively expensive to find
 * in general case unless we add some data structure just for that. The
 * current approach certainly won't find the right one too often and when it
 * finally does find _something_ it usually marks large part of the window
 * right away (because a retransmission with a larger timestamp blocks the
 * loop from advancing). -ij
 */
static void tcp_timeout_skbs(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	if (!tcp_is_fack(tp) || !tcp_head_timedout(sk))
		return;

	skb = tp->scoreboard_skb_hint;
	if (tp->scoreboard_skb_hint == NULL)
		skb = tcp_write_queue_head(sk);

	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
		if (!tcp_skb_timedout(sk, skb))
			break;

		tcp_skb_mark_lost(tp, skb);
	}

	tp->scoreboard_skb_hint = skb;

	tcp_verify_left_out(tp);
}

2507 2508 2509
/* Mark head of queue up as lost. With RFC3517 SACK, the packets is
 * is against sacked "cnt", otherwise it's against facked "cnt"
 */
I
Ilpo Järvinen 已提交
2510
static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
L
Linus Torvalds 已提交
2511
{
2512
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2513
	struct sk_buff *skb;
2514 2515 2516
	int cnt, oldcnt;
	int err;
	unsigned int mss;
L
Linus Torvalds 已提交
2517

2518
	WARN_ON(packets > tp->packets_out);
2519 2520 2521
	if (tp->lost_skb_hint) {
		skb = tp->lost_skb_hint;
		cnt = tp->lost_cnt_hint;
I
Ilpo Järvinen 已提交
2522 2523 2524
		/* Head already handled? */
		if (mark_head && skb != tcp_write_queue_head(sk))
			return;
2525
	} else {
2526
		skb = tcp_write_queue_head(sk);
2527 2528
		cnt = 0;
	}
L
Linus Torvalds 已提交
2529

2530 2531 2532
	tcp_for_write_queue_from(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2533 2534 2535 2536
		/* TODO: do this better */
		/* this is not the most efficient way to do this... */
		tp->lost_skb_hint = skb;
		tp->lost_cnt_hint = cnt;
2537

2538 2539 2540 2541
		if (after(TCP_SKB_CB(skb)->end_seq, tp->high_seq))
			break;

		oldcnt = cnt;
2542
		if (tcp_is_fack(tp) || tcp_is_reno(tp) ||
2543 2544 2545
		    (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
			cnt += tcp_skb_pcount(skb);

2546
		if (cnt > packets) {
2547 2548
			if ((tcp_is_sack(tp) && !tcp_is_fack(tp)) ||
			    (oldcnt >= packets))
2549 2550 2551 2552 2553 2554 2555 2556 2557
				break;

			mss = skb_shinfo(skb)->gso_size;
			err = tcp_fragment(sk, skb, (packets - oldcnt) * mss, mss);
			if (err < 0)
				break;
			cnt = packets;
		}

2558
		tcp_skb_mark_lost(tp, skb);
I
Ilpo Järvinen 已提交
2559 2560 2561

		if (mark_head)
			break;
L
Linus Torvalds 已提交
2562
	}
2563
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2564 2565 2566 2567
}

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

2568
static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
L
Linus Torvalds 已提交
2569
{
2570 2571
	struct tcp_sock *tp = tcp_sk(sk);

2572
	if (tcp_is_reno(tp)) {
I
Ilpo Järvinen 已提交
2573
		tcp_mark_head_lost(sk, 1, 1);
2574
	} else if (tcp_is_fack(tp)) {
L
Linus Torvalds 已提交
2575 2576 2577
		int lost = tp->fackets_out - tp->reordering;
		if (lost <= 0)
			lost = 1;
I
Ilpo Järvinen 已提交
2578
		tcp_mark_head_lost(sk, lost, 0);
L
Linus Torvalds 已提交
2579
	} else {
2580
		int sacked_upto = tp->sacked_out - tp->reordering;
I
Ilpo Järvinen 已提交
2581 2582 2583 2584
		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 已提交
2585 2586
	}

2587
	tcp_timeout_skbs(sk);
L
Linus Torvalds 已提交
2588 2589 2590 2591 2592 2593 2594 2595
}

/* CWND moderation, preventing bursts due to too big ACKs
 * in dubious situations.
 */
static inline void tcp_moderate_cwnd(struct tcp_sock *tp)
{
	tp->snd_cwnd = min(tp->snd_cwnd,
2596
			   tcp_packets_in_flight(tp) + tcp_max_burst(tp));
L
Linus Torvalds 已提交
2597 2598 2599
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

2600 2601 2602 2603 2604 2605 2606 2607 2608 2609
/* Lower bound on congestion window is slow start threshold
 * unless congestion avoidance choice decides to overide it.
 */
static inline u32 tcp_cwnd_min(const struct sock *sk)
{
	const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;

	return ca_ops->min_cwnd ? ca_ops->min_cwnd(sk) : tcp_sk(sk)->snd_ssthresh;
}

L
Linus Torvalds 已提交
2610
/* Decrease cwnd each second ack. */
2611
static void tcp_cwnd_down(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2612
{
2613
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2614 2615
	int decr = tp->snd_cwnd_cnt + 1;

2616 2617 2618
	if ((flag & (FLAG_ANY_PROGRESS | FLAG_DSACKING_ACK)) ||
	    (tcp_is_reno(tp) && !(flag & FLAG_NOT_DUP))) {
		tp->snd_cwnd_cnt = decr & 1;
2619
		decr >>= 1;
L
Linus Torvalds 已提交
2620

2621 2622
		if (decr && tp->snd_cwnd > tcp_cwnd_min(sk))
			tp->snd_cwnd -= decr;
L
Linus Torvalds 已提交
2623

2624
		tp->snd_cwnd = min(tp->snd_cwnd, tcp_packets_in_flight(tp) + 1);
2625 2626
		tp->snd_cwnd_stamp = tcp_time_stamp;
	}
L
Linus Torvalds 已提交
2627 2628 2629 2630 2631 2632 2633 2634 2635
}

/* Nothing was retransmitted or returned timestamp is less
 * than timestamp of the first retransmission.
 */
static inline int tcp_packet_delayed(struct tcp_sock *tp)
{
	return !tp->retrans_stamp ||
		(tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2636
		 before(tp->rx_opt.rcv_tsecr, tp->retrans_stamp));
L
Linus Torvalds 已提交
2637 2638 2639 2640 2641
}

/* Undo procedures. */

#if FASTRETRANS_DEBUG > 1
2642
static void DBGUNDO(struct sock *sk, const char *msg)
L
Linus Torvalds 已提交
2643
{
2644
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2645
	struct inet_sock *inet = inet_sk(sk);
2646

2647
	if (sk->sk_family == AF_INET) {
2648
		printk(KERN_DEBUG "Undo %s %pI4/%u c%u l%u ss%u/%u p%u\n",
2649
		       msg,
2650
		       &inet->inet_daddr, ntohs(inet->inet_dport),
2651 2652 2653 2654 2655 2656 2657
		       tp->snd_cwnd, tcp_left_out(tp),
		       tp->snd_ssthresh, tp->prior_ssthresh,
		       tp->packets_out);
	}
#if defined(CONFIG_IPV6) || defined(CONFIG_IPV6_MODULE)
	else if (sk->sk_family == AF_INET6) {
		struct ipv6_pinfo *np = inet6_sk(sk);
H
Harvey Harrison 已提交
2658
		printk(KERN_DEBUG "Undo %s %pI6/%u c%u l%u ss%u/%u p%u\n",
2659
		       msg,
2660
		       &np->daddr, ntohs(inet->inet_dport),
2661 2662 2663 2664 2665
		       tp->snd_cwnd, tcp_left_out(tp),
		       tp->snd_ssthresh, tp->prior_ssthresh,
		       tp->packets_out);
	}
#endif
L
Linus Torvalds 已提交
2666 2667 2668 2669 2670
}
#else
#define DBGUNDO(x...) do { } while (0)
#endif

2671
static void tcp_undo_cwr(struct sock *sk, const bool undo_ssthresh)
L
Linus Torvalds 已提交
2672
{
2673 2674
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2675
	if (tp->prior_ssthresh) {
2676 2677 2678 2679
		const struct inet_connection_sock *icsk = inet_csk(sk);

		if (icsk->icsk_ca_ops->undo_cwnd)
			tp->snd_cwnd = icsk->icsk_ca_ops->undo_cwnd(sk);
L
Linus Torvalds 已提交
2680
		else
2681
			tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh << 1);
L
Linus Torvalds 已提交
2682

2683
		if (undo_ssthresh && tp->prior_ssthresh > tp->snd_ssthresh) {
L
Linus Torvalds 已提交
2684 2685 2686 2687 2688 2689 2690 2691 2692 2693 2694
			tp->snd_ssthresh = tp->prior_ssthresh;
			TCP_ECN_withdraw_cwr(tp);
		}
	} else {
		tp->snd_cwnd = max(tp->snd_cwnd, tp->snd_ssthresh);
	}
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

static inline int tcp_may_undo(struct tcp_sock *tp)
{
2695
	return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
L
Linus Torvalds 已提交
2696 2697 2698
}

/* People celebrate: "We love our President!" */
2699
static int tcp_try_undo_recovery(struct sock *sk)
L
Linus Torvalds 已提交
2700
{
2701 2702
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2703
	if (tcp_may_undo(tp)) {
2704 2705
		int mib_idx;

L
Linus Torvalds 已提交
2706 2707 2708
		/* Happy end! We did not retransmit anything
		 * or our original transmission succeeded.
		 */
2709
		DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2710
		tcp_undo_cwr(sk, true);
2711
		if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2712
			mib_idx = LINUX_MIB_TCPLOSSUNDO;
L
Linus Torvalds 已提交
2713
		else
2714 2715
			mib_idx = LINUX_MIB_TCPFULLUNDO;

2716
		NET_INC_STATS_BH(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
2717 2718
		tp->undo_marker = 0;
	}
2719
	if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
L
Linus Torvalds 已提交
2720 2721 2722 2723 2724 2725
		/* 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. */
		tcp_moderate_cwnd(tp);
		return 1;
	}
2726
	tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2727 2728 2729 2730
	return 0;
}

/* Try to undo cwnd reduction, because D-SACKs acked all retransmitted data */
2731
static void tcp_try_undo_dsack(struct sock *sk)
L
Linus Torvalds 已提交
2732
{
2733 2734
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2735
	if (tp->undo_marker && !tp->undo_retrans) {
2736
		DBGUNDO(sk, "D-SACK");
2737
		tcp_undo_cwr(sk, true);
L
Linus Torvalds 已提交
2738
		tp->undo_marker = 0;
2739
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
L
Linus Torvalds 已提交
2740 2741 2742
	}
}

2743 2744 2745 2746 2747 2748 2749 2750 2751 2752 2753 2754 2755 2756 2757 2758 2759 2760 2761 2762 2763 2764 2765 2766 2767 2768 2769 2770 2771
/* 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 int tcp_any_retrans_done(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	struct sk_buff *skb;

	if (tp->retrans_out)
		return 1;

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

	return 0;
}

L
Linus Torvalds 已提交
2772 2773
/* Undo during fast recovery after partial ACK. */

2774
static int tcp_try_undo_partial(struct sock *sk, int acked)
L
Linus Torvalds 已提交
2775
{
2776
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
2777
	/* Partial ACK arrived. Force Hoe's retransmit. */
2778
	int failed = tcp_is_reno(tp) || (tcp_fackets_out(tp) > tp->reordering);
L
Linus Torvalds 已提交
2779 2780 2781 2782 2783

	if (tcp_may_undo(tp)) {
		/* Plain luck! Hole if filled with delayed
		 * packet, rather than with a retransmit.
		 */
2784
		if (!tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2785 2786
			tp->retrans_stamp = 0;

2787
		tcp_update_reordering(sk, tcp_fackets_out(tp) + acked, 1);
L
Linus Torvalds 已提交
2788

2789
		DBGUNDO(sk, "Hoe");
2790
		tcp_undo_cwr(sk, false);
2791
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
L
Linus Torvalds 已提交
2792 2793 2794 2795 2796 2797 2798 2799 2800 2801 2802

		/* So... Do not make Hoe's retransmit yet.
		 * If the first packet was delayed, the rest
		 * ones are most probably delayed as well.
		 */
		failed = 0;
	}
	return failed;
}

/* Undo during loss recovery after partial ACK. */
2803
static int tcp_try_undo_loss(struct sock *sk)
L
Linus Torvalds 已提交
2804
{
2805 2806
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
2807 2808
	if (tcp_may_undo(tp)) {
		struct sk_buff *skb;
2809 2810 2811
		tcp_for_write_queue(skb, sk) {
			if (skb == tcp_send_head(sk))
				break;
L
Linus Torvalds 已提交
2812 2813
			TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
		}
2814

2815
		tcp_clear_all_retrans_hints(tp);
2816

2817
		DBGUNDO(sk, "partial loss");
L
Linus Torvalds 已提交
2818
		tp->lost_out = 0;
2819
		tcp_undo_cwr(sk, true);
2820
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
2821
		inet_csk(sk)->icsk_retransmits = 0;
L
Linus Torvalds 已提交
2822
		tp->undo_marker = 0;
2823
		if (tcp_is_sack(tp))
2824
			tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
2825 2826 2827 2828 2829
		return 1;
	}
	return 0;
}

2830
static inline void tcp_complete_cwr(struct sock *sk)
L
Linus Torvalds 已提交
2831
{
2832
	struct tcp_sock *tp = tcp_sk(sk);
2833 2834 2835 2836 2837
	/* Do not moderate cwnd if it's already undone in cwr or recovery */
	if (tp->undo_marker && tp->snd_cwnd > tp->snd_ssthresh) {
		tp->snd_cwnd = tp->snd_ssthresh;
		tp->snd_cwnd_stamp = tcp_time_stamp;
	}
2838
	tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
L
Linus Torvalds 已提交
2839 2840
}

2841 2842 2843 2844 2845
static void tcp_try_keep_open(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);
	int state = TCP_CA_Open;

2846
	if (tcp_left_out(tp) || tcp_any_retrans_done(sk) || tp->undo_marker)
2847 2848 2849 2850 2851 2852 2853 2854
		state = TCP_CA_Disorder;

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

2855
static void tcp_try_to_open(struct sock *sk, int flag)
L
Linus Torvalds 已提交
2856
{
2857 2858
	struct tcp_sock *tp = tcp_sk(sk);

2859 2860
	tcp_verify_left_out(tp);

2861
	if (!tp->frto_counter && !tcp_any_retrans_done(sk))
L
Linus Torvalds 已提交
2862 2863
		tp->retrans_stamp = 0;

2864
	if (flag & FLAG_ECE)
2865
		tcp_enter_cwr(sk, 1);
L
Linus Torvalds 已提交
2866

2867
	if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2868
		tcp_try_keep_open(sk);
L
Linus Torvalds 已提交
2869 2870
		tcp_moderate_cwnd(tp);
	} else {
2871
		tcp_cwnd_down(sk, flag);
L
Linus Torvalds 已提交
2872 2873 2874
	}
}

J
John Heffner 已提交
2875 2876 2877 2878 2879 2880 2881 2882
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;
}

2883
static void tcp_mtup_probe_success(struct sock *sk)
J
John Heffner 已提交
2884 2885 2886 2887 2888 2889 2890 2891 2892 2893 2894
{
	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;
2895
	tp->snd_ssthresh = tcp_current_ssthresh(sk);
J
John Heffner 已提交
2896 2897 2898 2899 2900 2901

	icsk->icsk_mtup.search_low = icsk->icsk_mtup.probe_size;
	icsk->icsk_mtup.probe_size = 0;
	tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
}

2902 2903 2904 2905 2906 2907 2908 2909 2910
/* 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 已提交
2911
	unsigned int mss = tcp_current_mss(sk);
2912 2913 2914 2915 2916
	u32 prior_lost = tp->lost_out;

	tcp_for_write_queue(skb, sk) {
		if (skb == tcp_send_head(sk))
			break;
2917
		if (tcp_skb_seglen(skb) > mss &&
2918 2919 2920 2921 2922 2923 2924 2925 2926 2927 2928 2929 2930 2931 2932 2933 2934 2935 2936 2937 2938 2939 2940 2941 2942 2943 2944 2945 2946 2947 2948 2949 2950
		    !(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 已提交
2951
EXPORT_SYMBOL(tcp_simple_retransmit);
2952

L
Linus Torvalds 已提交
2953 2954 2955 2956 2957 2958 2959 2960 2961 2962 2963
/* 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.
 *
 * Besides that it does CWND reduction, when packet loss is detected
 * and changes state of machine.
 *
 * It does _not_ decide what to send, it is made in function
 * tcp_xmit_retransmit_queue().
 */
2964
static void tcp_fastretrans_alert(struct sock *sk, int pkts_acked, int flag)
L
Linus Torvalds 已提交
2965
{
2966
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
2967
	struct tcp_sock *tp = tcp_sk(sk);
2968 2969
	int is_dupack = !(flag & (FLAG_SND_UNA_ADVANCED | FLAG_NOT_DUP));
	int do_lost = is_dupack || ((flag & FLAG_DATA_SACKED) &&
2970
				    (tcp_fackets_out(tp) > tp->reordering));
2971
	int fast_rexmit = 0, mib_idx;
L
Linus Torvalds 已提交
2972

2973
	if (WARN_ON(!tp->packets_out && tp->sacked_out))
L
Linus Torvalds 已提交
2974
		tp->sacked_out = 0;
I
Ilpo Järvinen 已提交
2975
	if (WARN_ON(!tp->sacked_out && tp->fackets_out))
L
Linus Torvalds 已提交
2976 2977
		tp->fackets_out = 0;

2978
	/* Now state machine starts.
L
Linus Torvalds 已提交
2979
	 * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
2980
	if (flag & FLAG_ECE)
L
Linus Torvalds 已提交
2981 2982 2983
		tp->prior_ssthresh = 0;

	/* B. In all the states check for reneging SACKs. */
2984
	if (tcp_check_sack_reneging(sk, flag))
L
Linus Torvalds 已提交
2985 2986 2987
		return;

	/* C. Process data loss notification, provided it is valid. */
2988
	if (tcp_is_fack(tp) && (flag & FLAG_DATA_LOST) &&
L
Linus Torvalds 已提交
2989
	    before(tp->snd_una, tp->high_seq) &&
2990
	    icsk->icsk_ca_state != TCP_CA_Open &&
L
Linus Torvalds 已提交
2991
	    tp->fackets_out > tp->reordering) {
I
Ilpo Järvinen 已提交
2992
		tcp_mark_head_lost(sk, tp->fackets_out - tp->reordering, 0);
2993
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPLOSS);
L
Linus Torvalds 已提交
2994 2995
	}

2996 2997
	/* D. Check consistency of the current state. */
	tcp_verify_left_out(tp);
L
Linus Torvalds 已提交
2998 2999 3000

	/* E. Check state exit conditions. State can be terminated
	 *    when high_seq is ACKed. */
3001
	if (icsk->icsk_ca_state == TCP_CA_Open) {
3002
		WARN_ON(tp->retrans_out != 0);
L
Linus Torvalds 已提交
3003 3004
		tp->retrans_stamp = 0;
	} else if (!before(tp->snd_una, tp->high_seq)) {
3005
		switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
3006
		case TCP_CA_Loss:
3007
			icsk->icsk_retransmits = 0;
3008
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
3009 3010 3011 3012 3013 3014 3015
				return;
			break;

		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) {
3016 3017
				tcp_complete_cwr(sk);
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
3018 3019 3020 3021
			}
			break;

		case TCP_CA_Disorder:
3022
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
3023 3024 3025
			if (!tp->undo_marker ||
			    /* For SACK case do not Open to allow to undo
			     * catching for all duplicate ACKs. */
3026
			    tcp_is_reno(tp) || tp->snd_una != tp->high_seq) {
L
Linus Torvalds 已提交
3027
				tp->undo_marker = 0;
3028
				tcp_set_ca_state(sk, TCP_CA_Open);
L
Linus Torvalds 已提交
3029 3030 3031 3032
			}
			break;

		case TCP_CA_Recovery:
3033
			if (tcp_is_reno(tp))
L
Linus Torvalds 已提交
3034
				tcp_reset_reno_sack(tp);
3035
			if (tcp_try_undo_recovery(sk))
L
Linus Torvalds 已提交
3036
				return;
3037
			tcp_complete_cwr(sk);
L
Linus Torvalds 已提交
3038 3039 3040 3041 3042
			break;
		}
	}

	/* F. Process state. */
3043
	switch (icsk->icsk_ca_state) {
L
Linus Torvalds 已提交
3044
	case TCP_CA_Recovery:
3045
		if (!(flag & FLAG_SND_UNA_ADVANCED)) {
3046
			if (tcp_is_reno(tp) && is_dupack)
3047
				tcp_add_reno_sack(sk);
3048 3049
		} else
			do_lost = tcp_try_undo_partial(sk, pkts_acked);
L
Linus Torvalds 已提交
3050 3051
		break;
	case TCP_CA_Loss:
3052
		if (flag & FLAG_DATA_ACKED)
3053
			icsk->icsk_retransmits = 0;
3054 3055
		if (tcp_is_reno(tp) && flag & FLAG_SND_UNA_ADVANCED)
			tcp_reset_reno_sack(tp);
3056
		if (!tcp_try_undo_loss(sk)) {
L
Linus Torvalds 已提交
3057 3058 3059 3060
			tcp_moderate_cwnd(tp);
			tcp_xmit_retransmit_queue(sk);
			return;
		}
3061
		if (icsk->icsk_ca_state != TCP_CA_Open)
L
Linus Torvalds 已提交
3062 3063 3064
			return;
		/* Loss is undone; fall through to processing in Open state. */
	default:
3065
		if (tcp_is_reno(tp)) {
3066
			if (flag & FLAG_SND_UNA_ADVANCED)
L
Linus Torvalds 已提交
3067 3068
				tcp_reset_reno_sack(tp);
			if (is_dupack)
3069
				tcp_add_reno_sack(sk);
L
Linus Torvalds 已提交
3070 3071
		}

3072
		if (icsk->icsk_ca_state == TCP_CA_Disorder)
3073
			tcp_try_undo_dsack(sk);
L
Linus Torvalds 已提交
3074

3075 3076
		if (!tcp_time_to_recover(sk)) {
			tcp_try_to_open(sk, flag);
L
Linus Torvalds 已提交
3077 3078 3079
			return;
		}

J
John Heffner 已提交
3080 3081 3082
		/* MTU probe failure: don't reduce cwnd */
		if (icsk->icsk_ca_state < TCP_CA_CWR &&
		    icsk->icsk_mtup.probe_size &&
3083
		    tp->snd_una == tp->mtu_probe.probe_seq_start) {
J
John Heffner 已提交
3084 3085 3086 3087 3088 3089 3090
			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 已提交
3091 3092
		/* Otherwise enter Recovery state */

3093
		if (tcp_is_reno(tp))
3094
			mib_idx = LINUX_MIB_TCPRENORECOVERY;
L
Linus Torvalds 已提交
3095
		else
3096 3097
			mib_idx = LINUX_MIB_TCPSACKRECOVERY;

3098
		NET_INC_STATS_BH(sock_net(sk), mib_idx);
L
Linus Torvalds 已提交
3099 3100 3101 3102 3103 3104

		tp->high_seq = tp->snd_nxt;
		tp->prior_ssthresh = 0;
		tp->undo_marker = tp->snd_una;
		tp->undo_retrans = tp->retrans_out;

3105
		if (icsk->icsk_ca_state < TCP_CA_CWR) {
3106
			if (!(flag & FLAG_ECE))
3107 3108
				tp->prior_ssthresh = tcp_current_ssthresh(sk);
			tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
L
Linus Torvalds 已提交
3109 3110 3111
			TCP_ECN_queue_cwr(tp);
		}

3112
		tp->bytes_acked = 0;
L
Linus Torvalds 已提交
3113
		tp->snd_cwnd_cnt = 0;
3114
		tcp_set_ca_state(sk, TCP_CA_Recovery);
3115
		fast_rexmit = 1;
L
Linus Torvalds 已提交
3116 3117
	}

3118 3119
	if (do_lost || (tcp_is_fack(tp) && tcp_head_timedout(sk)))
		tcp_update_scoreboard(sk, fast_rexmit);
3120
	tcp_cwnd_down(sk, flag);
L
Linus Torvalds 已提交
3121 3122 3123
	tcp_xmit_retransmit_queue(sk);
}

3124
void tcp_valid_rtt_meas(struct sock *sk, u32 seq_rtt)
3125 3126 3127 3128 3129
{
	tcp_rtt_estimator(sk, seq_rtt);
	tcp_set_rto(sk);
	inet_csk(sk)->icsk_backoff = 0;
}
3130
EXPORT_SYMBOL(tcp_valid_rtt_meas);
3131

L
Linus Torvalds 已提交
3132
/* Read draft-ietf-tcplw-high-performance before mucking
S
Stephen Hemminger 已提交
3133
 * with this code. (Supersedes RFC1323)
L
Linus Torvalds 已提交
3134
 */
3135
static void tcp_ack_saw_tstamp(struct sock *sk, int flag)
L
Linus Torvalds 已提交
3136 3137 3138 3139 3140 3141 3142 3143 3144 3145
{
	/* 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.
	 * 1998/04/10 Andrey V. Savochkin <saw@msu.ru>
	 *
	 * Changed: reset backoff as soon as we see the first valid sample.
S
Stephen Hemminger 已提交
3146
	 * If we do not, we get strongly overestimated rto. With timestamps
L
Linus Torvalds 已提交
3147 3148 3149 3150 3151
	 * samples are accepted even from very old segments: f.e., when rtt=1
	 * increases to 8, we retransmit 5 times and after 8 seconds delayed
	 * answer arrives rto becomes 120 seconds! If at least one of segments
	 * in window is lost... Voila.	 			--ANK (010210)
	 */
3152
	struct tcp_sock *tp = tcp_sk(sk);
3153 3154

	tcp_valid_rtt_meas(sk, tcp_time_stamp - tp->rx_opt.rcv_tsecr);
L
Linus Torvalds 已提交
3155 3156
}

3157
static void tcp_ack_no_tstamp(struct sock *sk, u32 seq_rtt, int flag)
L
Linus Torvalds 已提交
3158 3159 3160 3161 3162 3163 3164 3165 3166 3167 3168 3169 3170
{
	/* We don't have a timestamp. Can only use
	 * packets that are not retransmitted to determine
	 * rtt estimates. Also, we must not reset the
	 * backoff for rto until we get a non-retransmitted
	 * packet. This allows us to deal with a situation
	 * where the network delay has increased suddenly.
	 * I.e. Karn's algorithm. (SIGCOMM '87, p5.)
	 */

	if (flag & FLAG_RETRANS_DATA_ACKED)
		return;

3171
	tcp_valid_rtt_meas(sk, seq_rtt);
L
Linus Torvalds 已提交
3172 3173
}

3174
static inline void tcp_ack_update_rtt(struct sock *sk, const int flag,
3175
				      const s32 seq_rtt)
L
Linus Torvalds 已提交
3176
{
3177
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3178 3179
	/* Note that peer MAY send zero echo. In this case it is ignored. (rfc1323) */
	if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
3180
		tcp_ack_saw_tstamp(sk, flag);
L
Linus Torvalds 已提交
3181
	else if (seq_rtt >= 0)
3182
		tcp_ack_no_tstamp(sk, seq_rtt, flag);
L
Linus Torvalds 已提交
3183 3184
}

3185
static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 in_flight)
L
Linus Torvalds 已提交
3186
{
3187
	const struct inet_connection_sock *icsk = inet_csk(sk);
3188
	icsk->icsk_ca_ops->cong_avoid(sk, ack, in_flight);
3189
	tcp_sk(sk)->snd_cwnd_stamp = tcp_time_stamp;
L
Linus Torvalds 已提交
3190 3191 3192 3193 3194
}

/* Restart timer after forward progress on connection.
 * RFC2988 recommends to restart timer to now+rto.
 */
3195
static void tcp_rearm_rto(struct sock *sk)
L
Linus Torvalds 已提交
3196
{
3197 3198
	struct tcp_sock *tp = tcp_sk(sk);

L
Linus Torvalds 已提交
3199
	if (!tp->packets_out) {
3200
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
L
Linus Torvalds 已提交
3201
	} else {
3202 3203
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
					  inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
L
Linus Torvalds 已提交
3204 3205 3206
	}
}

3207
/* If we get here, the whole TSO packet has not been acked. */
3208
static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
L
Linus Torvalds 已提交
3209 3210
{
	struct tcp_sock *tp = tcp_sk(sk);
3211
	u32 packets_acked;
L
Linus Torvalds 已提交
3212

3213
	BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
L
Linus Torvalds 已提交
3214 3215

	packets_acked = tcp_skb_pcount(skb);
3216
	if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
L
Linus Torvalds 已提交
3217 3218 3219 3220 3221
		return 0;
	packets_acked -= tcp_skb_pcount(skb);

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

3225
	return packets_acked;
L
Linus Torvalds 已提交
3226 3227
}

3228 3229 3230 3231
/* 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 已提交
3232 3233
static int tcp_clean_rtx_queue(struct sock *sk, int prior_fackets,
			       u32 prior_snd_una)
L
Linus Torvalds 已提交
3234 3235
{
	struct tcp_sock *tp = tcp_sk(sk);
3236
	const struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3237
	struct sk_buff *skb;
3238
	u32 now = tcp_time_stamp;
3239
	int fully_acked = 1;
3240
	int flag = 0;
3241
	u32 pkts_acked = 0;
3242
	u32 reord = tp->packets_out;
3243
	u32 prior_sacked = tp->sacked_out;
3244
	s32 seq_rtt = -1;
3245
	s32 ca_seq_rtt = -1;
3246
	ktime_t last_ackt = net_invalid_timestamp();
L
Linus Torvalds 已提交
3247

3248
	while ((skb = tcp_write_queue_head(sk)) && skb != tcp_send_head(sk)) {
3249
		struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3250
		u32 acked_pcount;
3251
		u8 sacked = scb->sacked;
L
Linus Torvalds 已提交
3252

3253
		/* Determine how many packets and what bytes were acked, tso and else */
L
Linus Torvalds 已提交
3254
		if (after(scb->end_seq, tp->snd_una)) {
3255 3256 3257 3258
			if (tcp_skb_pcount(skb) == 1 ||
			    !after(tp->snd_una, scb->seq))
				break;

3259 3260
			acked_pcount = tcp_tso_acked(sk, skb);
			if (!acked_pcount)
3261 3262 3263 3264
				break;

			fully_acked = 0;
		} else {
3265
			acked_pcount = tcp_skb_pcount(skb);
L
Linus Torvalds 已提交
3266 3267
		}

3268 3269
		if (sacked & TCPCB_RETRANS) {
			if (sacked & TCPCB_SACKED_RETRANS)
3270
				tp->retrans_out -= acked_pcount;
3271 3272 3273
			flag |= FLAG_RETRANS_DATA_ACKED;
			ca_seq_rtt = -1;
			seq_rtt = -1;
3274
			if ((flag & FLAG_DATA_ACKED) || (acked_pcount > 1))
3275
				flag |= FLAG_NONHEAD_RETRANS_ACKED;
3276
		} else {
3277 3278
			ca_seq_rtt = now - scb->when;
			last_ackt = skb->tstamp;
3279
			if (seq_rtt < 0) {
3280
				seq_rtt = ca_seq_rtt;
3281
			}
3282
			if (!(sacked & TCPCB_SACKED_ACKED))
3283
				reord = min(pkts_acked, reord);
3284
		}
3285 3286

		if (sacked & TCPCB_SACKED_ACKED)
3287
			tp->sacked_out -= acked_pcount;
3288
		if (sacked & TCPCB_LOST)
3289
			tp->lost_out -= acked_pcount;
3290

3291 3292
		tp->packets_out -= acked_pcount;
		pkts_acked += acked_pcount;
3293

3294 3295 3296 3297 3298 3299 3300
		/* 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.
		 */
C
Changli Gao 已提交
3301
		if (!(scb->flags & TCPHDR_SYN)) {
3302 3303 3304 3305 3306 3307
			flag |= FLAG_DATA_ACKED;
		} else {
			flag |= FLAG_SYN_ACKED;
			tp->retrans_stamp = 0;
		}

3308 3309 3310
		if (!fully_acked)
			break;

3311
		tcp_unlink_write_queue(skb, sk);
3312
		sk_wmem_free_skb(sk, skb);
3313
		tp->scoreboard_skb_hint = NULL;
3314 3315
		if (skb == tp->retransmit_skb_hint)
			tp->retransmit_skb_hint = NULL;
3316 3317
		if (skb == tp->lost_skb_hint)
			tp->lost_skb_hint = NULL;
L
Linus Torvalds 已提交
3318 3319
	}

I
Ilpo Järvinen 已提交
3320 3321 3322
	if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
		tp->snd_up = tp->snd_una;

3323 3324 3325
	if (skb && (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
		flag |= FLAG_SACK_RENEGING;

3326
	if (flag & FLAG_ACKED) {
3327 3328 3329
		const struct tcp_congestion_ops *ca_ops
			= inet_csk(sk)->icsk_ca_ops;

3330 3331 3332 3333 3334
		if (unlikely(icsk->icsk_mtup.probe_size &&
			     !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
			tcp_mtup_probe_success(sk);
		}

3335
		tcp_ack_update_rtt(sk, flag, seq_rtt);
3336
		tcp_rearm_rto(sk);
3337

3338 3339 3340
		if (tcp_is_reno(tp)) {
			tcp_remove_reno_sacks(sk, pkts_acked);
		} else {
3341 3342
			int delta;

3343 3344 3345
			/* Non-retransmitted hole got filled? That's reordering */
			if (reord < prior_fackets)
				tcp_update_reordering(sk, tp->fackets_out - reord, 0);
3346

3347 3348 3349
			delta = tcp_is_fack(tp) ? pkts_acked :
						  prior_sacked - tp->sacked_out;
			tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3350 3351
		}

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

3354 3355 3356 3357
		if (ca_ops->pkts_acked) {
			s32 rtt_us = -1;

			/* Is the ACK triggering packet unambiguous? */
3358
			if (!(flag & FLAG_RETRANS_DATA_ACKED)) {
3359 3360 3361 3362 3363 3364
				/* High resolution needed and available? */
				if (ca_ops->flags & TCP_CONG_RTT_STAMP &&
				    !ktime_equal(last_ackt,
						 net_invalid_timestamp()))
					rtt_us = ktime_us_delta(ktime_get_real(),
								last_ackt);
3365
				else if (ca_seq_rtt >= 0)
3366
					rtt_us = jiffies_to_usecs(ca_seq_rtt);
3367
			}
3368

3369 3370
			ca_ops->pkts_acked(sk, pkts_acked, rtt_us);
		}
L
Linus Torvalds 已提交
3371 3372 3373
	}

#if FASTRETRANS_DEBUG > 0
3374 3375 3376
	WARN_ON((int)tp->sacked_out < 0);
	WARN_ON((int)tp->lost_out < 0);
	WARN_ON((int)tp->retrans_out < 0);
3377
	if (!tp->packets_out && tcp_is_sack(tp)) {
S
Stephen Hemminger 已提交
3378
		icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3379 3380
		if (tp->lost_out) {
			printk(KERN_DEBUG "Leak l=%u %d\n",
3381
			       tp->lost_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3382 3383 3384 3385
			tp->lost_out = 0;
		}
		if (tp->sacked_out) {
			printk(KERN_DEBUG "Leak s=%u %d\n",
3386
			       tp->sacked_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3387 3388 3389 3390
			tp->sacked_out = 0;
		}
		if (tp->retrans_out) {
			printk(KERN_DEBUG "Leak r=%u %d\n",
3391
			       tp->retrans_out, icsk->icsk_ca_state);
L
Linus Torvalds 已提交
3392 3393 3394 3395
			tp->retrans_out = 0;
		}
	}
#endif
3396
	return flag;
L
Linus Torvalds 已提交
3397 3398 3399 3400
}

static void tcp_ack_probe(struct sock *sk)
{
3401 3402
	const struct tcp_sock *tp = tcp_sk(sk);
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3403 3404 3405

	/* Was it a usable window open? */

3406
	if (!after(TCP_SKB_CB(tcp_send_head(sk))->end_seq, tcp_wnd_end(tp))) {
3407 3408
		icsk->icsk_backoff = 0;
		inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
L
Linus Torvalds 已提交
3409 3410 3411 3412
		/* Socket must be waked up by subsequent tcp_data_snd_check().
		 * This function is not for random using!
		 */
	} else {
3413
		inet_csk_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
3414 3415
					  min(icsk->icsk_rto << icsk->icsk_backoff, TCP_RTO_MAX),
					  TCP_RTO_MAX);
L
Linus Torvalds 已提交
3416 3417 3418
	}
}

3419
static inline int tcp_ack_is_dubious(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3420
{
E
Eric Dumazet 已提交
3421 3422
	return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
		inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
L
Linus Torvalds 已提交
3423 3424
}

3425
static inline int tcp_may_raise_cwnd(const struct sock *sk, const int flag)
L
Linus Torvalds 已提交
3426
{
3427
	const struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3428
	return (!(flag & FLAG_ECE) || tp->snd_cwnd < tp->snd_ssthresh) &&
3429
		!((1 << inet_csk(sk)->icsk_ca_state) & (TCPF_CA_Recovery | TCPF_CA_CWR));
L
Linus Torvalds 已提交
3430 3431 3432 3433 3434
}

/* Check that window update is acceptable.
 * The function assumes that snd_una<=ack<=snd_next.
 */
3435 3436 3437
static inline int tcp_may_update_window(const struct tcp_sock *tp,
					const u32 ack, const u32 ack_seq,
					const u32 nwin)
L
Linus Torvalds 已提交
3438
{
E
Eric Dumazet 已提交
3439
	return	after(ack, tp->snd_una) ||
L
Linus Torvalds 已提交
3440
		after(ack_seq, tp->snd_wl1) ||
E
Eric Dumazet 已提交
3441
		(ack_seq == tp->snd_wl1 && nwin > tp->snd_wnd);
L
Linus Torvalds 已提交
3442 3443 3444 3445 3446 3447 3448
}

/* 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.
 */
3449 3450
static int tcp_ack_update_window(struct sock *sk, struct sk_buff *skb, u32 ack,
				 u32 ack_seq)
L
Linus Torvalds 已提交
3451
{
3452
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
3453
	int flag = 0;
3454
	u32 nwin = ntohs(tcp_hdr(skb)->window);
L
Linus Torvalds 已提交
3455

3456
	if (likely(!tcp_hdr(skb)->syn))
L
Linus Torvalds 已提交
3457 3458 3459 3460
		nwin <<= tp->rx_opt.snd_wscale;

	if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {
		flag |= FLAG_WIN_UPDATE;
3461
		tcp_update_wl(tp, ack_seq);
L
Linus Torvalds 已提交
3462 3463 3464 3465 3466 3467 3468

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

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

			if (nwin > tp->max_window) {
				tp->max_window = nwin;
3474
				tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
3475 3476 3477 3478 3479 3480 3481 3482 3483
			}
		}
	}

	tp->snd_una = ack;

	return flag;
}

3484 3485 3486 3487 3488 3489
/* A very conservative spurious RTO response algorithm: reduce cwnd and
 * continue in congestion avoidance.
 */
static void tcp_conservative_spur_to_response(struct tcp_sock *tp)
{
	tp->snd_cwnd = min(tp->snd_cwnd, tp->snd_ssthresh);
3490
	tp->snd_cwnd_cnt = 0;
3491
	tp->bytes_acked = 0;
3492
	TCP_ECN_queue_cwr(tp);
3493 3494 3495
	tcp_moderate_cwnd(tp);
}

3496 3497 3498 3499 3500 3501 3502 3503
/* A conservative spurious RTO response algorithm: reduce cwnd using
 * rate halving and continue in congestion avoidance.
 */
static void tcp_ratehalving_spur_to_response(struct sock *sk)
{
	tcp_enter_cwr(sk, 0);
}

3504
static void tcp_undo_spur_to_response(struct sock *sk, int flag)
3505
{
3506
	if (flag & FLAG_ECE)
3507 3508
		tcp_ratehalving_spur_to_response(sk);
	else
3509
		tcp_undo_cwr(sk, true);
3510 3511
}

3512 3513
/* F-RTO spurious RTO detection algorithm (RFC4138)
 *
3514 3515 3516
 * F-RTO affects during two new ACKs following RTO (well, almost, see inline
 * comments). State (ACK number) is kept in frto_counter. When ACK advances
 * window (but not to or beyond highest sequence sent before RTO):
3517 3518 3519 3520 3521
 *   On First ACK,  send two new segments out.
 *   On Second ACK, RTO was likely spurious. Do spurious response (response
 *                  algorithm is not part of the F-RTO detection algorithm
 *                  given in RFC4138 but can be selected separately).
 * Otherwise (basically on duplicate ACK), RTO was (likely) caused by a loss
3522 3523 3524
 * and TCP falls back to conventional RTO recovery. F-RTO allows overriding
 * of Nagle, this is done using frto_counter states 2 and 3, when a new data
 * segment of any size sent during F-RTO, state 2 is upgraded to 3.
3525 3526 3527 3528
 *
 * Rationale: if the RTO was spurious, new ACKs should arrive from the
 * original window even after we transmit two new data segments.
 *
I
Ilpo Järvinen 已提交
3529 3530 3531 3532
 * SACK version:
 *   on first step, wait until first cumulative ACK arrives, then move to
 *   the second step. In second step, the next ACK decides.
 *
3533 3534 3535 3536 3537 3538 3539 3540 3541
 * F-RTO is implemented (mainly) in four functions:
 *   - tcp_use_frto() is used to determine if TCP is can use F-RTO
 *   - tcp_enter_frto() prepares TCP state on RTO if F-RTO is used, it is
 *     called when tcp_use_frto() showed green light
 *   - tcp_process_frto() handles incoming ACKs during F-RTO algorithm
 *   - tcp_enter_frto_loss() is called if there is not enough evidence
 *     to prove that the RTO is indeed spurious. It transfers the control
 *     from F-RTO to the conventional RTO recovery
 */
3542
static int tcp_process_frto(struct sock *sk, int flag)
L
Linus Torvalds 已提交
3543 3544
{
	struct tcp_sock *tp = tcp_sk(sk);
3545

3546
	tcp_verify_left_out(tp);
3547

3548
	/* Duplicate the behavior from Loss state (fastretrans_alert) */
3549
	if (flag & FLAG_DATA_ACKED)
3550 3551
		inet_csk(sk)->icsk_retransmits = 0;

3552 3553 3554 3555
	if ((flag & FLAG_NONHEAD_RETRANS_ACKED) ||
	    ((tp->frto_counter >= 2) && (flag & FLAG_RETRANS_DATA_ACKED)))
		tp->undo_marker = 0;

3556
	if (!before(tp->snd_una, tp->frto_highmark)) {
3557
		tcp_enter_frto_loss(sk, (tp->frto_counter == 1 ? 2 : 3), flag);
3558
		return 1;
3559 3560
	}

3561
	if (!tcp_is_sackfrto(tp)) {
I
Ilpo Järvinen 已提交
3562 3563 3564 3565
		/* RFC4138 shortcoming in step 2; should also have case c):
		 * ACK isn't duplicate nor advances window, e.g., opposite dir
		 * data, winupdate
		 */
3566
		if (!(flag & FLAG_ANY_PROGRESS) && (flag & FLAG_NOT_DUP))
I
Ilpo Järvinen 已提交
3567 3568
			return 1;

3569
		if (!(flag & FLAG_DATA_ACKED)) {
I
Ilpo Järvinen 已提交
3570 3571 3572 3573 3574
			tcp_enter_frto_loss(sk, (tp->frto_counter == 1 ? 0 : 3),
					    flag);
			return 1;
		}
	} else {
3575
		if (!(flag & FLAG_DATA_ACKED) && (tp->frto_counter == 1)) {
I
Ilpo Järvinen 已提交
3576 3577 3578 3579 3580
			/* Prevent sending of new data. */
			tp->snd_cwnd = min(tp->snd_cwnd,
					   tcp_packets_in_flight(tp));
			return 1;
		}
3581

3582
		if ((tp->frto_counter >= 2) &&
3583 3584 3585
		    (!(flag & FLAG_FORWARD_PROGRESS) ||
		     ((flag & FLAG_DATA_SACKED) &&
		      !(flag & FLAG_ONLY_ORIG_SACKED)))) {
I
Ilpo Järvinen 已提交
3586
			/* RFC4138 shortcoming (see comment above) */
3587 3588
			if (!(flag & FLAG_FORWARD_PROGRESS) &&
			    (flag & FLAG_NOT_DUP))
I
Ilpo Järvinen 已提交
3589 3590 3591 3592 3593
				return 1;

			tcp_enter_frto_loss(sk, 3, flag);
			return 1;
		}
L
Linus Torvalds 已提交
3594 3595 3596
	}

	if (tp->frto_counter == 1) {
3597
		/* tcp_may_send_now needs to see updated state */
L
Linus Torvalds 已提交
3598
		tp->snd_cwnd = tcp_packets_in_flight(tp) + 2;
3599
		tp->frto_counter = 2;
3600 3601 3602 3603

		if (!tcp_may_send_now(sk))
			tcp_enter_frto_loss(sk, 2, flag);

3604
		return 1;
3605
	} else {
3606 3607
		switch (sysctl_tcp_frto_response) {
		case 2:
3608
			tcp_undo_spur_to_response(sk, flag);
3609 3610 3611 3612 3613 3614 3615
			break;
		case 1:
			tcp_conservative_spur_to_response(tp);
			break;
		default:
			tcp_ratehalving_spur_to_response(sk);
			break;
3616
		}
3617
		tp->frto_counter = 0;
3618
		tp->undo_marker = 0;
3619
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPSPURIOUSRTOS);
L
Linus Torvalds 已提交
3620
	}
3621
	return 0;
L
Linus Torvalds 已提交
3622 3623 3624 3625 3626
}

/* This routine deals with incoming acks, but not outgoing ones. */
static int tcp_ack(struct sock *sk, struct sk_buff *skb, int flag)
{
3627
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
3628 3629 3630 3631 3632
	struct tcp_sock *tp = tcp_sk(sk);
	u32 prior_snd_una = tp->snd_una;
	u32 ack_seq = TCP_SKB_CB(skb)->seq;
	u32 ack = TCP_SKB_CB(skb)->ack_seq;
	u32 prior_in_flight;
3633
	u32 prior_fackets;
L
Linus Torvalds 已提交
3634
	int prior_packets;
3635
	int frto_cwnd = 0;
L
Linus Torvalds 已提交
3636

3637
	/* If the ack is older than previous acks
L
Linus Torvalds 已提交
3638 3639 3640 3641 3642
	 * then we can probably ignore it.
	 */
	if (before(ack, prior_snd_una))
		goto old_ack;

3643 3644 3645 3646 3647 3648
	/* 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;

3649 3650 3651
	if (after(ack, prior_snd_una))
		flag |= FLAG_SND_UNA_ADVANCED;

3652 3653 3654 3655 3656
	if (sysctl_tcp_abc) {
		if (icsk->icsk_ca_state < TCP_CA_CWR)
			tp->bytes_acked += ack - prior_snd_una;
		else if (icsk->icsk_ca_state == TCP_CA_Loss)
			/* we assume just one segment left network */
3657 3658
			tp->bytes_acked += min(ack - prior_snd_una,
					       tp->mss_cache);
3659
	}
3660

3661
	prior_fackets = tp->fackets_out;
3662
	prior_in_flight = tcp_packets_in_flight(tp);
3663

3664
	if (!(flag & FLAG_SLOWPATH) && after(ack, prior_snd_una)) {
L
Linus Torvalds 已提交
3665 3666 3667 3668
		/* Window is constant, pure forward advance.
		 * No more checks are required.
		 * Note, we use the fact that SND.UNA>=SND.WL2.
		 */
3669
		tcp_update_wl(tp, ack_seq);
L
Linus Torvalds 已提交
3670 3671 3672
		tp->snd_una = ack;
		flag |= FLAG_WIN_UPDATE;

3673
		tcp_ca_event(sk, CA_EVENT_FAST_ACK);
3674

3675
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPACKS);
L
Linus Torvalds 已提交
3676 3677 3678 3679
	} else {
		if (ack_seq != TCP_SKB_CB(skb)->end_seq)
			flag |= FLAG_DATA;
		else
3680
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPPUREACKS);
L
Linus Torvalds 已提交
3681

3682
		flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);
L
Linus Torvalds 已提交
3683 3684 3685 3686

		if (TCP_SKB_CB(skb)->sacked)
			flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una);

3687
		if (TCP_ECN_rcv_ecn_echo(tp, tcp_hdr(skb)))
L
Linus Torvalds 已提交
3688 3689
			flag |= FLAG_ECE;

3690
		tcp_ca_event(sk, CA_EVENT_SLOW_ACK);
L
Linus Torvalds 已提交
3691 3692 3693 3694 3695 3696
	}

	/* We passed data and got it acked, remove any soft error
	 * log. Something worked...
	 */
	sk->sk_err_soft = 0;
3697
	icsk->icsk_probes_out = 0;
L
Linus Torvalds 已提交
3698 3699 3700 3701 3702 3703
	tp->rcv_tstamp = tcp_time_stamp;
	prior_packets = tp->packets_out;
	if (!prior_packets)
		goto no_queue;

	/* See if we can take anything off of the retransmit queue. */
I
Ilpo Järvinen 已提交
3704
	flag |= tcp_clean_rtx_queue(sk, prior_fackets, prior_snd_una);
L
Linus Torvalds 已提交
3705

3706 3707
	if (tp->frto_counter)
		frto_cwnd = tcp_process_frto(sk, flag);
3708 3709 3710
	/* Guarantee sacktag reordering detection against wrap-arounds */
	if (before(tp->frto_highmark, tp->snd_una))
		tp->frto_highmark = 0;
L
Linus Torvalds 已提交
3711

3712
	if (tcp_ack_is_dubious(sk, flag)) {
S
Stephen Hemminger 已提交
3713
		/* Advance CWND, if state allows this. */
3714 3715
		if ((flag & FLAG_DATA_ACKED) && !frto_cwnd &&
		    tcp_may_raise_cwnd(sk, flag))
3716
			tcp_cong_avoid(sk, ack, prior_in_flight);
3717 3718
		tcp_fastretrans_alert(sk, prior_packets - tp->packets_out,
				      flag);
L
Linus Torvalds 已提交
3719
	} else {
3720
		if ((flag & FLAG_DATA_ACKED) && !frto_cwnd)
3721
			tcp_cong_avoid(sk, ack, prior_in_flight);
L
Linus Torvalds 已提交
3722 3723
	}

3724
	if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
E
Eric Dumazet 已提交
3725
		dst_confirm(__sk_dst_get(sk));
L
Linus Torvalds 已提交
3726 3727 3728 3729 3730 3731 3732 3733

	return 1;

no_queue:
	/* 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.
	 */
3734
	if (tcp_send_head(sk))
L
Linus Torvalds 已提交
3735 3736 3737
		tcp_ack_probe(sk);
	return 1;

3738 3739 3740 3741
invalid_ack:
	SOCK_DEBUG(sk, "Ack %u after %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
	return -1;

L
Linus Torvalds 已提交
3742
old_ack:
3743
	if (TCP_SKB_CB(skb)->sacked) {
L
Linus Torvalds 已提交
3744
		tcp_sacktag_write_queue(sk, skb, prior_snd_una);
3745 3746 3747
		if (icsk->icsk_ca_state == TCP_CA_Open)
			tcp_try_keep_open(sk);
	}
L
Linus Torvalds 已提交
3748

3749
	SOCK_DEBUG(sk, "Ack %u before %u:%u\n", ack, tp->snd_una, tp->snd_nxt);
L
Linus Torvalds 已提交
3750 3751 3752 3753 3754 3755 3756
	return 0;
}

/* 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.
 */
3757
void tcp_parse_options(struct sk_buff *skb, struct tcp_options_received *opt_rx,
3758
		       u8 **hvpp, int estab)
L
Linus Torvalds 已提交
3759 3760
{
	unsigned char *ptr;
3761
	struct tcphdr *th = tcp_hdr(skb);
3762
	int length = (th->doff * 4) - sizeof(struct tcphdr);
L
Linus Torvalds 已提交
3763 3764 3765 3766

	ptr = (unsigned char *)(th + 1);
	opt_rx->saw_tstamp = 0;

S
Stephen Hemminger 已提交
3767
	while (length > 0) {
3768
		int opcode = *ptr++;
L
Linus Torvalds 已提交
3769 3770 3771
		int opsize;

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

3827 3828 3829 3830 3831 3832 3833
			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;
3834
#ifdef CONFIG_TCP_MD5SIG
3835 3836 3837 3838 3839 3840
			case TCPOPT_MD5SIG:
				/*
				 * The MD5 Hash has already been
				 * checked (see tcp_v{4,6}_do_rcv()).
				 */
				break;
3841
#endif
3842 3843 3844 3845 3846 3847 3848 3849 3850 3851 3852 3853 3854 3855 3856 3857 3858 3859
			case TCPOPT_COOKIE:
				/* This option is variable length.
				 */
				switch (opsize) {
				case TCPOLEN_COOKIE_BASE:
					/* not yet implemented */
					break;
				case TCPOLEN_COOKIE_PAIR:
					/* not yet implemented */
					break;
				case TCPOLEN_COOKIE_MIN+0:
				case TCPOLEN_COOKIE_MIN+2:
				case TCPOLEN_COOKIE_MIN+4:
				case TCPOLEN_COOKIE_MIN+6:
				case TCPOLEN_COOKIE_MAX:
					/* 16-bit multiple */
					opt_rx->cookie_plus = opsize;
					*hvpp = ptr;
3860
					break;
3861 3862 3863
				default:
					/* ignore option */
					break;
3864
				}
3865
				break;
3866
			}
3867

3868 3869
			ptr += opsize-2;
			length -= opsize;
3870
		}
L
Linus Torvalds 已提交
3871 3872
	}
}
E
Eric Dumazet 已提交
3873
EXPORT_SYMBOL(tcp_parse_options);
L
Linus Torvalds 已提交
3874

3875 3876 3877 3878 3879 3880 3881 3882 3883 3884 3885 3886 3887 3888 3889 3890
static int tcp_parse_aligned_timestamp(struct tcp_sock *tp, struct tcphdr *th)
{
	__be32 *ptr = (__be32 *)(th + 1);

	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;
		tp->rx_opt.rcv_tsecr = ntohl(*ptr);
		return 1;
	}
	return 0;
}

L
Linus Torvalds 已提交
3891 3892 3893
/* Fast parse options. This hopes to only see timestamps.
 * If it is wrong it falls back on tcp_parse_options().
 */
S
Stephen Hemminger 已提交
3894
static int tcp_fast_parse_options(struct sk_buff *skb, struct tcphdr *th,
3895
				  struct tcp_sock *tp, u8 **hvpp)
L
Linus Torvalds 已提交
3896
{
3897 3898 3899 3900
	/* 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 已提交
3901 3902 3903
		tp->rx_opt.saw_tstamp = 0;
		return 0;
	} else if (tp->rx_opt.tstamp_ok &&
3904
		   th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
3905
		if (tcp_parse_aligned_timestamp(tp, th))
L
Linus Torvalds 已提交
3906 3907
			return 1;
	}
3908
	tcp_parse_options(skb, &tp->rx_opt, hvpp, 1);
L
Linus Torvalds 已提交
3909 3910 3911
	return 1;
}

3912 3913 3914 3915 3916 3917 3918 3919 3920 3921 3922 3923 3924 3925 3926 3927 3928 3929 3930 3931 3932 3933 3934 3935 3936 3937 3938 3939
#ifdef CONFIG_TCP_MD5SIG
/*
 * Parse MD5 Signature option
 */
u8 *tcp_parse_md5sig_option(struct tcphdr *th)
{
	int length = (th->doff << 2) - sizeof (*th);
	u8 *ptr = (u8*)(th + 1);

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

		switch(opcode) {
		case TCPOPT_EOL:
			return NULL;
		case TCPOPT_NOP:
			length--;
			continue;
		default:
			opsize = *ptr++;
			if (opsize < 2 || opsize > length)
				return NULL;
			if (opcode == TCPOPT_MD5SIG)
3940
				return opsize == TCPOLEN_MD5SIG ? ptr : NULL;
3941 3942 3943 3944 3945 3946
		}
		ptr += opsize - 2;
		length -= opsize;
	}
	return NULL;
}
E
Eric Dumazet 已提交
3947
EXPORT_SYMBOL(tcp_parse_md5sig_option);
3948 3949
#endif

L
Linus Torvalds 已提交
3950 3951 3952
static inline void tcp_store_ts_recent(struct tcp_sock *tp)
{
	tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
3953
	tp->rx_opt.ts_recent_stamp = get_seconds();
L
Linus Torvalds 已提交
3954 3955 3956 3957 3958 3959 3960 3961 3962 3963 3964 3965
}

static inline 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.
		 */

I
Ilpo Järvinen 已提交
3966
		if (tcp_paws_check(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
3967 3968 3969 3970 3971 3972 3973 3974 3975 3976 3977 3978 3979 3980 3981 3982 3983 3984 3985 3986 3987 3988 3989 3990 3991 3992 3993
			tcp_store_ts_recent(tp);
	}
}

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

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

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

	return !tcp_paws_check(&tp->rx_opt, TCP_PAWS_WINDOW) &&
	       !tcp_disordered_ack(sk, skb);
L
Linus Torvalds 已提交
4021 4022 4023 4024 4025 4026 4027 4028 4029 4030 4031 4032 4033 4034 4035 4036 4037 4038 4039 4040 4041 4042 4043 4044 4045 4046
}

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

static inline int tcp_sequence(struct tcp_sock *tp, u32 seq, u32 end_seq)
{
	return	!before(end_seq, tp->rcv_wup) &&
		!after(seq, tp->rcv_nxt + tcp_receive_window(tp));
}

/* When we get a reset we do this. */
static void tcp_reset(struct sock *sk)
{
	/* We want the right error as BSD sees it (and indeed as we do). */
	switch (sk->sk_state) {
4047 4048 4049 4050 4051 4052 4053 4054 4055 4056
	case TCP_SYN_SENT:
		sk->sk_err = ECONNREFUSED;
		break;
	case TCP_CLOSE_WAIT:
		sk->sk_err = EPIPE;
		break;
	case TCP_CLOSE:
		return;
	default:
		sk->sk_err = ECONNRESET;
L
Linus Torvalds 已提交
4057
	}
T
Tom Marshall 已提交
4058 4059
	/* This barrier is coupled with smp_rmb() in tcp_poll() */
	smp_wmb();
L
Linus Torvalds 已提交
4060 4061 4062 4063 4064 4065 4066 4067 4068 4069 4070 4071 4072 4073 4074 4075 4076 4077 4078 4079 4080 4081 4082 4083 4084

	if (!sock_flag(sk, SOCK_DEAD))
		sk->sk_error_report(sk);

	tcp_done(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.
 */
static void tcp_fin(struct sk_buff *skb, struct sock *sk, struct tcphdr *th)
{
	struct tcp_sock *tp = tcp_sk(sk);

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

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

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

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

4108 4109 4110 4111 4112 4113 4114 4115 4116 4117 4118 4119 4120 4121 4122 4123 4124 4125
	case TCP_FIN_WAIT1:
		/* This case occurs when a simultaneous close
		 * happens, we must ack the received FIN and
		 * enter the CLOSING state.
		 */
		tcp_send_ack(sk);
		tcp_set_state(sk, TCP_CLOSING);
		break;
	case TCP_FIN_WAIT2:
		/* Received a FIN -- send ACK and enter TIME_WAIT. */
		tcp_send_ack(sk);
		tcp_time_wait(sk, TCP_TIME_WAIT, 0);
		break;
	default:
		/* Only TCP_LISTEN and TCP_CLOSE are left, in these
		 * cases we should never reach this piece of code.
		 */
		printk(KERN_ERR "%s: Impossible, sk->sk_state=%d\n",
4126
		       __func__, sk->sk_state);
4127
		break;
4128
	}
L
Linus Torvalds 已提交
4129 4130 4131 4132 4133

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

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

4150 4151
static inline int tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
				  u32 end_seq)
L
Linus Torvalds 已提交
4152 4153 4154 4155 4156 4157 4158 4159 4160 4161 4162
{
	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;
		return 1;
	}
	return 0;
}

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

4167
	if (tcp_is_sack(tp) && sysctl_tcp_dsack) {
4168 4169
		int mib_idx;

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

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

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

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

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

static void tcp_send_dupack(struct sock *sk, struct sk_buff *skb)
{
	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)) {
4199
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4200
		tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4201

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

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

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

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

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

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

			/* Zap this SACK, by moving forward any other SACKS. */
			for (i=this_sack+1; i < num_sacks; i++)
				tp->selective_acks[i-1] = tp->selective_acks[i];
			num_sacks--;
			continue;
		}
		this_sack++;
		sp++;
	}
4315
	tp->rx_opt.num_sacks = num_sacks;
L
Linus Torvalds 已提交
4316 4317 4318 4319 4320 4321 4322 4323 4324 4325 4326 4327 4328 4329 4330 4331 4332 4333 4334
}

/* 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;
	struct sk_buff *skb;

	while ((skb = skb_peek(&tp->out_of_order_queue)) != NULL) {
		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;
4335
			tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);
L
Linus Torvalds 已提交
4336 4337 4338
		}

		if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
4339
			SOCK_DEBUG(sk, "ofo packet was already received\n");
D
David S. Miller 已提交
4340
			__skb_unlink(skb, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
4341 4342 4343 4344 4345 4346 4347
			__kfree_skb(skb);
			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);

D
David S. Miller 已提交
4348
		__skb_unlink(skb, &tp->out_of_order_queue);
L
Linus Torvalds 已提交
4349 4350
		__skb_queue_tail(&sk->sk_receive_queue, skb);
		tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
4351 4352
		if (tcp_hdr(skb)->fin)
			tcp_fin(skb, sk, tcp_hdr(skb));
L
Linus Torvalds 已提交
4353 4354 4355
	}
}

4356
static int tcp_prune_ofo_queue(struct sock *sk);
L
Linus Torvalds 已提交
4357 4358
static int tcp_prune_queue(struct sock *sk);

4359 4360 4361 4362 4363 4364 4365 4366 4367
static inline int tcp_try_rmem_schedule(struct sock *sk, unsigned int size)
{
	if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
	    !sk_rmem_schedule(sk, size)) {

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

		if (!sk_rmem_schedule(sk, size)) {
4368 4369 4370
			if (!tcp_prune_ofo_queue(sk))
				return -1;

4371 4372 4373 4374 4375 4376 4377
			if (!sk_rmem_schedule(sk, size))
				return -1;
		}
	}
	return 0;
}

L
Linus Torvalds 已提交
4378 4379
static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
{
4380
	struct tcphdr *th = tcp_hdr(skb);
L
Linus Torvalds 已提交
4381 4382 4383 4384 4385 4386
	struct tcp_sock *tp = tcp_sk(sk);
	int eaten = -1;

	if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq)
		goto drop;

E
Eric Dumazet 已提交
4387
	skb_dst_drop(skb);
4388
	__skb_pull(skb, th->doff * 4);
L
Linus Torvalds 已提交
4389 4390 4391

	TCP_ECN_accept_cwr(tp, skb);

4392
	tp->rx_opt.dsack = 0;
L
Linus Torvalds 已提交
4393 4394 4395 4396 4397 4398 4399 4400 4401 4402 4403 4404 4405 4406

	/*  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,
4407
					  tp->ucopy.len);
L
Linus Torvalds 已提交
4408 4409 4410 4411 4412 4413 4414

			__set_current_state(TASK_RUNNING);

			local_bh_enable();
			if (!skb_copy_datagram_iovec(skb, 0, tp->ucopy.iov, chunk)) {
				tp->ucopy.len -= chunk;
				tp->copied_seq += chunk;
4415
				eaten = (chunk == skb->len);
L
Linus Torvalds 已提交
4416 4417 4418 4419 4420 4421 4422 4423
				tcp_rcv_space_adjust(sk);
			}
			local_bh_disable();
		}

		if (eaten <= 0) {
queue_and_out:
			if (eaten < 0 &&
4424 4425 4426
			    tcp_try_rmem_schedule(sk, skb->truesize))
				goto drop;

4427
			skb_set_owner_r(skb, sk);
L
Linus Torvalds 已提交
4428 4429 4430
			__skb_queue_tail(&sk->sk_receive_queue, skb);
		}
		tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
S
Stephen Hemminger 已提交
4431
		if (skb->len)
4432
			tcp_event_data_recv(sk, skb);
S
Stephen Hemminger 已提交
4433
		if (th->fin)
L
Linus Torvalds 已提交
4434 4435
			tcp_fin(skb, sk, th);

4436
		if (!skb_queue_empty(&tp->out_of_order_queue)) {
L
Linus Torvalds 已提交
4437 4438 4439 4440 4441
			tcp_ofo_queue(sk);

			/* RFC2581. 4.2. SHOULD send immediate ACK, when
			 * gap in queue is filled.
			 */
4442
			if (skb_queue_empty(&tp->out_of_order_queue))
4443
				inet_csk(sk)->icsk_ack.pingpong = 0;
L
Linus Torvalds 已提交
4444 4445 4446 4447 4448
		}

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

4449
		tcp_fast_path_check(sk);
L
Linus Torvalds 已提交
4450 4451 4452 4453 4454 4455 4456 4457 4458 4459

		if (eaten > 0)
			__kfree_skb(skb);
		else if (!sock_flag(sk, SOCK_DEAD))
			sk->sk_data_ready(sk, 0);
		return;
	}

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

out_of_window:
4464 4465
		tcp_enter_quickack_mode(sk);
		inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4466 4467 4468 4469 4470 4471 4472 4473 4474
drop:
		__kfree_skb(skb);
		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;

4475
	tcp_enter_quickack_mode(sk);
L
Linus Torvalds 已提交
4476 4477 4478 4479 4480 4481 4482

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

4483
		tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
4484

L
Linus Torvalds 已提交
4485 4486 4487 4488 4489 4490 4491 4492 4493 4494
		/* 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;
	}

	TCP_ECN_check_ce(tp, skb);

4495 4496
	if (tcp_try_rmem_schedule(sk, skb->truesize))
		goto drop;
L
Linus Torvalds 已提交
4497 4498 4499

	/* Disable header prediction. */
	tp->pred_flags = 0;
4500
	inet_csk_schedule_ack(sk);
L
Linus Torvalds 已提交
4501 4502 4503 4504

	SOCK_DEBUG(sk, "out of order segment: rcv_next %X seq %X - %X\n",
		   tp->rcv_nxt, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);

4505
	skb_set_owner_r(skb, sk);
L
Linus Torvalds 已提交
4506 4507 4508

	if (!skb_peek(&tp->out_of_order_queue)) {
		/* Initial out of order segment, build 1 SACK. */
4509
		if (tcp_is_sack(tp)) {
L
Linus Torvalds 已提交
4510 4511 4512 4513 4514
			tp->rx_opt.num_sacks = 1;
			tp->selective_acks[0].start_seq = TCP_SKB_CB(skb)->seq;
			tp->selective_acks[0].end_seq =
						TCP_SKB_CB(skb)->end_seq;
		}
4515
		__skb_queue_head(&tp->out_of_order_queue, skb);
L
Linus Torvalds 已提交
4516
	} else {
4517
		struct sk_buff *skb1 = skb_peek_tail(&tp->out_of_order_queue);
L
Linus Torvalds 已提交
4518 4519 4520 4521
		u32 seq = TCP_SKB_CB(skb)->seq;
		u32 end_seq = TCP_SKB_CB(skb)->end_seq;

		if (seq == TCP_SKB_CB(skb1)->end_seq) {
4522
			__skb_queue_after(&tp->out_of_order_queue, skb1, skb);
L
Linus Torvalds 已提交
4523 4524 4525 4526 4527 4528 4529 4530 4531 4532 4533

			if (!tp->rx_opt.num_sacks ||
			    tp->selective_acks[0].end_seq != seq)
				goto add_sack;

			/* Common case: data arrive in order after hole. */
			tp->selective_acks[0].end_seq = end_seq;
			return;
		}

		/* Find place to insert this segment. */
4534
		while (1) {
L
Linus Torvalds 已提交
4535 4536
			if (!after(TCP_SKB_CB(skb1)->seq, seq))
				break;
4537 4538 4539 4540 4541 4542
			if (skb_queue_is_first(&tp->out_of_order_queue, skb1)) {
				skb1 = NULL;
				break;
			}
			skb1 = skb_queue_prev(&tp->out_of_order_queue, skb1);
		}
L
Linus Torvalds 已提交
4543 4544

		/* Do skb overlap to previous one? */
4545
		if (skb1 && before(seq, TCP_SKB_CB(skb1)->end_seq)) {
L
Linus Torvalds 已提交
4546 4547 4548
			if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
				/* All the bits are present. Drop. */
				__kfree_skb(skb);
4549
				tcp_dsack_set(sk, seq, end_seq);
L
Linus Torvalds 已提交
4550 4551 4552 4553
				goto add_sack;
			}
			if (after(seq, TCP_SKB_CB(skb1)->seq)) {
				/* Partial overlap. */
4554
				tcp_dsack_set(sk, seq,
4555
					      TCP_SKB_CB(skb1)->end_seq);
L
Linus Torvalds 已提交
4556
			} else {
4557 4558 4559 4560 4561 4562 4563
				if (skb_queue_is_first(&tp->out_of_order_queue,
						       skb1))
					skb1 = NULL;
				else
					skb1 = skb_queue_prev(
						&tp->out_of_order_queue,
						skb1);
L
Linus Torvalds 已提交
4564 4565
			}
		}
4566 4567 4568 4569
		if (!skb1)
			__skb_queue_head(&tp->out_of_order_queue, skb);
		else
			__skb_queue_after(&tp->out_of_order_queue, skb1, skb);
4570

L
Linus Torvalds 已提交
4571
		/* And clean segments covered by new one as whole. */
4572 4573
		while (!skb_queue_is_last(&tp->out_of_order_queue, skb)) {
			skb1 = skb_queue_next(&tp->out_of_order_queue, skb);
4574

4575 4576 4577
			if (!after(end_seq, TCP_SKB_CB(skb1)->seq))
				break;
			if (before(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
4578
				tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
4579 4580
						 end_seq);
				break;
4581
			}
4582 4583 4584 4585
			__skb_unlink(skb1, &tp->out_of_order_queue);
			tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
					 TCP_SKB_CB(skb1)->end_seq);
			__kfree_skb(skb1);
L
Linus Torvalds 已提交
4586 4587 4588
		}

add_sack:
4589
		if (tcp_is_sack(tp))
L
Linus Torvalds 已提交
4590 4591 4592 4593
			tcp_sack_new_ofo_skb(sk, seq, end_seq);
	}
}

4594 4595 4596
static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
					struct sk_buff_head *list)
{
4597 4598 4599 4600
	struct sk_buff *next = NULL;

	if (!skb_queue_is_last(list, skb))
		next = skb_queue_next(list, skb);
4601 4602 4603 4604 4605 4606 4607 4608

	__skb_unlink(skb, list);
	__kfree_skb(skb);
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);

	return next;
}

L
Linus Torvalds 已提交
4609 4610
/* Collapse contiguous sequence of skbs head..tail with
 * sequence numbers start..end.
4611 4612 4613
 *
 * If tail is NULL, this means until the end of the list.
 *
L
Linus Torvalds 已提交
4614 4615 4616 4617
 * Segments with FIN/SYN are not collapsed (only because this
 * simplifies code)
 */
static void
D
David S. Miller 已提交
4618 4619 4620
tcp_collapse(struct sock *sk, struct sk_buff_head *list,
	     struct sk_buff *head, struct sk_buff *tail,
	     u32 start, u32 end)
L
Linus Torvalds 已提交
4621
{
4622 4623
	struct sk_buff *skb, *n;
	bool end_of_skbs;
L
Linus Torvalds 已提交
4624

S
Stephen Hemminger 已提交
4625
	/* First, check that queue is collapsible and find
L
Linus Torvalds 已提交
4626
	 * the point where collapsing can be useful. */
4627 4628 4629 4630 4631 4632
	skb = head;
restart:
	end_of_skbs = true;
	skb_queue_walk_from_safe(list, skb, n) {
		if (skb == tail)
			break;
L
Linus Torvalds 已提交
4633 4634
		/* No new bits? It is possible on ofo queue. */
		if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
4635
			skb = tcp_collapse_one(sk, skb, list);
4636 4637 4638
			if (!skb)
				break;
			goto restart;
L
Linus Torvalds 已提交
4639 4640 4641 4642 4643 4644 4645
		}

		/* The first skb to collapse is:
		 * - not SYN/FIN and
		 * - bloated or contains data before "start" or
		 *   overlaps to the next one.
		 */
4646
		if (!tcp_hdr(skb)->syn && !tcp_hdr(skb)->fin &&
L
Linus Torvalds 已提交
4647
		    (tcp_win_from_space(skb->truesize) > skb->len ||
4648 4649
		     before(TCP_SKB_CB(skb)->seq, start))) {
			end_of_skbs = false;
L
Linus Torvalds 已提交
4650
			break;
4651 4652 4653 4654 4655 4656 4657 4658 4659 4660
		}

		if (!skb_queue_is_last(list, skb)) {
			struct sk_buff *next = skb_queue_next(list, skb);
			if (next != tail &&
			    TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(next)->seq) {
				end_of_skbs = false;
				break;
			}
		}
L
Linus Torvalds 已提交
4661 4662 4663 4664

		/* Decided to skip this, advance start seq. */
		start = TCP_SKB_CB(skb)->end_seq;
	}
4665
	if (end_of_skbs || tcp_hdr(skb)->syn || tcp_hdr(skb)->fin)
L
Linus Torvalds 已提交
4666 4667 4668 4669
		return;

	while (before(start, end)) {
		struct sk_buff *nskb;
4670
		unsigned int header = skb_headroom(skb);
L
Linus Torvalds 已提交
4671 4672 4673 4674 4675
		int copy = SKB_MAX_ORDER(header, 0);

		/* Too big header? This can happen with IPv6. */
		if (copy < 0)
			return;
4676 4677 4678
		if (end - start < copy)
			copy = end - start;
		nskb = alloc_skb(copy + header, GFP_ATOMIC);
L
Linus Torvalds 已提交
4679 4680
		if (!nskb)
			return;
4681

4682
		skb_set_mac_header(nskb, skb_mac_header(skb) - skb->head);
4683 4684 4685 4686
		skb_set_network_header(nskb, (skb_network_header(skb) -
					      skb->head));
		skb_set_transport_header(nskb, (skb_transport_header(skb) -
						skb->head));
L
Linus Torvalds 已提交
4687 4688 4689 4690
		skb_reserve(nskb, header);
		memcpy(nskb->head, skb->head, header);
		memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
		TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
4691
		__skb_queue_before(list, skb, nskb);
4692
		skb_set_owner_r(nskb, sk);
L
Linus Torvalds 已提交
4693 4694 4695 4696 4697 4698

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

4699
			BUG_ON(offset < 0);
L
Linus Torvalds 已提交
4700 4701 4702 4703 4704 4705 4706 4707 4708
			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)) {
4709
				skb = tcp_collapse_one(sk, skb, list);
4710 4711
				if (!skb ||
				    skb == tail ||
4712 4713
				    tcp_hdr(skb)->syn ||
				    tcp_hdr(skb)->fin)
L
Linus Torvalds 已提交
4714 4715 4716 4717 4718 4719 4720 4721 4722 4723 4724 4725 4726 4727 4728 4729 4730 4731 4732 4733 4734 4735 4736 4737
					return;
			}
		}
	}
}

/* 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);
	struct sk_buff *skb = skb_peek(&tp->out_of_order_queue);
	struct sk_buff *head;
	u32 start, end;

	if (skb == NULL)
		return;

	start = TCP_SKB_CB(skb)->seq;
	end = TCP_SKB_CB(skb)->end_seq;
	head = skb;

	for (;;) {
4738 4739 4740 4741 4742
		struct sk_buff *next = NULL;

		if (!skb_queue_is_last(&tp->out_of_order_queue, skb))
			next = skb_queue_next(&tp->out_of_order_queue, skb);
		skb = next;
L
Linus Torvalds 已提交
4743 4744 4745

		/* Segment is terminated when we see gap or when
		 * we are at the end of all the queue. */
4746
		if (!skb ||
L
Linus Torvalds 已提交
4747 4748
		    after(TCP_SKB_CB(skb)->seq, end) ||
		    before(TCP_SKB_CB(skb)->end_seq, start)) {
D
David S. Miller 已提交
4749 4750
			tcp_collapse(sk, &tp->out_of_order_queue,
				     head, skb, start, end);
L
Linus Torvalds 已提交
4751
			head = skb;
4752
			if (!skb)
L
Linus Torvalds 已提交
4753 4754 4755 4756 4757 4758 4759 4760 4761 4762 4763 4764 4765
				break;
			/* Start new segment */
			start = TCP_SKB_CB(skb)->seq;
			end = TCP_SKB_CB(skb)->end_seq;
		} else {
			if (before(TCP_SKB_CB(skb)->seq, start))
				start = TCP_SKB_CB(skb)->seq;
			if (after(TCP_SKB_CB(skb)->end_seq, end))
				end = TCP_SKB_CB(skb)->end_seq;
		}
	}
}

4766 4767
/*
 * Purge the out-of-order queue.
4768
 * Return true if queue was pruned.
4769
 */
4770
static int tcp_prune_ofo_queue(struct sock *sk)
4771 4772
{
	struct tcp_sock *tp = tcp_sk(sk);
4773
	int res = 0;
4774 4775

	if (!skb_queue_empty(&tp->out_of_order_queue)) {
4776
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_OFOPRUNED);
4777 4778 4779 4780 4781 4782 4783 4784 4785 4786
		__skb_queue_purge(&tp->out_of_order_queue);

		/* 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);
		sk_mem_reclaim(sk);
4787
		res = 1;
4788
	}
4789
	return res;
4790 4791
}

L
Linus Torvalds 已提交
4792 4793 4794 4795 4796 4797 4798 4799 4800
/* 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)
{
4801
	struct tcp_sock *tp = tcp_sk(sk);
L
Linus Torvalds 已提交
4802 4803 4804

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

4805
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PRUNECALLED);
L
Linus Torvalds 已提交
4806 4807

	if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
4808
		tcp_clamp_window(sk);
L
Linus Torvalds 已提交
4809 4810 4811 4812
	else if (tcp_memory_pressure)
		tp->rcv_ssthresh = min(tp->rcv_ssthresh, 4U * tp->advmss);

	tcp_collapse_ofo_queue(sk);
4813 4814 4815 4816 4817
	if (!skb_queue_empty(&sk->sk_receive_queue))
		tcp_collapse(sk, &sk->sk_receive_queue,
			     skb_peek(&sk->sk_receive_queue),
			     NULL,
			     tp->copied_seq, tp->rcv_nxt);
4818
	sk_mem_reclaim(sk);
L
Linus Torvalds 已提交
4819 4820 4821 4822 4823 4824 4825

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

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

4826
	tcp_prune_ofo_queue(sk);
L
Linus Torvalds 已提交
4827 4828 4829 4830 4831 4832 4833 4834

	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.
	 */
4835
	NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_RCVPRUNED);
L
Linus Torvalds 已提交
4836 4837 4838 4839 4840 4841 4842 4843 4844 4845 4846 4847 4848 4849

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

/* RFC2861, slow part. Adjust cwnd, after it was not full during one rto.
 * As additional protections, we do not touch cwnd in retransmission phases,
 * and if application hit its sndbuf limit recently.
 */
void tcp_cwnd_application_limited(struct sock *sk)
{
	struct tcp_sock *tp = tcp_sk(sk);

4850
	if (inet_csk(sk)->icsk_ca_state == TCP_CA_Open &&
L
Linus Torvalds 已提交
4851 4852
	    sk->sk_socket && !test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
		/* Limited by application or receiver window. */
4853 4854
		u32 init_win = tcp_init_cwnd(tp, __sk_dst_get(sk));
		u32 win_used = max(tp->snd_cwnd_used, init_win);
L
Linus Torvalds 已提交
4855
		if (win_used < tp->snd_cwnd) {
4856
			tp->snd_ssthresh = tcp_current_ssthresh(sk);
L
Linus Torvalds 已提交
4857 4858 4859 4860 4861 4862 4863
			tp->snd_cwnd = (tp->snd_cwnd + win_used) >> 1;
		}
		tp->snd_cwnd_used = 0;
	}
	tp->snd_cwnd_stamp = tcp_time_stamp;
}

4864
static int tcp_should_expand_sndbuf(struct sock *sk)
4865
{
4866 4867
	struct tcp_sock *tp = tcp_sk(sk);

4868 4869 4870 4871 4872 4873 4874 4875 4876 4877 4878
	/* If the user specified a specific send buffer setting, do
	 * not modify it.
	 */
	if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
		return 0;

	/* If we are under global TCP memory pressure, do not expand.  */
	if (tcp_memory_pressure)
		return 0;

	/* If we are under soft global TCP memory pressure, do not expand.  */
E
Eric Dumazet 已提交
4879
	if (atomic_long_read(&tcp_memory_allocated) >= sysctl_tcp_mem[0])
4880 4881 4882 4883 4884 4885 4886 4887
		return 0;

	/* If we filled the congestion window, do not expand.  */
	if (tp->packets_out >= tp->snd_cwnd)
		return 0;

	return 1;
}
L
Linus Torvalds 已提交
4888 4889 4890 4891 4892 4893 4894 4895 4896 4897 4898

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

4899
	if (tcp_should_expand_sndbuf(sk)) {
4900
		int sndmem = max_t(u32, tp->rx_opt.mss_clamp, tp->mss_cache) +
I
Ilpo Järvinen 已提交
4901 4902
			MAX_TCP_HEADER + 16 + sizeof(struct sk_buff);
		int demanded = max_t(unsigned int, tp->snd_cwnd,
4903 4904
				     tp->reordering + 1);
		sndmem *= 2 * demanded;
L
Linus Torvalds 已提交
4905 4906 4907 4908 4909 4910 4911 4912
		if (sndmem > sk->sk_sndbuf)
			sk->sk_sndbuf = min(sndmem, sysctl_tcp_wmem[2]);
		tp->snd_cwnd_stamp = tcp_time_stamp;
	}

	sk->sk_write_space(sk);
}

S
Stephen Hemminger 已提交
4913
static void tcp_check_space(struct sock *sk)
L
Linus Torvalds 已提交
4914 4915 4916 4917 4918 4919 4920 4921 4922
{
	if (sock_flag(sk, SOCK_QUEUE_SHRUNK)) {
		sock_reset_flag(sk, SOCK_QUEUE_SHRUNK);
		if (sk->sk_socket &&
		    test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
			tcp_new_space(sk);
	}
}

4923
static inline void tcp_data_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
4924
{
4925
	tcp_push_pending_frames(sk);
L
Linus Torvalds 已提交
4926 4927 4928 4929 4930 4931 4932 4933 4934 4935 4936
	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... */
4937
	if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss &&
L
Linus Torvalds 已提交
4938 4939 4940
	     /* ... and right edge of window advances far enough.
	      * (tcp_recvmsg() will send ACK otherwise). Or...
	      */
4941
	     __tcp_select_window(sk) >= tp->rcv_wnd) ||
L
Linus Torvalds 已提交
4942
	    /* We ACK each frame or... */
4943
	    tcp_in_quickack_mode(sk) ||
L
Linus Torvalds 已提交
4944
	    /* We have out of order data. */
4945
	    (ofo_possible && skb_peek(&tp->out_of_order_queue))) {
L
Linus Torvalds 已提交
4946 4947 4948 4949 4950 4951 4952 4953
		/* Then ack it now */
		tcp_send_ack(sk);
	} else {
		/* Else, send delayed ack. */
		tcp_send_delayed_ack(sk);
	}
}

S
Stephen Hemminger 已提交
4954
static inline void tcp_ack_snd_check(struct sock *sk)
L
Linus Torvalds 已提交
4955
{
4956
	if (!inet_csk_ack_scheduled(sk)) {
L
Linus Torvalds 已提交
4957 4958 4959 4960 4961 4962 4963 4964
		/* 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 已提交
4965
 *	signaled. Its the 'slow' part of tcp_urg. It could be
L
Linus Torvalds 已提交
4966 4967 4968 4969 4970 4971
 *	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).
 */
4972

4973
static void tcp_check_urg(struct sock *sk, struct tcphdr *th)
L
Linus Torvalds 已提交
4974 4975 4976 4977 4978 4979 4980 4981 4982 4983 4984 4985 4986 4987 4988 4989 4990 4991 4992 4993 4994 4995 4996 4997 4998 4999 5000 5001 5002 5003 5004 5005 5006 5007 5008 5009
{
	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 已提交
5010
	 * or we break the semantics of SIOCATMARK (and thus sockatmark())
L
Linus Torvalds 已提交
5011 5012 5013 5014 5015 5016 5017 5018 5019 5020 5021
	 *
	 * 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 &&
5022
	    !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
L
Linus Torvalds 已提交
5023 5024 5025
		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 已提交
5026
			__skb_unlink(skb, &sk->sk_receive_queue);
L
Linus Torvalds 已提交
5027 5028 5029 5030
			__kfree_skb(skb);
		}
	}

5031 5032
	tp->urg_data = TCP_URG_NOTYET;
	tp->urg_seq = ptr;
L
Linus Torvalds 已提交
5033 5034 5035 5036 5037 5038 5039 5040 5041 5042 5043 5044

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

/* This is the 'fast' part of urgent handling. */
static void tcp_urg(struct sock *sk, struct sk_buff *skb, struct tcphdr *th)
{
	struct tcp_sock *tp = tcp_sk(sk);

	/* Check if we get a new urgent pointer - normally not. */
	if (th->urg)
5045
		tcp_check_urg(sk, th);
L
Linus Torvalds 已提交
5046 5047 5048 5049 5050 5051

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

5052
		/* Is the urgent pointer pointing into this packet? */
L
Linus Torvalds 已提交
5053 5054 5055 5056 5057 5058 5059 5060 5061 5062 5063 5064 5065 5066 5067 5068 5069 5070
		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))
				sk->sk_data_ready(sk, 0);
		}
	}
}

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;

	local_bh_enable();
5071
	if (skb_csum_unnecessary(skb))
L
Linus Torvalds 已提交
5072 5073 5074 5075 5076 5077 5078 5079 5080 5081 5082 5083 5084 5085 5086
		err = skb_copy_datagram_iovec(skb, hlen, tp->ucopy.iov, chunk);
	else
		err = skb_copy_and_csum_datagram_iovec(skb, hlen,
						       tp->ucopy.iov);

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

	local_bh_disable();
	return err;
}

5087 5088
static __sum16 __tcp_checksum_complete_user(struct sock *sk,
					    struct sk_buff *skb)
L
Linus Torvalds 已提交
5089
{
5090
	__sum16 result;
L
Linus Torvalds 已提交
5091 5092 5093 5094 5095 5096 5097 5098 5099 5100 5101

	if (sock_owned_by_user(sk)) {
		local_bh_enable();
		result = __tcp_checksum_complete(skb);
		local_bh_disable();
	} else {
		result = __tcp_checksum_complete(skb);
	}
	return result;
}

5102 5103
static inline int tcp_checksum_complete_user(struct sock *sk,
					     struct sk_buff *skb)
L
Linus Torvalds 已提交
5104
{
5105
	return !skb_csum_unnecessary(skb) &&
5106
	       __tcp_checksum_complete_user(sk, skb);
L
Linus Torvalds 已提交
5107 5108
}

C
Chris Leech 已提交
5109
#ifdef CONFIG_NET_DMA
5110 5111
static int tcp_dma_try_early_copy(struct sock *sk, struct sk_buff *skb,
				  int hlen)
C
Chris Leech 已提交
5112 5113 5114 5115 5116 5117 5118
{
	struct tcp_sock *tp = tcp_sk(sk);
	int chunk = skb->len - hlen;
	int dma_cookie;
	int copied_early = 0;

	if (tp->ucopy.wakeup)
5119
		return 0;
C
Chris Leech 已提交
5120 5121

	if (!tp->ucopy.dma_chan && tp->ucopy.pinned_list)
5122
		tp->ucopy.dma_chan = dma_find_channel(DMA_MEMCPY);
C
Chris Leech 已提交
5123

5124
	if (tp->ucopy.dma_chan && skb_csum_unnecessary(skb)) {
C
Chris Leech 已提交
5125 5126

		dma_cookie = dma_skb_copy_datagram_iovec(tp->ucopy.dma_chan,
5127 5128 5129
							 skb, hlen,
							 tp->ucopy.iov, chunk,
							 tp->ucopy.pinned_list);
C
Chris Leech 已提交
5130 5131 5132 5133 5134 5135 5136 5137 5138 5139 5140 5141

		if (dma_cookie < 0)
			goto out;

		tp->ucopy.dma_cookie = dma_cookie;
		copied_early = 1;

		tp->ucopy.len -= chunk;
		tp->copied_seq += chunk;
		tcp_rcv_space_adjust(sk);

		if ((tp->ucopy.len == 0) ||
5142
		    (tcp_flag_word(tcp_hdr(skb)) & TCP_FLAG_PSH) ||
C
Chris Leech 已提交
5143 5144 5145 5146 5147 5148 5149 5150 5151 5152 5153 5154 5155
		    (atomic_read(&sk->sk_rmem_alloc) > (sk->sk_rcvbuf >> 1))) {
			tp->ucopy.wakeup = 1;
			sk->sk_data_ready(sk, 0);
		}
	} else if (chunk > 0) {
		tp->ucopy.wakeup = 1;
		sk->sk_data_ready(sk, 0);
	}
out:
	return copied_early;
}
#endif /* CONFIG_NET_DMA */

5156 5157 5158 5159 5160 5161
/* Does PAWS and seqno based validation of an incoming segment, flags will
 * play significant role here.
 */
static int tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
			      struct tcphdr *th, int syn_inerr)
{
5162
	u8 *hash_location;
5163 5164 5165
	struct tcp_sock *tp = tcp_sk(sk);

	/* RFC1323: H1. Apply PAWS check first. */
5166 5167
	if (tcp_fast_parse_options(skb, th, tp, &hash_location) &&
	    tp->rx_opt.saw_tstamp &&
5168 5169 5170 5171 5172 5173 5174 5175 5176 5177 5178 5179 5180 5181 5182 5183 5184 5185 5186 5187 5188 5189 5190 5191 5192 5193 5194 5195 5196 5197 5198 5199 5200 5201 5202 5203 5204 5205 5206 5207 5208 5209 5210 5211 5212 5213 5214 5215 5216 5217 5218
	    tcp_paws_discard(sk, skb)) {
		if (!th->rst) {
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
			tcp_send_dupack(sk, skb);
			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)".
		 */
		if (!th->rst)
			tcp_send_dupack(sk, skb);
		goto discard;
	}

	/* Step 2: check RST bit */
	if (th->rst) {
		tcp_reset(sk);
		goto discard;
	}

	/* ts_recent update must be made after we are sure that the packet
	 * is in window.
	 */
	tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);

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

	/* step 4: Check for a SYN in window. */
	if (th->syn && !before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
		if (syn_inerr)
			TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
		NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONSYN);
		tcp_reset(sk);
		return -1;
	}

	return 1;

discard:
	__kfree_skb(skb);
	return 0;
}

L
Linus Torvalds 已提交
5219
/*
5220
 *	TCP receive function for the ESTABLISHED state.
L
Linus Torvalds 已提交
5221
 *
5222
 *	It is split into a fast path and a slow path. The fast path is
L
Linus Torvalds 已提交
5223 5224
 * 	disabled when:
 *	- A zero window was announced from us - zero window probing
5225
 *        is only handled properly in the slow path.
L
Linus Torvalds 已提交
5226 5227 5228 5229
 *	- Out of order segments arrived.
 *	- Urgent data is expected.
 *	- There is no buffer space left
 *	- Unexpected TCP flags/window values/header lengths are received
5230
 *	  (detected by checking the TCP header against pred_flags)
L
Linus Torvalds 已提交
5231 5232 5233 5234 5235
 *	- 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.
 *
5236
 *	When these conditions are not satisfied it drops into a standard
L
Linus Torvalds 已提交
5237 5238
 *	receive procedure patterned after RFC793 to handle all cases.
 *	The first three cases are guaranteed by proper pred_flags setting,
5239
 *	the rest is checked inline. Fast processing is turned on in
L
Linus Torvalds 已提交
5240 5241 5242 5243 5244 5245
 *	tcp_data_queue when everything is OK.
 */
int tcp_rcv_established(struct sock *sk, struct sk_buff *skb,
			struct tcphdr *th, unsigned len)
{
	struct tcp_sock *tp = tcp_sk(sk);
5246
	int res;
L
Linus Torvalds 已提交
5247 5248 5249

	/*
	 *	Header prediction.
5250
	 *	The code loosely follows the one in the famous
L
Linus Torvalds 已提交
5251
	 *	"30 instruction TCP receive" Van Jacobson mail.
5252 5253
	 *
	 *	Van's trick is to deposit buffers into socket queue
L
Linus Torvalds 已提交
5254 5255 5256 5257
	 *	on a device interrupt, to call tcp_recv function
	 *	on the receive process context and checksum and copy
	 *	the buffer to user space. smart...
	 *
5258
	 *	Our current scheme is not silly either but we take the
L
Linus Torvalds 已提交
5259 5260 5261 5262 5263 5264 5265
	 *	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 已提交
5266
	 *	if header_prediction is to be made
L
Linus Torvalds 已提交
5267 5268
	 *	'S' will always be tp->tcp_header_len >> 2
	 *	'?' will be 0 for the fast path, otherwise pred_flags is 0 to
5269
	 *  turn it off	(when there are holes in the receive
L
Linus Torvalds 已提交
5270 5271 5272 5273 5274
	 *	 space for instance)
	 *	PSH flag is ignored.
	 */

	if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
5275 5276
	    TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
	    !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
L
Linus Torvalds 已提交
5277 5278 5279 5280 5281 5282 5283 5284 5285 5286
		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! */
5287
			if (!tcp_parse_aligned_timestamp(tp, th))
L
Linus Torvalds 已提交
5288 5289 5290 5291 5292 5293 5294 5295 5296 5297 5298 5299 5300 5301 5302 5303 5304 5305 5306 5307 5308 5309 5310 5311 5312 5313 5314 5315 5316
				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);
5317
				__kfree_skb(skb);
5318
				tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5319 5320
				return 0;
			} else { /* Header too small */
5321
				TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5322 5323 5324 5325
				goto discard;
			}
		} else {
			int eaten = 0;
C
Chris Leech 已提交
5326
			int copied_early = 0;
L
Linus Torvalds 已提交
5327

C
Chris Leech 已提交
5328 5329 5330 5331 5332 5333 5334 5335
			if (tp->copied_seq == tp->rcv_nxt &&
			    len - tcp_header_len <= tp->ucopy.len) {
#ifdef CONFIG_NET_DMA
				if (tcp_dma_try_early_copy(sk, skb, tcp_header_len)) {
					copied_early = 1;
					eaten = 1;
				}
#endif
5336 5337
				if (tp->ucopy.task == current &&
				    sock_owned_by_user(sk) && !copied_early) {
C
Chris Leech 已提交
5338
					__set_current_state(TASK_RUNNING);
L
Linus Torvalds 已提交
5339

C
Chris Leech 已提交
5340 5341 5342 5343
					if (!tcp_copy_to_iovec(sk, skb, tcp_header_len))
						eaten = 1;
				}
				if (eaten) {
L
Linus Torvalds 已提交
5344 5345 5346 5347 5348 5349 5350 5351 5352 5353
					/* 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);

5354
					tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5355 5356 5357

					__skb_pull(skb, tcp_header_len);
					tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
5358
					NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITSTOUSER);
L
Linus Torvalds 已提交
5359
				}
C
Chris Leech 已提交
5360 5361
				if (copied_early)
					tcp_cleanup_rbuf(sk, skb->len);
L
Linus Torvalds 已提交
5362 5363 5364 5365 5366 5367 5368 5369 5370 5371 5372 5373 5374 5375
			}
			if (!eaten) {
				if (tcp_checksum_complete_user(sk, skb))
					goto csum_error;

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

5376
				tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5377 5378 5379 5380

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

5381
				NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPHPHITS);
L
Linus Torvalds 已提交
5382 5383

				/* Bulk data transfer: receiver */
5384
				__skb_pull(skb, tcp_header_len);
L
Linus Torvalds 已提交
5385
				__skb_queue_tail(&sk->sk_receive_queue, skb);
5386
				skb_set_owner_r(skb, sk);
L
Linus Torvalds 已提交
5387 5388 5389
				tp->rcv_nxt = TCP_SKB_CB(skb)->end_seq;
			}

5390
			tcp_event_data_recv(sk, skb);
L
Linus Torvalds 已提交
5391 5392 5393 5394

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

5400 5401
			if (!copied_early || tp->rcv_nxt != tp->rcv_wup)
				__tcp_ack_snd_check(sk, 0);
L
Linus Torvalds 已提交
5402
no_ack:
C
Chris Leech 已提交
5403 5404 5405 5406 5407
#ifdef CONFIG_NET_DMA
			if (copied_early)
				__skb_queue_tail(&sk->sk_async_wait_queue, skb);
			else
#endif
L
Linus Torvalds 已提交
5408 5409 5410 5411 5412 5413 5414 5415 5416
			if (eaten)
				__kfree_skb(skb);
			else
				sk->sk_data_ready(sk, 0);
			return 0;
		}
	}

slow_path:
5417
	if (len < (th->doff << 2) || tcp_checksum_complete_user(sk, skb))
L
Linus Torvalds 已提交
5418 5419 5420 5421 5422 5423
		goto csum_error;

	/*
	 *	Standard slow path.
	 */

5424 5425 5426
	res = tcp_validate_incoming(sk, skb, th, 1);
	if (res <= 0)
		return -res;
L
Linus Torvalds 已提交
5427 5428

step5:
5429 5430
	if (th->ack && tcp_ack(sk, skb, FLAG_SLOWPATH) < 0)
		goto discard;
L
Linus Torvalds 已提交
5431

5432
	tcp_rcv_rtt_measure_ts(sk, skb);
L
Linus Torvalds 已提交
5433 5434 5435 5436 5437 5438 5439

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

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

5440
	tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5441 5442 5443 5444
	tcp_ack_snd_check(sk);
	return 0;

csum_error:
5445
	TCP_INC_STATS_BH(sock_net(sk), TCP_MIB_INERRS);
L
Linus Torvalds 已提交
5446 5447 5448 5449 5450

discard:
	__kfree_skb(skb);
	return 0;
}
E
Eric Dumazet 已提交
5451
EXPORT_SYMBOL(tcp_rcv_established);
L
Linus Torvalds 已提交
5452 5453 5454 5455

static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
					 struct tcphdr *th, unsigned len)
{
5456
	u8 *hash_location;
5457
	struct inet_connection_sock *icsk = inet_csk(sk);
5458 5459 5460
	struct tcp_sock *tp = tcp_sk(sk);
	struct tcp_cookie_values *cvp = tp->cookie_values;
	int saved_clamp = tp->rx_opt.mss_clamp;
L
Linus Torvalds 已提交
5461

5462
	tcp_parse_options(skb, &tp->rx_opt, &hash_location, 0);
L
Linus Torvalds 已提交
5463 5464 5465 5466 5467 5468 5469 5470 5471 5472 5473 5474 5475 5476 5477 5478 5479 5480 5481

	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)"
		 *
		 *  We do not send data with SYN, so that RFC-correct
		 *  test reduces to:
		 */
		if (TCP_SKB_CB(skb)->ack_seq != tp->snd_nxt)
			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)) {
5482
			NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_PAWSACTIVEREJECTED);
L
Linus Torvalds 已提交
5483 5484 5485 5486 5487 5488 5489 5490 5491 5492 5493 5494 5495 5496 5497 5498 5499 5500 5501 5502 5503 5504 5505 5506 5507 5508 5509 5510 5511 5512 5513 5514 5515 5516 5517 5518 5519 5520 5521 5522 5523 5524 5525 5526 5527 5528 5529 5530
			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..."
		 */

		TCP_ECN_rcv_synack(tp, th);

		tp->snd_wl1 = TCP_SKB_CB(skb)->seq;
		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);
5531
		tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
L
Linus Torvalds 已提交
5532 5533 5534 5535 5536 5537 5538 5539 5540 5541 5542 5543 5544 5545 5546 5547

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

5548 5549
		if (tcp_is_sack(tp) && sysctl_tcp_fack)
			tcp_enable_fack(tp);
L
Linus Torvalds 已提交
5550

J
John Heffner 已提交
5551
		tcp_mtup_init(sk);
5552
		tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
L
Linus Torvalds 已提交
5553 5554 5555 5556 5557 5558
		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;
5559 5560 5561 5562 5563 5564 5565 5566 5567 5568 5569 5570 5571 5572 5573 5574 5575 5576 5577 5578 5579 5580 5581 5582 5583

		if (cvp != NULL &&
		    cvp->cookie_pair_size > 0 &&
		    tp->rx_opt.cookie_plus > 0) {
			int cookie_size = tp->rx_opt.cookie_plus
					- TCPOLEN_COOKIE_BASE;
			int cookie_pair_size = cookie_size
					     + cvp->cookie_desired;

			/* A cookie extension option was sent and returned.
			 * Note that each incoming SYNACK replaces the
			 * Responder cookie.  The initial exchange is most
			 * fragile, as protection against spoofing relies
			 * entirely upon the sequence and timestamp (above).
			 * This replacement strategy allows the correct pair to
			 * pass through, while any others will be filtered via
			 * Responder verification later.
			 */
			if (sizeof(cvp->cookie_pair) >= cookie_pair_size) {
				memcpy(&cvp->cookie_pair[cvp->cookie_desired],
				       hash_location, cookie_size);
				cvp->cookie_pair_size = cookie_pair_size;
			}
		}

R
Ralf Baechle 已提交
5584
		smp_mb();
L
Linus Torvalds 已提交
5585 5586
		tcp_set_state(sk, TCP_ESTABLISHED);

5587 5588
		security_inet_conn_established(sk, skb);

L
Linus Torvalds 已提交
5589
		/* Make sure socket is routed, for correct metrics.  */
5590
		icsk->icsk_af_ops->rebuild_header(sk);
L
Linus Torvalds 已提交
5591 5592 5593

		tcp_init_metrics(sk);

5594
		tcp_init_congestion_control(sk);
5595

L
Linus Torvalds 已提交
5596 5597 5598 5599 5600 5601 5602 5603
		/* 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))
5604
			inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
L
Linus Torvalds 已提交
5605 5606 5607 5608 5609 5610 5611 5612

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

		if (!sock_flag(sk, SOCK_DEAD)) {
			sk->sk_state_change(sk);
5613
			sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
L
Linus Torvalds 已提交
5614 5615
		}

5616 5617 5618
		if (sk->sk_write_pending ||
		    icsk->icsk_accept_queue.rskq_defer_accept ||
		    icsk->icsk_ack.pingpong) {
L
Linus Torvalds 已提交
5619 5620 5621 5622 5623 5624 5625
			/* 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
			 */
5626
			inet_csk_schedule_ack(sk);
5627 5628
			icsk->icsk_ack.lrcvtime = tcp_time_stamp;
			icsk->icsk_ack.ato	 = TCP_ATO_MIN;
5629 5630
			tcp_incr_quickack(sk);
			tcp_enter_quickack_mode(sk);
5631 5632
			inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
						  TCP_DELACK_MAX, TCP_RTO_MAX);
L
Linus Torvalds 已提交
5633 5634 5635 5636 5637 5638 5639 5640 5641 5642 5643 5644 5645 5646 5647 5648 5649 5650 5651 5652 5653 5654 5655

discard:
			__kfree_skb(skb);
			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. */
5656
	if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
I
Ilpo Järvinen 已提交
5657
	    tcp_paws_reject(&tp->rx_opt, 0))
L
Linus Torvalds 已提交
5658 5659 5660 5661 5662 5663 5664 5665 5666 5667 5668 5669 5670 5671 5672 5673 5674 5675 5676 5677 5678 5679 5680 5681 5682 5683 5684 5685 5686 5687
		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;
		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;

		TCP_ECN_rcv_syn(tp, th);

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

		tcp_send_synack(sk);
#if 0
		/* Note, we could accept data and URG from this segment.
		 * There are no obstacles to make this.
		 *
		 * 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
5725
 *	all states except ESTABLISHED and TIME_WAIT.
L
Linus Torvalds 已提交
5726 5727 5728
 *	It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
 *	address independent.
 */
5729

L
Linus Torvalds 已提交
5730 5731 5732 5733
int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb,
			  struct tcphdr *th, unsigned len)
{
	struct tcp_sock *tp = tcp_sk(sk);
5734
	struct inet_connection_sock *icsk = inet_csk(sk);
L
Linus Torvalds 已提交
5735
	int queued = 0;
5736
	int res;
L
Linus Torvalds 已提交
5737 5738 5739 5740 5741 5742 5743 5744

	tp->rx_opt.saw_tstamp = 0;

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

	case TCP_LISTEN:
S
Stephen Hemminger 已提交
5745
		if (th->ack)
L
Linus Torvalds 已提交
5746 5747
			return 1;

S
Stephen Hemminger 已提交
5748
		if (th->rst)
L
Linus Torvalds 已提交
5749 5750
			goto discard;

S
Stephen Hemminger 已提交
5751
		if (th->syn) {
5752
			if (icsk->icsk_af_ops->conn_request(sk, skb) < 0)
L
Linus Torvalds 已提交
5753 5754
				return 1;

5755 5756
			/* Now we have several options: In theory there is
			 * nothing else in the frame. KA9Q has an option to
L
Linus Torvalds 已提交
5757
			 * send data with the syn, BSD accepts data with the
5758 5759 5760
			 * syn up to the [to be] advertised window and
			 * Solaris 2.1 gives you a protocol error. For now
			 * we just ignore it, that fits the spec precisely
L
Linus Torvalds 已提交
5761 5762 5763
			 * and avoids incompatibilities. It would be nice in
			 * future to drop through and process the data.
			 *
5764
			 * Now that TTCP is starting to be used we ought to
L
Linus Torvalds 已提交
5765 5766
			 * queue this data.
			 * But, this leaves one open to an easy denial of
5767
			 * service attack, and SYN cookies can't defend
L
Linus Torvalds 已提交
5768
			 * against this problem. So, we drop the data
5769 5770
			 * in the interest of security over speed unless
			 * it's still in use.
L
Linus Torvalds 已提交
5771
			 */
5772 5773
			kfree_skb(skb);
			return 0;
L
Linus Torvalds 已提交
5774 5775 5776 5777 5778 5779 5780 5781 5782 5783 5784
		}
		goto discard;

	case TCP_SYN_SENT:
		queued = tcp_rcv_synsent_state_process(sk, skb, th, len);
		if (queued >= 0)
			return queued;

		/* Do step6 onward by hand. */
		tcp_urg(sk, skb, th);
		__kfree_skb(skb);
5785
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5786 5787 5788
		return 0;
	}

5789 5790 5791
	res = tcp_validate_incoming(sk, skb, th, 0);
	if (res <= 0)
		return -res;
L
Linus Torvalds 已提交
5792 5793 5794

	/* step 5: check the ACK field */
	if (th->ack) {
5795
		int acceptable = tcp_ack(sk, skb, FLAG_SLOWPATH) > 0;
L
Linus Torvalds 已提交
5796

S
Stephen Hemminger 已提交
5797
		switch (sk->sk_state) {
L
Linus Torvalds 已提交
5798 5799 5800
		case TCP_SYN_RECV:
			if (acceptable) {
				tp->copied_seq = tp->rcv_nxt;
R
Ralf Baechle 已提交
5801
				smp_mb();
L
Linus Torvalds 已提交
5802 5803 5804 5805 5806 5807 5808 5809
				tcp_set_state(sk, TCP_ESTABLISHED);
				sk->sk_state_change(sk);

				/* 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.
				 */
5810 5811
				if (sk->sk_socket)
					sk_wake_async(sk,
5812
						      SOCK_WAKE_IO, POLL_OUT);
L
Linus Torvalds 已提交
5813 5814 5815 5816

				tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
				tp->snd_wnd = ntohs(th->window) <<
					      tp->rx_opt.snd_wscale;
5817
				tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
L
Linus Torvalds 已提交
5818 5819 5820 5821 5822 5823 5824

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

				/* Make sure socket is routed, for
				 * correct metrics.
				 */
5825
				icsk->icsk_af_ops->rebuild_header(sk);
L
Linus Torvalds 已提交
5826 5827 5828

				tcp_init_metrics(sk);

5829
				tcp_init_congestion_control(sk);
5830

L
Linus Torvalds 已提交
5831 5832 5833 5834 5835
				/* Prevent spurious tcp_cwnd_restart() on
				 * first data packet.
				 */
				tp->lsndtime = tcp_time_stamp;

J
John Heffner 已提交
5836
				tcp_mtup_init(sk);
L
Linus Torvalds 已提交
5837 5838 5839 5840 5841 5842 5843 5844 5845 5846 5847 5848
				tcp_initialize_rcv_mss(sk);
				tcp_init_buffer_space(sk);
				tcp_fast_path_on(tp);
			} else {
				return 1;
			}
			break;

		case TCP_FIN_WAIT1:
			if (tp->snd_una == tp->write_seq) {
				tcp_set_state(sk, TCP_FIN_WAIT2);
				sk->sk_shutdown |= SEND_SHUTDOWN;
E
Eric Dumazet 已提交
5849
				dst_confirm(__sk_dst_get(sk));
L
Linus Torvalds 已提交
5850 5851 5852 5853 5854 5855 5856 5857 5858 5859 5860

				if (!sock_flag(sk, SOCK_DEAD))
					/* Wake up lingering close() */
					sk->sk_state_change(sk);
				else {
					int tmo;

					if (tp->linger2 < 0 ||
					    (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
					     after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt))) {
						tcp_done(sk);
5861
						NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
5862 5863 5864
						return 1;
					}

5865
					tmo = tcp_fin_time(sk);
L
Linus Torvalds 已提交
5866
					if (tmo > TCP_TIMEWAIT_LEN) {
5867
						inet_csk_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN);
L
Linus Torvalds 已提交
5868 5869 5870 5871 5872 5873 5874
					} 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.
						 */
5875
						inet_csk_reset_keepalive_timer(sk, tmo);
L
Linus Torvalds 已提交
5876 5877 5878 5879 5880 5881 5882 5883 5884 5885 5886 5887 5888 5889 5890 5891 5892 5893 5894 5895 5896 5897 5898 5899 5900 5901 5902 5903 5904 5905 5906 5907 5908 5909 5910 5911 5912 5913 5914
					} else {
						tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
						goto discard;
					}
				}
			}
			break;

		case TCP_CLOSING:
			if (tp->snd_una == tp->write_seq) {
				tcp_time_wait(sk, TCP_TIME_WAIT, 0);
				goto discard;
			}
			break;

		case TCP_LAST_ACK:
			if (tp->snd_una == tp->write_seq) {
				tcp_update_metrics(sk);
				tcp_done(sk);
				goto discard;
			}
			break;
		}
	} else
		goto discard;

	/* 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,
5915
		 * RFC 1122 says we MUST send a reset.
L
Linus Torvalds 已提交
5916 5917 5918 5919 5920
		 * 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)) {
5921
				NET_INC_STATS_BH(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
L
Linus Torvalds 已提交
5922 5923 5924 5925 5926
				tcp_reset(sk);
				return 1;
			}
		}
		/* Fall through */
5927
	case TCP_ESTABLISHED:
L
Linus Torvalds 已提交
5928 5929 5930 5931 5932 5933 5934
		tcp_data_queue(sk, skb);
		queued = 1;
		break;
	}

	/* tcp_data could move socket to TIME-WAIT */
	if (sk->sk_state != TCP_CLOSE) {
5935
		tcp_data_snd_check(sk);
L
Linus Torvalds 已提交
5936 5937 5938
		tcp_ack_snd_check(sk);
	}

5939
	if (!queued) {
L
Linus Torvalds 已提交
5940 5941 5942 5943 5944 5945
discard:
		__kfree_skb(skb);
	}
	return 0;
}
EXPORT_SYMBOL(tcp_rcv_state_process);