]> Git Repo - linux.git/blob - net/ipv4/tcp_input.c
drm/vc4: Run DRM default client setup
[linux.git] / net / ipv4 / tcp_input.c
1 // SPDX-License-Identifier: GPL-2.0
2 /*
3  * INET         An implementation of the TCP/IP protocol suite for the LINUX
4  *              operating system.  INET is implemented using the  BSD Socket
5  *              interface as the means of communication with the user level.
6  *
7  *              Implementation of the Transmission Control Protocol(TCP).
8  *
9  * Authors:     Ross Biro
10  *              Fred N. van Kempen, <[email protected]>
11  *              Mark Evans, <[email protected]>
12  *              Corey Minyard <[email protected]>
13  *              Florian La Roche, <[email protected]>
14  *              Charles Hedrick, <[email protected]>
15  *              Linus Torvalds, <[email protected]>
16  *              Alan Cox, <[email protected]>
17  *              Matthew Dillon, <[email protected]>
18  *              Arnt Gulbrandsen, <[email protected]>
19  *              Jorge Cwik, <[email protected]>
20  */
21
22 /*
23  * Changes:
24  *              Pedro Roque     :       Fast Retransmit/Recovery.
25  *                                      Two receive queues.
26  *                                      Retransmit queue handled by TCP.
27  *                                      Better retransmit timer handling.
28  *                                      New congestion avoidance.
29  *                                      Header prediction.
30  *                                      Variable renaming.
31  *
32  *              Eric            :       Fast Retransmit.
33  *              Randy Scott     :       MSS option defines.
34  *              Eric Schenk     :       Fixes to slow start algorithm.
35  *              Eric Schenk     :       Yet another double ACK bug.
36  *              Eric Schenk     :       Delayed ACK bug fixes.
37  *              Eric Schenk     :       Floyd style fast retrans war avoidance.
38  *              David S. Miller :       Don't allow zero congestion window.
39  *              Eric Schenk     :       Fix retransmitter so that it sends
40  *                                      next packet on ack of previous packet.
41  *              Andi Kleen      :       Moved open_request checking here
42  *                                      and process RSTs for open_requests.
43  *              Andi Kleen      :       Better prune_queue, and other fixes.
44  *              Andrey Savochkin:       Fix RTT measurements in the presence of
45  *                                      timestamps.
46  *              Andrey Savochkin:       Check sequence numbers correctly when
47  *                                      removing SACKs due to in sequence incoming
48  *                                      data segments.
49  *              Andi Kleen:             Make sure we never ack data there is not
50  *                                      enough room for. Also make this condition
51  *                                      a fatal error if it might still happen.
52  *              Andi Kleen:             Add tcp_measure_rcv_mss to make
53  *                                      connections with MSS<min(MTU,ann. MSS)
54  *                                      work without delayed acks.
55  *              Andi Kleen:             Process packets with PSH set in the
56  *                                      fast path.
57  *              J Hadi Salim:           ECN support
58  *              Andrei Gurtov,
59  *              Pasi Sarolahti,
60  *              Panu Kuhlberg:          Experimental audit of TCP (re)transmission
61  *                                      engine. Lots of bugs are found.
62  *              Pasi Sarolahti:         F-RTO for dealing with spurious RTOs
63  */
64
65 #define pr_fmt(fmt) "TCP: " fmt
66
67 #include <linux/mm.h>
68 #include <linux/slab.h>
69 #include <linux/module.h>
70 #include <linux/sysctl.h>
71 #include <linux/kernel.h>
72 #include <linux/prefetch.h>
73 #include <net/dst.h>
74 #include <net/tcp.h>
75 #include <net/proto_memory.h>
76 #include <net/inet_common.h>
77 #include <linux/ipsec.h>
78 #include <asm/unaligned.h>
79 #include <linux/errqueue.h>
80 #include <trace/events/tcp.h>
81 #include <linux/jump_label_ratelimit.h>
82 #include <net/busy_poll.h>
83 #include <net/mptcp.h>
84
85 int sysctl_tcp_max_orphans __read_mostly = NR_FILE;
86
87 #define FLAG_DATA               0x01 /* Incoming frame contained data.          */
88 #define FLAG_WIN_UPDATE         0x02 /* Incoming ACK was a window update.       */
89 #define FLAG_DATA_ACKED         0x04 /* This ACK acknowledged new data.         */
90 #define FLAG_RETRANS_DATA_ACKED 0x08 /* "" "" some of which was retransmitted.  */
91 #define FLAG_SYN_ACKED          0x10 /* This ACK acknowledged SYN.              */
92 #define FLAG_DATA_SACKED        0x20 /* New SACK.                               */
93 #define FLAG_ECE                0x40 /* ECE in this ACK                         */
94 #define FLAG_LOST_RETRANS       0x80 /* This ACK marks some retransmission lost */
95 #define FLAG_SLOWPATH           0x100 /* Do not skip RFC checks for window update.*/
96 #define FLAG_ORIG_SACK_ACKED    0x200 /* Never retransmitted data are (s)acked  */
97 #define FLAG_SND_UNA_ADVANCED   0x400 /* Snd_una was changed (!= FLAG_DATA_ACKED) */
98 #define FLAG_DSACKING_ACK       0x800 /* SACK blocks contained D-SACK info */
99 #define FLAG_SET_XMIT_TIMER     0x1000 /* Set TLP or RTO timer */
100 #define FLAG_SACK_RENEGING      0x2000 /* snd_una advanced to a sacked seq */
101 #define FLAG_UPDATE_TS_RECENT   0x4000 /* tcp_replace_ts_recent() */
102 #define FLAG_NO_CHALLENGE_ACK   0x8000 /* do not call tcp_send_challenge_ack()  */
103 #define FLAG_ACK_MAYBE_DELAYED  0x10000 /* Likely a delayed ACK */
104 #define FLAG_DSACK_TLP          0x20000 /* DSACK for tail loss probe */
105
106 #define FLAG_ACKED              (FLAG_DATA_ACKED|FLAG_SYN_ACKED)
107 #define FLAG_NOT_DUP            (FLAG_DATA|FLAG_WIN_UPDATE|FLAG_ACKED)
108 #define FLAG_CA_ALERT           (FLAG_DATA_SACKED|FLAG_ECE|FLAG_DSACKING_ACK)
109 #define FLAG_FORWARD_PROGRESS   (FLAG_ACKED|FLAG_DATA_SACKED)
110
111 #define TCP_REMNANT (TCP_FLAG_FIN|TCP_FLAG_URG|TCP_FLAG_SYN|TCP_FLAG_PSH)
112 #define TCP_HP_BITS (~(TCP_RESERVED_BITS|TCP_FLAG_PSH))
113
114 #define REXMIT_NONE     0 /* no loss recovery to do */
115 #define REXMIT_LOST     1 /* retransmit packets marked lost */
116 #define REXMIT_NEW      2 /* FRTO-style transmit of unsent/new packets */
117
118 #if IS_ENABLED(CONFIG_TLS_DEVICE)
119 static DEFINE_STATIC_KEY_DEFERRED_FALSE(clean_acked_data_enabled, HZ);
120
121 void clean_acked_data_enable(struct inet_connection_sock *icsk,
122                              void (*cad)(struct sock *sk, u32 ack_seq))
123 {
124         icsk->icsk_clean_acked = cad;
125         static_branch_deferred_inc(&clean_acked_data_enabled);
126 }
127 EXPORT_SYMBOL_GPL(clean_acked_data_enable);
128
129 void clean_acked_data_disable(struct inet_connection_sock *icsk)
130 {
131         static_branch_slow_dec_deferred(&clean_acked_data_enabled);
132         icsk->icsk_clean_acked = NULL;
133 }
134 EXPORT_SYMBOL_GPL(clean_acked_data_disable);
135
136 void clean_acked_data_flush(void)
137 {
138         static_key_deferred_flush(&clean_acked_data_enabled);
139 }
140 EXPORT_SYMBOL_GPL(clean_acked_data_flush);
141 #endif
142
143 #ifdef CONFIG_CGROUP_BPF
144 static void bpf_skops_parse_hdr(struct sock *sk, struct sk_buff *skb)
145 {
146         bool unknown_opt = tcp_sk(sk)->rx_opt.saw_unknown &&
147                 BPF_SOCK_OPS_TEST_FLAG(tcp_sk(sk),
148                                        BPF_SOCK_OPS_PARSE_UNKNOWN_HDR_OPT_CB_FLAG);
149         bool parse_all_opt = BPF_SOCK_OPS_TEST_FLAG(tcp_sk(sk),
150                                                     BPF_SOCK_OPS_PARSE_ALL_HDR_OPT_CB_FLAG);
151         struct bpf_sock_ops_kern sock_ops;
152
153         if (likely(!unknown_opt && !parse_all_opt))
154                 return;
155
156         /* The skb will be handled in the
157          * bpf_skops_established() or
158          * bpf_skops_write_hdr_opt().
159          */
160         switch (sk->sk_state) {
161         case TCP_SYN_RECV:
162         case TCP_SYN_SENT:
163         case TCP_LISTEN:
164                 return;
165         }
166
167         sock_owned_by_me(sk);
168
169         memset(&sock_ops, 0, offsetof(struct bpf_sock_ops_kern, temp));
170         sock_ops.op = BPF_SOCK_OPS_PARSE_HDR_OPT_CB;
171         sock_ops.is_fullsock = 1;
172         sock_ops.sk = sk;
173         bpf_skops_init_skb(&sock_ops, skb, tcp_hdrlen(skb));
174
175         BPF_CGROUP_RUN_PROG_SOCK_OPS(&sock_ops);
176 }
177
178 static void bpf_skops_established(struct sock *sk, int bpf_op,
179                                   struct sk_buff *skb)
180 {
181         struct bpf_sock_ops_kern sock_ops;
182
183         sock_owned_by_me(sk);
184
185         memset(&sock_ops, 0, offsetof(struct bpf_sock_ops_kern, temp));
186         sock_ops.op = bpf_op;
187         sock_ops.is_fullsock = 1;
188         sock_ops.sk = sk;
189         /* sk with TCP_REPAIR_ON does not have skb in tcp_finish_connect */
190         if (skb)
191                 bpf_skops_init_skb(&sock_ops, skb, tcp_hdrlen(skb));
192
193         BPF_CGROUP_RUN_PROG_SOCK_OPS(&sock_ops);
194 }
195 #else
196 static void bpf_skops_parse_hdr(struct sock *sk, struct sk_buff *skb)
197 {
198 }
199
200 static void bpf_skops_established(struct sock *sk, int bpf_op,
201                                   struct sk_buff *skb)
202 {
203 }
204 #endif
205
206 static __cold void tcp_gro_dev_warn(const struct sock *sk, const struct sk_buff *skb,
207                                     unsigned int len)
208 {
209         struct net_device *dev;
210
211         rcu_read_lock();
212         dev = dev_get_by_index_rcu(sock_net(sk), skb->skb_iif);
213         if (!dev || len >= READ_ONCE(dev->mtu))
214                 pr_warn("%s: Driver has suspect GRO implementation, TCP performance may be compromised.\n",
215                         dev ? dev->name : "Unknown driver");
216         rcu_read_unlock();
217 }
218
219 /* Adapt the MSS value used to make delayed ack decision to the
220  * real world.
221  */
222 static void tcp_measure_rcv_mss(struct sock *sk, const struct sk_buff *skb)
223 {
224         struct inet_connection_sock *icsk = inet_csk(sk);
225         const unsigned int lss = icsk->icsk_ack.last_seg_size;
226         unsigned int len;
227
228         icsk->icsk_ack.last_seg_size = 0;
229
230         /* skb->len may jitter because of SACKs, even if peer
231          * sends good full-sized frames.
232          */
233         len = skb_shinfo(skb)->gso_size ? : skb->len;
234         if (len >= icsk->icsk_ack.rcv_mss) {
235                 /* Note: divides are still a bit expensive.
236                  * For the moment, only adjust scaling_ratio
237                  * when we update icsk_ack.rcv_mss.
238                  */
239                 if (unlikely(len != icsk->icsk_ack.rcv_mss)) {
240                         u64 val = (u64)skb->len << TCP_RMEM_TO_WIN_SCALE;
241                         u8 old_ratio = tcp_sk(sk)->scaling_ratio;
242
243                         do_div(val, skb->truesize);
244                         tcp_sk(sk)->scaling_ratio = val ? val : 1;
245
246                         if (old_ratio != tcp_sk(sk)->scaling_ratio)
247                                 WRITE_ONCE(tcp_sk(sk)->window_clamp,
248                                            tcp_win_from_space(sk, sk->sk_rcvbuf));
249                 }
250                 icsk->icsk_ack.rcv_mss = min_t(unsigned int, len,
251                                                tcp_sk(sk)->advmss);
252                 /* Account for possibly-removed options */
253                 DO_ONCE_LITE_IF(len > icsk->icsk_ack.rcv_mss + MAX_TCP_OPTION_SPACE,
254                                 tcp_gro_dev_warn, sk, skb, len);
255                 /* If the skb has a len of exactly 1*MSS and has the PSH bit
256                  * set then it is likely the end of an application write. So
257                  * more data may not be arriving soon, and yet the data sender
258                  * may be waiting for an ACK if cwnd-bound or using TX zero
259                  * copy. So we set ICSK_ACK_PUSHED here so that
260                  * tcp_cleanup_rbuf() will send an ACK immediately if the app
261                  * reads all of the data and is not ping-pong. If len > MSS
262                  * then this logic does not matter (and does not hurt) because
263                  * tcp_cleanup_rbuf() will always ACK immediately if the app
264                  * reads data and there is more than an MSS of unACKed data.
265                  */
266                 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_PSH)
267                         icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
268         } else {
269                 /* Otherwise, we make more careful check taking into account,
270                  * that SACKs block is variable.
271                  *
272                  * "len" is invariant segment length, including TCP header.
273                  */
274                 len += skb->data - skb_transport_header(skb);
275                 if (len >= TCP_MSS_DEFAULT + sizeof(struct tcphdr) ||
276                     /* If PSH is not set, packet should be
277                      * full sized, provided peer TCP is not badly broken.
278                      * This observation (if it is correct 8)) allows
279                      * to handle super-low mtu links fairly.
280                      */
281                     (len >= TCP_MIN_MSS + sizeof(struct tcphdr) &&
282                      !(tcp_flag_word(tcp_hdr(skb)) & TCP_REMNANT))) {
283                         /* Subtract also invariant (if peer is RFC compliant),
284                          * tcp header plus fixed timestamp option length.
285                          * Resulting "len" is MSS free of SACK jitter.
286                          */
287                         len -= tcp_sk(sk)->tcp_header_len;
288                         icsk->icsk_ack.last_seg_size = len;
289                         if (len == lss) {
290                                 icsk->icsk_ack.rcv_mss = len;
291                                 return;
292                         }
293                 }
294                 if (icsk->icsk_ack.pending & ICSK_ACK_PUSHED)
295                         icsk->icsk_ack.pending |= ICSK_ACK_PUSHED2;
296                 icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
297         }
298 }
299
300 static void tcp_incr_quickack(struct sock *sk, unsigned int max_quickacks)
301 {
302         struct inet_connection_sock *icsk = inet_csk(sk);
303         unsigned int quickacks = tcp_sk(sk)->rcv_wnd / (2 * icsk->icsk_ack.rcv_mss);
304
305         if (quickacks == 0)
306                 quickacks = 2;
307         quickacks = min(quickacks, max_quickacks);
308         if (quickacks > icsk->icsk_ack.quick)
309                 icsk->icsk_ack.quick = quickacks;
310 }
311
312 static void tcp_enter_quickack_mode(struct sock *sk, unsigned int max_quickacks)
313 {
314         struct inet_connection_sock *icsk = inet_csk(sk);
315
316         tcp_incr_quickack(sk, max_quickacks);
317         inet_csk_exit_pingpong_mode(sk);
318         icsk->icsk_ack.ato = TCP_ATO_MIN;
319 }
320
321 /* Send ACKs quickly, if "quick" count is not exhausted
322  * and the session is not interactive.
323  */
324
325 static bool tcp_in_quickack_mode(struct sock *sk)
326 {
327         const struct inet_connection_sock *icsk = inet_csk(sk);
328         const struct dst_entry *dst = __sk_dst_get(sk);
329
330         return (dst && dst_metric(dst, RTAX_QUICKACK)) ||
331                 (icsk->icsk_ack.quick && !inet_csk_in_pingpong_mode(sk));
332 }
333
334 static void tcp_ecn_queue_cwr(struct tcp_sock *tp)
335 {
336         if (tp->ecn_flags & TCP_ECN_OK)
337                 tp->ecn_flags |= TCP_ECN_QUEUE_CWR;
338 }
339
340 static void tcp_ecn_accept_cwr(struct sock *sk, const struct sk_buff *skb)
341 {
342         if (tcp_hdr(skb)->cwr) {
343                 tcp_sk(sk)->ecn_flags &= ~TCP_ECN_DEMAND_CWR;
344
345                 /* If the sender is telling us it has entered CWR, then its
346                  * cwnd may be very low (even just 1 packet), so we should ACK
347                  * immediately.
348                  */
349                 if (TCP_SKB_CB(skb)->seq != TCP_SKB_CB(skb)->end_seq)
350                         inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_NOW;
351         }
352 }
353
354 static void tcp_ecn_withdraw_cwr(struct tcp_sock *tp)
355 {
356         tp->ecn_flags &= ~TCP_ECN_QUEUE_CWR;
357 }
358
359 static void __tcp_ecn_check_ce(struct sock *sk, const struct sk_buff *skb)
360 {
361         struct tcp_sock *tp = tcp_sk(sk);
362
363         switch (TCP_SKB_CB(skb)->ip_dsfield & INET_ECN_MASK) {
364         case INET_ECN_NOT_ECT:
365                 /* Funny extension: if ECT is not set on a segment,
366                  * and we already seen ECT on a previous segment,
367                  * it is probably a retransmit.
368                  */
369                 if (tp->ecn_flags & TCP_ECN_SEEN)
370                         tcp_enter_quickack_mode(sk, 2);
371                 break;
372         case INET_ECN_CE:
373                 if (tcp_ca_needs_ecn(sk))
374                         tcp_ca_event(sk, CA_EVENT_ECN_IS_CE);
375
376                 if (!(tp->ecn_flags & TCP_ECN_DEMAND_CWR)) {
377                         /* Better not delay acks, sender can have a very low cwnd */
378                         tcp_enter_quickack_mode(sk, 2);
379                         tp->ecn_flags |= TCP_ECN_DEMAND_CWR;
380                 }
381                 tp->ecn_flags |= TCP_ECN_SEEN;
382                 break;
383         default:
384                 if (tcp_ca_needs_ecn(sk))
385                         tcp_ca_event(sk, CA_EVENT_ECN_NO_CE);
386                 tp->ecn_flags |= TCP_ECN_SEEN;
387                 break;
388         }
389 }
390
391 static void tcp_ecn_check_ce(struct sock *sk, const struct sk_buff *skb)
392 {
393         if (tcp_sk(sk)->ecn_flags & TCP_ECN_OK)
394                 __tcp_ecn_check_ce(sk, skb);
395 }
396
397 static void tcp_ecn_rcv_synack(struct tcp_sock *tp, const struct tcphdr *th)
398 {
399         if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || th->cwr))
400                 tp->ecn_flags &= ~TCP_ECN_OK;
401 }
402
403 static void tcp_ecn_rcv_syn(struct tcp_sock *tp, const struct tcphdr *th)
404 {
405         if ((tp->ecn_flags & TCP_ECN_OK) && (!th->ece || !th->cwr))
406                 tp->ecn_flags &= ~TCP_ECN_OK;
407 }
408
409 static bool tcp_ecn_rcv_ecn_echo(const struct tcp_sock *tp, const struct tcphdr *th)
410 {
411         if (th->ece && !th->syn && (tp->ecn_flags & TCP_ECN_OK))
412                 return true;
413         return false;
414 }
415
416 /* Buffer size and advertised window tuning.
417  *
418  * 1. Tuning sk->sk_sndbuf, when connection enters established state.
419  */
420
421 static void tcp_sndbuf_expand(struct sock *sk)
422 {
423         const struct tcp_sock *tp = tcp_sk(sk);
424         const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
425         int sndmem, per_mss;
426         u32 nr_segs;
427
428         /* Worst case is non GSO/TSO : each frame consumes one skb
429          * and skb->head is kmalloced using power of two area of memory
430          */
431         per_mss = max_t(u32, tp->rx_opt.mss_clamp, tp->mss_cache) +
432                   MAX_TCP_HEADER +
433                   SKB_DATA_ALIGN(sizeof(struct skb_shared_info));
434
435         per_mss = roundup_pow_of_two(per_mss) +
436                   SKB_DATA_ALIGN(sizeof(struct sk_buff));
437
438         nr_segs = max_t(u32, TCP_INIT_CWND, tcp_snd_cwnd(tp));
439         nr_segs = max_t(u32, nr_segs, tp->reordering + 1);
440
441         /* Fast Recovery (RFC 5681 3.2) :
442          * Cubic needs 1.7 factor, rounded to 2 to include
443          * extra cushion (application might react slowly to EPOLLOUT)
444          */
445         sndmem = ca_ops->sndbuf_expand ? ca_ops->sndbuf_expand(sk) : 2;
446         sndmem *= nr_segs * per_mss;
447
448         if (sk->sk_sndbuf < sndmem)
449                 WRITE_ONCE(sk->sk_sndbuf,
450                            min(sndmem, READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_wmem[2])));
451 }
452
453 /* 2. Tuning advertised window (window_clamp, rcv_ssthresh)
454  *
455  * All tcp_full_space() is split to two parts: "network" buffer, allocated
456  * forward and advertised in receiver window (tp->rcv_wnd) and
457  * "application buffer", required to isolate scheduling/application
458  * latencies from network.
459  * window_clamp is maximal advertised window. It can be less than
460  * tcp_full_space(), in this case tcp_full_space() - window_clamp
461  * is reserved for "application" buffer. The less window_clamp is
462  * the smoother our behaviour from viewpoint of network, but the lower
463  * throughput and the higher sensitivity of the connection to losses. 8)
464  *
465  * rcv_ssthresh is more strict window_clamp used at "slow start"
466  * phase to predict further behaviour of this connection.
467  * It is used for two goals:
468  * - to enforce header prediction at sender, even when application
469  *   requires some significant "application buffer". It is check #1.
470  * - to prevent pruning of receive queue because of misprediction
471  *   of receiver window. Check #2.
472  *
473  * The scheme does not work when sender sends good segments opening
474  * window and then starts to feed us spaghetti. But it should work
475  * in common situations. Otherwise, we have to rely on queue collapsing.
476  */
477
478 /* Slow part of check#2. */
479 static int __tcp_grow_window(const struct sock *sk, const struct sk_buff *skb,
480                              unsigned int skbtruesize)
481 {
482         const struct tcp_sock *tp = tcp_sk(sk);
483         /* Optimize this! */
484         int truesize = tcp_win_from_space(sk, skbtruesize) >> 1;
485         int window = tcp_win_from_space(sk, READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[2])) >> 1;
486
487         while (tp->rcv_ssthresh <= window) {
488                 if (truesize <= skb->len)
489                         return 2 * inet_csk(sk)->icsk_ack.rcv_mss;
490
491                 truesize >>= 1;
492                 window >>= 1;
493         }
494         return 0;
495 }
496
497 /* Even if skb appears to have a bad len/truesize ratio, TCP coalescing
498  * can play nice with us, as sk_buff and skb->head might be either
499  * freed or shared with up to MAX_SKB_FRAGS segments.
500  * Only give a boost to drivers using page frag(s) to hold the frame(s),
501  * and if no payload was pulled in skb->head before reaching us.
502  */
503 static u32 truesize_adjust(bool adjust, const struct sk_buff *skb)
504 {
505         u32 truesize = skb->truesize;
506
507         if (adjust && !skb_headlen(skb)) {
508                 truesize -= SKB_TRUESIZE(skb_end_offset(skb));
509                 /* paranoid check, some drivers might be buggy */
510                 if (unlikely((int)truesize < (int)skb->len))
511                         truesize = skb->truesize;
512         }
513         return truesize;
514 }
515
516 static void tcp_grow_window(struct sock *sk, const struct sk_buff *skb,
517                             bool adjust)
518 {
519         struct tcp_sock *tp = tcp_sk(sk);
520         int room;
521
522         room = min_t(int, tp->window_clamp, tcp_space(sk)) - tp->rcv_ssthresh;
523
524         if (room <= 0)
525                 return;
526
527         /* Check #1 */
528         if (!tcp_under_memory_pressure(sk)) {
529                 unsigned int truesize = truesize_adjust(adjust, skb);
530                 int incr;
531
532                 /* Check #2. Increase window, if skb with such overhead
533                  * will fit to rcvbuf in future.
534                  */
535                 if (tcp_win_from_space(sk, truesize) <= skb->len)
536                         incr = 2 * tp->advmss;
537                 else
538                         incr = __tcp_grow_window(sk, skb, truesize);
539
540                 if (incr) {
541                         incr = max_t(int, incr, 2 * skb->len);
542                         tp->rcv_ssthresh += min(room, incr);
543                         inet_csk(sk)->icsk_ack.quick |= 1;
544                 }
545         } else {
546                 /* Under pressure:
547                  * Adjust rcv_ssthresh according to reserved mem
548                  */
549                 tcp_adjust_rcv_ssthresh(sk);
550         }
551 }
552
553 /* 3. Try to fixup all. It is made immediately after connection enters
554  *    established state.
555  */
556 static void tcp_init_buffer_space(struct sock *sk)
557 {
558         int tcp_app_win = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_app_win);
559         struct tcp_sock *tp = tcp_sk(sk);
560         int maxwin;
561
562         if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK))
563                 tcp_sndbuf_expand(sk);
564
565         tcp_mstamp_refresh(tp);
566         tp->rcvq_space.time = tp->tcp_mstamp;
567         tp->rcvq_space.seq = tp->copied_seq;
568
569         maxwin = tcp_full_space(sk);
570
571         if (tp->window_clamp >= maxwin) {
572                 WRITE_ONCE(tp->window_clamp, maxwin);
573
574                 if (tcp_app_win && maxwin > 4 * tp->advmss)
575                         WRITE_ONCE(tp->window_clamp,
576                                    max(maxwin - (maxwin >> tcp_app_win),
577                                        4 * tp->advmss));
578         }
579
580         /* Force reservation of one segment. */
581         if (tcp_app_win &&
582             tp->window_clamp > 2 * tp->advmss &&
583             tp->window_clamp + tp->advmss > maxwin)
584                 WRITE_ONCE(tp->window_clamp,
585                            max(2 * tp->advmss, maxwin - tp->advmss));
586
587         tp->rcv_ssthresh = min(tp->rcv_ssthresh, tp->window_clamp);
588         tp->snd_cwnd_stamp = tcp_jiffies32;
589         tp->rcvq_space.space = min3(tp->rcv_ssthresh, tp->rcv_wnd,
590                                     (u32)TCP_INIT_CWND * tp->advmss);
591 }
592
593 /* 4. Recalculate window clamp after socket hit its memory bounds. */
594 static void tcp_clamp_window(struct sock *sk)
595 {
596         struct tcp_sock *tp = tcp_sk(sk);
597         struct inet_connection_sock *icsk = inet_csk(sk);
598         struct net *net = sock_net(sk);
599         int rmem2;
600
601         icsk->icsk_ack.quick = 0;
602         rmem2 = READ_ONCE(net->ipv4.sysctl_tcp_rmem[2]);
603
604         if (sk->sk_rcvbuf < rmem2 &&
605             !(sk->sk_userlocks & SOCK_RCVBUF_LOCK) &&
606             !tcp_under_memory_pressure(sk) &&
607             sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)) {
608                 WRITE_ONCE(sk->sk_rcvbuf,
609                            min(atomic_read(&sk->sk_rmem_alloc), rmem2));
610         }
611         if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf)
612                 tp->rcv_ssthresh = min(tp->window_clamp, 2U * tp->advmss);
613 }
614
615 /* Initialize RCV_MSS value.
616  * RCV_MSS is an our guess about MSS used by the peer.
617  * We haven't any direct information about the MSS.
618  * It's better to underestimate the RCV_MSS rather than overestimate.
619  * Overestimations make us ACKing less frequently than needed.
620  * Underestimations are more easy to detect and fix by tcp_measure_rcv_mss().
621  */
622 void tcp_initialize_rcv_mss(struct sock *sk)
623 {
624         const struct tcp_sock *tp = tcp_sk(sk);
625         unsigned int hint = min_t(unsigned int, tp->advmss, tp->mss_cache);
626
627         hint = min(hint, tp->rcv_wnd / 2);
628         hint = min(hint, TCP_MSS_DEFAULT);
629         hint = max(hint, TCP_MIN_MSS);
630
631         inet_csk(sk)->icsk_ack.rcv_mss = hint;
632 }
633 EXPORT_SYMBOL(tcp_initialize_rcv_mss);
634
635 /* Receiver "autotuning" code.
636  *
637  * The algorithm for RTT estimation w/o timestamps is based on
638  * Dynamic Right-Sizing (DRS) by Wu Feng and Mike Fisk of LANL.
639  * <https://public.lanl.gov/radiant/pubs.html#DRS>
640  *
641  * More detail on this code can be found at
642  * <http://staff.psc.edu/jheffner/>,
643  * though this reference is out of date.  A new paper
644  * is pending.
645  */
646 static void tcp_rcv_rtt_update(struct tcp_sock *tp, u32 sample, int win_dep)
647 {
648         u32 new_sample = tp->rcv_rtt_est.rtt_us;
649         long m = sample;
650
651         if (new_sample != 0) {
652                 /* If we sample in larger samples in the non-timestamp
653                  * case, we could grossly overestimate the RTT especially
654                  * with chatty applications or bulk transfer apps which
655                  * are stalled on filesystem I/O.
656                  *
657                  * Also, since we are only going for a minimum in the
658                  * non-timestamp case, we do not smooth things out
659                  * else with timestamps disabled convergence takes too
660                  * long.
661                  */
662                 if (!win_dep) {
663                         m -= (new_sample >> 3);
664                         new_sample += m;
665                 } else {
666                         m <<= 3;
667                         if (m < new_sample)
668                                 new_sample = m;
669                 }
670         } else {
671                 /* No previous measure. */
672                 new_sample = m << 3;
673         }
674
675         tp->rcv_rtt_est.rtt_us = new_sample;
676 }
677
678 static inline void tcp_rcv_rtt_measure(struct tcp_sock *tp)
679 {
680         u32 delta_us;
681
682         if (tp->rcv_rtt_est.time == 0)
683                 goto new_measure;
684         if (before(tp->rcv_nxt, tp->rcv_rtt_est.seq))
685                 return;
686         delta_us = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcv_rtt_est.time);
687         if (!delta_us)
688                 delta_us = 1;
689         tcp_rcv_rtt_update(tp, delta_us, 1);
690
691 new_measure:
692         tp->rcv_rtt_est.seq = tp->rcv_nxt + tp->rcv_wnd;
693         tp->rcv_rtt_est.time = tp->tcp_mstamp;
694 }
695
696 static s32 tcp_rtt_tsopt_us(const struct tcp_sock *tp)
697 {
698         u32 delta, delta_us;
699
700         delta = tcp_time_stamp_ts(tp) - tp->rx_opt.rcv_tsecr;
701         if (tp->tcp_usec_ts)
702                 return delta;
703
704         if (likely(delta < INT_MAX / (USEC_PER_SEC / TCP_TS_HZ))) {
705                 if (!delta)
706                         delta = 1;
707                 delta_us = delta * (USEC_PER_SEC / TCP_TS_HZ);
708                 return delta_us;
709         }
710         return -1;
711 }
712
713 static inline void tcp_rcv_rtt_measure_ts(struct sock *sk,
714                                           const struct sk_buff *skb)
715 {
716         struct tcp_sock *tp = tcp_sk(sk);
717
718         if (tp->rx_opt.rcv_tsecr == tp->rcv_rtt_last_tsecr)
719                 return;
720         tp->rcv_rtt_last_tsecr = tp->rx_opt.rcv_tsecr;
721
722         if (TCP_SKB_CB(skb)->end_seq -
723             TCP_SKB_CB(skb)->seq >= inet_csk(sk)->icsk_ack.rcv_mss) {
724                 s32 delta = tcp_rtt_tsopt_us(tp);
725
726                 if (delta >= 0)
727                         tcp_rcv_rtt_update(tp, delta, 0);
728         }
729 }
730
731 /*
732  * This function should be called every time data is copied to user space.
733  * It calculates the appropriate TCP receive buffer space.
734  */
735 void tcp_rcv_space_adjust(struct sock *sk)
736 {
737         struct tcp_sock *tp = tcp_sk(sk);
738         u32 copied;
739         int time;
740
741         trace_tcp_rcv_space_adjust(sk);
742
743         tcp_mstamp_refresh(tp);
744         time = tcp_stamp_us_delta(tp->tcp_mstamp, tp->rcvq_space.time);
745         if (time < (tp->rcv_rtt_est.rtt_us >> 3) || tp->rcv_rtt_est.rtt_us == 0)
746                 return;
747
748         /* Number of bytes copied to user in last RTT */
749         copied = tp->copied_seq - tp->rcvq_space.seq;
750         if (copied <= tp->rcvq_space.space)
751                 goto new_measure;
752
753         /* A bit of theory :
754          * copied = bytes received in previous RTT, our base window
755          * To cope with packet losses, we need a 2x factor
756          * To cope with slow start, and sender growing its cwin by 100 %
757          * every RTT, we need a 4x factor, because the ACK we are sending
758          * now is for the next RTT, not the current one :
759          * <prev RTT . ><current RTT .. ><next RTT .... >
760          */
761
762         if (READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_moderate_rcvbuf) &&
763             !(sk->sk_userlocks & SOCK_RCVBUF_LOCK)) {
764                 u64 rcvwin, grow;
765                 int rcvbuf;
766
767                 /* minimal window to cope with packet losses, assuming
768                  * steady state. Add some cushion because of small variations.
769                  */
770                 rcvwin = ((u64)copied << 1) + 16 * tp->advmss;
771
772                 /* Accommodate for sender rate increase (eg. slow start) */
773                 grow = rcvwin * (copied - tp->rcvq_space.space);
774                 do_div(grow, tp->rcvq_space.space);
775                 rcvwin += (grow << 1);
776
777                 rcvbuf = min_t(u64, tcp_space_from_win(sk, rcvwin),
778                                READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_rmem[2]));
779                 if (rcvbuf > sk->sk_rcvbuf) {
780                         WRITE_ONCE(sk->sk_rcvbuf, rcvbuf);
781
782                         /* Make the window clamp follow along.  */
783                         WRITE_ONCE(tp->window_clamp,
784                                    tcp_win_from_space(sk, rcvbuf));
785                 }
786         }
787         tp->rcvq_space.space = copied;
788
789 new_measure:
790         tp->rcvq_space.seq = tp->copied_seq;
791         tp->rcvq_space.time = tp->tcp_mstamp;
792 }
793
794 static void tcp_save_lrcv_flowlabel(struct sock *sk, const struct sk_buff *skb)
795 {
796 #if IS_ENABLED(CONFIG_IPV6)
797         struct inet_connection_sock *icsk = inet_csk(sk);
798
799         if (skb->protocol == htons(ETH_P_IPV6))
800                 icsk->icsk_ack.lrcv_flowlabel = ntohl(ip6_flowlabel(ipv6_hdr(skb)));
801 #endif
802 }
803
804 /* There is something which you must keep in mind when you analyze the
805  * behavior of the tp->ato delayed ack timeout interval.  When a
806  * connection starts up, we want to ack as quickly as possible.  The
807  * problem is that "good" TCP's do slow start at the beginning of data
808  * transmission.  The means that until we send the first few ACK's the
809  * sender will sit on his end and only queue most of his data, because
810  * he can only send snd_cwnd unacked packets at any given time.  For
811  * each ACK we send, he increments snd_cwnd and transmits more of his
812  * queue.  -DaveM
813  */
814 static void tcp_event_data_recv(struct sock *sk, struct sk_buff *skb)
815 {
816         struct tcp_sock *tp = tcp_sk(sk);
817         struct inet_connection_sock *icsk = inet_csk(sk);
818         u32 now;
819
820         inet_csk_schedule_ack(sk);
821
822         tcp_measure_rcv_mss(sk, skb);
823
824         tcp_rcv_rtt_measure(tp);
825
826         now = tcp_jiffies32;
827
828         if (!icsk->icsk_ack.ato) {
829                 /* The _first_ data packet received, initialize
830                  * delayed ACK engine.
831                  */
832                 tcp_incr_quickack(sk, TCP_MAX_QUICKACKS);
833                 icsk->icsk_ack.ato = TCP_ATO_MIN;
834         } else {
835                 int m = now - icsk->icsk_ack.lrcvtime;
836
837                 if (m <= TCP_ATO_MIN / 2) {
838                         /* The fastest case is the first. */
839                         icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + TCP_ATO_MIN / 2;
840                 } else if (m < icsk->icsk_ack.ato) {
841                         icsk->icsk_ack.ato = (icsk->icsk_ack.ato >> 1) + m;
842                         if (icsk->icsk_ack.ato > icsk->icsk_rto)
843                                 icsk->icsk_ack.ato = icsk->icsk_rto;
844                 } else if (m > icsk->icsk_rto) {
845                         /* Too long gap. Apparently sender failed to
846                          * restart window, so that we send ACKs quickly.
847                          */
848                         tcp_incr_quickack(sk, TCP_MAX_QUICKACKS);
849                 }
850         }
851         icsk->icsk_ack.lrcvtime = now;
852         tcp_save_lrcv_flowlabel(sk, skb);
853
854         tcp_ecn_check_ce(sk, skb);
855
856         if (skb->len >= 128)
857                 tcp_grow_window(sk, skb, true);
858 }
859
860 /* Called to compute a smoothed rtt estimate. The data fed to this
861  * routine either comes from timestamps, or from segments that were
862  * known _not_ to have been retransmitted [see Karn/Partridge
863  * Proceedings SIGCOMM 87]. The algorithm is from the SIGCOMM 88
864  * piece by Van Jacobson.
865  * NOTE: the next three routines used to be one big routine.
866  * To save cycles in the RFC 1323 implementation it was better to break
867  * it up into three procedures. -- erics
868  */
869 static void tcp_rtt_estimator(struct sock *sk, long mrtt_us)
870 {
871         struct tcp_sock *tp = tcp_sk(sk);
872         long m = mrtt_us; /* RTT */
873         u32 srtt = tp->srtt_us;
874
875         /*      The following amusing code comes from Jacobson's
876          *      article in SIGCOMM '88.  Note that rtt and mdev
877          *      are scaled versions of rtt and mean deviation.
878          *      This is designed to be as fast as possible
879          *      m stands for "measurement".
880          *
881          *      On a 1990 paper the rto value is changed to:
882          *      RTO = rtt + 4 * mdev
883          *
884          * Funny. This algorithm seems to be very broken.
885          * These formulae increase RTO, when it should be decreased, increase
886          * too slowly, when it should be increased quickly, decrease too quickly
887          * etc. I guess in BSD RTO takes ONE value, so that it is absolutely
888          * does not matter how to _calculate_ it. Seems, it was trap
889          * that VJ failed to avoid. 8)
890          */
891         if (srtt != 0) {
892                 m -= (srtt >> 3);       /* m is now error in rtt est */
893                 srtt += m;              /* rtt = 7/8 rtt + 1/8 new */
894                 if (m < 0) {
895                         m = -m;         /* m is now abs(error) */
896                         m -= (tp->mdev_us >> 2);   /* similar update on mdev */
897                         /* This is similar to one of Eifel findings.
898                          * Eifel blocks mdev updates when rtt decreases.
899                          * This solution is a bit different: we use finer gain
900                          * for mdev in this case (alpha*beta).
901                          * Like Eifel it also prevents growth of rto,
902                          * but also it limits too fast rto decreases,
903                          * happening in pure Eifel.
904                          */
905                         if (m > 0)
906                                 m >>= 3;
907                 } else {
908                         m -= (tp->mdev_us >> 2);   /* similar update on mdev */
909                 }
910                 tp->mdev_us += m;               /* mdev = 3/4 mdev + 1/4 new */
911                 if (tp->mdev_us > tp->mdev_max_us) {
912                         tp->mdev_max_us = tp->mdev_us;
913                         if (tp->mdev_max_us > tp->rttvar_us)
914                                 tp->rttvar_us = tp->mdev_max_us;
915                 }
916                 if (after(tp->snd_una, tp->rtt_seq)) {
917                         if (tp->mdev_max_us < tp->rttvar_us)
918                                 tp->rttvar_us -= (tp->rttvar_us - tp->mdev_max_us) >> 2;
919                         tp->rtt_seq = tp->snd_nxt;
920                         tp->mdev_max_us = tcp_rto_min_us(sk);
921
922                         tcp_bpf_rtt(sk, mrtt_us, srtt);
923                 }
924         } else {
925                 /* no previous measure. */
926                 srtt = m << 3;          /* take the measured time to be rtt */
927                 tp->mdev_us = m << 1;   /* make sure rto = 3*rtt */
928                 tp->rttvar_us = max(tp->mdev_us, tcp_rto_min_us(sk));
929                 tp->mdev_max_us = tp->rttvar_us;
930                 tp->rtt_seq = tp->snd_nxt;
931
932                 tcp_bpf_rtt(sk, mrtt_us, srtt);
933         }
934         tp->srtt_us = max(1U, srtt);
935 }
936
937 static void tcp_update_pacing_rate(struct sock *sk)
938 {
939         const struct tcp_sock *tp = tcp_sk(sk);
940         u64 rate;
941
942         /* set sk_pacing_rate to 200 % of current rate (mss * cwnd / srtt) */
943         rate = (u64)tp->mss_cache * ((USEC_PER_SEC / 100) << 3);
944
945         /* current rate is (cwnd * mss) / srtt
946          * In Slow Start [1], set sk_pacing_rate to 200 % the current rate.
947          * In Congestion Avoidance phase, set it to 120 % the current rate.
948          *
949          * [1] : Normal Slow Start condition is (tp->snd_cwnd < tp->snd_ssthresh)
950          *       If snd_cwnd >= (tp->snd_ssthresh / 2), we are approaching
951          *       end of slow start and should slow down.
952          */
953         if (tcp_snd_cwnd(tp) < tp->snd_ssthresh / 2)
954                 rate *= READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_pacing_ss_ratio);
955         else
956                 rate *= READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_pacing_ca_ratio);
957
958         rate *= max(tcp_snd_cwnd(tp), tp->packets_out);
959
960         if (likely(tp->srtt_us))
961                 do_div(rate, tp->srtt_us);
962
963         /* WRITE_ONCE() is needed because sch_fq fetches sk_pacing_rate
964          * without any lock. We want to make sure compiler wont store
965          * intermediate values in this location.
966          */
967         WRITE_ONCE(sk->sk_pacing_rate,
968                    min_t(u64, rate, READ_ONCE(sk->sk_max_pacing_rate)));
969 }
970
971 /* Calculate rto without backoff.  This is the second half of Van Jacobson's
972  * routine referred to above.
973  */
974 static void tcp_set_rto(struct sock *sk)
975 {
976         const struct tcp_sock *tp = tcp_sk(sk);
977         /* Old crap is replaced with new one. 8)
978          *
979          * More seriously:
980          * 1. If rtt variance happened to be less 50msec, it is hallucination.
981          *    It cannot be less due to utterly erratic ACK generation made
982          *    at least by solaris and freebsd. "Erratic ACKs" has _nothing_
983          *    to do with delayed acks, because at cwnd>2 true delack timeout
984          *    is invisible. Actually, Linux-2.4 also generates erratic
985          *    ACKs in some circumstances.
986          */
987         inet_csk(sk)->icsk_rto = __tcp_set_rto(tp);
988
989         /* 2. Fixups made earlier cannot be right.
990          *    If we do not estimate RTO correctly without them,
991          *    all the algo is pure shit and should be replaced
992          *    with correct one. It is exactly, which we pretend to do.
993          */
994
995         /* NOTE: clamping at TCP_RTO_MIN is not required, current algo
996          * guarantees that rto is higher.
997          */
998         tcp_bound_rto(sk);
999 }
1000
1001 __u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst)
1002 {
1003         __u32 cwnd = (dst ? dst_metric(dst, RTAX_INITCWND) : 0);
1004
1005         if (!cwnd)
1006                 cwnd = TCP_INIT_CWND;
1007         return min_t(__u32, cwnd, tp->snd_cwnd_clamp);
1008 }
1009
1010 struct tcp_sacktag_state {
1011         /* Timestamps for earliest and latest never-retransmitted segment
1012          * that was SACKed. RTO needs the earliest RTT to stay conservative,
1013          * but congestion control should still get an accurate delay signal.
1014          */
1015         u64     first_sackt;
1016         u64     last_sackt;
1017         u32     reord;
1018         u32     sack_delivered;
1019         int     flag;
1020         unsigned int mss_now;
1021         struct rate_sample *rate;
1022 };
1023
1024 /* Take a notice that peer is sending D-SACKs. Skip update of data delivery
1025  * and spurious retransmission information if this DSACK is unlikely caused by
1026  * sender's action:
1027  * - DSACKed sequence range is larger than maximum receiver's window.
1028  * - Total no. of DSACKed segments exceed the total no. of retransmitted segs.
1029  */
1030 static u32 tcp_dsack_seen(struct tcp_sock *tp, u32 start_seq,
1031                           u32 end_seq, struct tcp_sacktag_state *state)
1032 {
1033         u32 seq_len, dup_segs = 1;
1034
1035         if (!before(start_seq, end_seq))
1036                 return 0;
1037
1038         seq_len = end_seq - start_seq;
1039         /* Dubious DSACK: DSACKed range greater than maximum advertised rwnd */
1040         if (seq_len > tp->max_window)
1041                 return 0;
1042         if (seq_len > tp->mss_cache)
1043                 dup_segs = DIV_ROUND_UP(seq_len, tp->mss_cache);
1044         else if (tp->tlp_high_seq && tp->tlp_high_seq == end_seq)
1045                 state->flag |= FLAG_DSACK_TLP;
1046
1047         tp->dsack_dups += dup_segs;
1048         /* Skip the DSACK if dup segs weren't retransmitted by sender */
1049         if (tp->dsack_dups > tp->total_retrans)
1050                 return 0;
1051
1052         tp->rx_opt.sack_ok |= TCP_DSACK_SEEN;
1053         /* We increase the RACK ordering window in rounds where we receive
1054          * DSACKs that may have been due to reordering causing RACK to trigger
1055          * a spurious fast recovery. Thus RACK ignores DSACKs that happen
1056          * without having seen reordering, or that match TLP probes (TLP
1057          * is timer-driven, not triggered by RACK).
1058          */
1059         if (tp->reord_seen && !(state->flag & FLAG_DSACK_TLP))
1060                 tp->rack.dsack_seen = 1;
1061
1062         state->flag |= FLAG_DSACKING_ACK;
1063         /* A spurious retransmission is delivered */
1064         state->sack_delivered += dup_segs;
1065
1066         return dup_segs;
1067 }
1068
1069 /* It's reordering when higher sequence was delivered (i.e. sacked) before
1070  * some lower never-retransmitted sequence ("low_seq"). The maximum reordering
1071  * distance is approximated in full-mss packet distance ("reordering").
1072  */
1073 static void tcp_check_sack_reordering(struct sock *sk, const u32 low_seq,
1074                                       const int ts)
1075 {
1076         struct tcp_sock *tp = tcp_sk(sk);
1077         const u32 mss = tp->mss_cache;
1078         u32 fack, metric;
1079
1080         fack = tcp_highest_sack_seq(tp);
1081         if (!before(low_seq, fack))
1082                 return;
1083
1084         metric = fack - low_seq;
1085         if ((metric > tp->reordering * mss) && mss) {
1086 #if FASTRETRANS_DEBUG > 1
1087                 pr_debug("Disorder%d %d %u f%u s%u rr%d\n",
1088                          tp->rx_opt.sack_ok, inet_csk(sk)->icsk_ca_state,
1089                          tp->reordering,
1090                          0,
1091                          tp->sacked_out,
1092                          tp->undo_marker ? tp->undo_retrans : 0);
1093 #endif
1094                 tp->reordering = min_t(u32, (metric + mss - 1) / mss,
1095                                        READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_max_reordering));
1096         }
1097
1098         /* This exciting event is worth to be remembered. 8) */
1099         tp->reord_seen++;
1100         NET_INC_STATS(sock_net(sk),
1101                       ts ? LINUX_MIB_TCPTSREORDER : LINUX_MIB_TCPSACKREORDER);
1102 }
1103
1104  /* This must be called before lost_out or retrans_out are updated
1105   * on a new loss, because we want to know if all skbs previously
1106   * known to be lost have already been retransmitted, indicating
1107   * that this newly lost skb is our next skb to retransmit.
1108   */
1109 static void tcp_verify_retransmit_hint(struct tcp_sock *tp, struct sk_buff *skb)
1110 {
1111         if ((!tp->retransmit_skb_hint && tp->retrans_out >= tp->lost_out) ||
1112             (tp->retransmit_skb_hint &&
1113              before(TCP_SKB_CB(skb)->seq,
1114                     TCP_SKB_CB(tp->retransmit_skb_hint)->seq)))
1115                 tp->retransmit_skb_hint = skb;
1116 }
1117
1118 /* Sum the number of packets on the wire we have marked as lost, and
1119  * notify the congestion control module that the given skb was marked lost.
1120  */
1121 static void tcp_notify_skb_loss_event(struct tcp_sock *tp, const struct sk_buff *skb)
1122 {
1123         tp->lost += tcp_skb_pcount(skb);
1124 }
1125
1126 void tcp_mark_skb_lost(struct sock *sk, struct sk_buff *skb)
1127 {
1128         __u8 sacked = TCP_SKB_CB(skb)->sacked;
1129         struct tcp_sock *tp = tcp_sk(sk);
1130
1131         if (sacked & TCPCB_SACKED_ACKED)
1132                 return;
1133
1134         tcp_verify_retransmit_hint(tp, skb);
1135         if (sacked & TCPCB_LOST) {
1136                 if (sacked & TCPCB_SACKED_RETRANS) {
1137                         /* Account for retransmits that are lost again */
1138                         TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_RETRANS;
1139                         tp->retrans_out -= tcp_skb_pcount(skb);
1140                         NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPLOSTRETRANSMIT,
1141                                       tcp_skb_pcount(skb));
1142                         tcp_notify_skb_loss_event(tp, skb);
1143                 }
1144         } else {
1145                 tp->lost_out += tcp_skb_pcount(skb);
1146                 TCP_SKB_CB(skb)->sacked |= TCPCB_LOST;
1147                 tcp_notify_skb_loss_event(tp, skb);
1148         }
1149 }
1150
1151 /* Updates the delivered and delivered_ce counts */
1152 static void tcp_count_delivered(struct tcp_sock *tp, u32 delivered,
1153                                 bool ece_ack)
1154 {
1155         tp->delivered += delivered;
1156         if (ece_ack)
1157                 tp->delivered_ce += delivered;
1158 }
1159
1160 /* This procedure tags the retransmission queue when SACKs arrive.
1161  *
1162  * We have three tag bits: SACKED(S), RETRANS(R) and LOST(L).
1163  * Packets in queue with these bits set are counted in variables
1164  * sacked_out, retrans_out and lost_out, correspondingly.
1165  *
1166  * Valid combinations are:
1167  * Tag  InFlight        Description
1168  * 0    1               - orig segment is in flight.
1169  * S    0               - nothing flies, orig reached receiver.
1170  * L    0               - nothing flies, orig lost by net.
1171  * R    2               - both orig and retransmit are in flight.
1172  * L|R  1               - orig is lost, retransmit is in flight.
1173  * S|R  1               - orig reached receiver, retrans is still in flight.
1174  * (L|S|R is logically valid, it could occur when L|R is sacked,
1175  *  but it is equivalent to plain S and code short-circuits it to S.
1176  *  L|S is logically invalid, it would mean -1 packet in flight 8))
1177  *
1178  * These 6 states form finite state machine, controlled by the following events:
1179  * 1. New ACK (+SACK) arrives. (tcp_sacktag_write_queue())
1180  * 2. Retransmission. (tcp_retransmit_skb(), tcp_xmit_retransmit_queue())
1181  * 3. Loss detection event of two flavors:
1182  *      A. Scoreboard estimator decided the packet is lost.
1183  *         A'. Reno "three dupacks" marks head of queue lost.
1184  *      B. SACK arrives sacking SND.NXT at the moment, when the
1185  *         segment was retransmitted.
1186  * 4. D-SACK added new rule: D-SACK changes any tag to S.
1187  *
1188  * It is pleasant to note, that state diagram turns out to be commutative,
1189  * so that we are allowed not to be bothered by order of our actions,
1190  * when multiple events arrive simultaneously. (see the function below).
1191  *
1192  * Reordering detection.
1193  * --------------------
1194  * Reordering metric is maximal distance, which a packet can be displaced
1195  * in packet stream. With SACKs we can estimate it:
1196  *
1197  * 1. SACK fills old hole and the corresponding segment was not
1198  *    ever retransmitted -> reordering. Alas, we cannot use it
1199  *    when segment was retransmitted.
1200  * 2. The last flaw is solved with D-SACK. D-SACK arrives
1201  *    for retransmitted and already SACKed segment -> reordering..
1202  * Both of these heuristics are not used in Loss state, when we cannot
1203  * account for retransmits accurately.
1204  *
1205  * SACK block validation.
1206  * ----------------------
1207  *
1208  * SACK block range validation checks that the received SACK block fits to
1209  * the expected sequence limits, i.e., it is between SND.UNA and SND.NXT.
1210  * Note that SND.UNA is not included to the range though being valid because
1211  * it means that the receiver is rather inconsistent with itself reporting
1212  * SACK reneging when it should advance SND.UNA. Such SACK block this is
1213  * perfectly valid, however, in light of RFC2018 which explicitly states
1214  * that "SACK block MUST reflect the newest segment.  Even if the newest
1215  * segment is going to be discarded ...", not that it looks very clever
1216  * in case of head skb. Due to potentional receiver driven attacks, we
1217  * choose to avoid immediate execution of a walk in write queue due to
1218  * reneging and defer head skb's loss recovery to standard loss recovery
1219  * procedure that will eventually trigger (nothing forbids us doing this).
1220  *
1221  * Implements also blockage to start_seq wrap-around. Problem lies in the
1222  * fact that though start_seq (s) is before end_seq (i.e., not reversed),
1223  * there's no guarantee that it will be before snd_nxt (n). The problem
1224  * happens when start_seq resides between end_seq wrap (e_w) and snd_nxt
1225  * wrap (s_w):
1226  *
1227  *         <- outs wnd ->                          <- wrapzone ->
1228  *         u     e      n                         u_w   e_w  s n_w
1229  *         |     |      |                          |     |   |  |
1230  * |<------------+------+----- TCP seqno space --------------+---------->|
1231  * ...-- <2^31 ->|                                           |<--------...
1232  * ...---- >2^31 ------>|                                    |<--------...
1233  *
1234  * Current code wouldn't be vulnerable but it's better still to discard such
1235  * crazy SACK blocks. Doing this check for start_seq alone closes somewhat
1236  * similar case (end_seq after snd_nxt wrap) as earlier reversed check in
1237  * snd_nxt wrap -> snd_una region will then become "well defined", i.e.,
1238  * equal to the ideal case (infinite seqno space without wrap caused issues).
1239  *
1240  * With D-SACK the lower bound is extended to cover sequence space below
1241  * SND.UNA down to undo_marker, which is the last point of interest. Yet
1242  * again, D-SACK block must not to go across snd_una (for the same reason as
1243  * for the normal SACK blocks, explained above). But there all simplicity
1244  * ends, TCP might receive valid D-SACKs below that. As long as they reside
1245  * fully below undo_marker they do not affect behavior in anyway and can
1246  * therefore be safely ignored. In rare cases (which are more or less
1247  * theoretical ones), the D-SACK will nicely cross that boundary due to skb
1248  * fragmentation and packet reordering past skb's retransmission. To consider
1249  * them correctly, the acceptable range must be extended even more though
1250  * the exact amount is rather hard to quantify. However, tp->max_window can
1251  * be used as an exaggerated estimate.
1252  */
1253 static bool tcp_is_sackblock_valid(struct tcp_sock *tp, bool is_dsack,
1254                                    u32 start_seq, u32 end_seq)
1255 {
1256         /* Too far in future, or reversed (interpretation is ambiguous) */
1257         if (after(end_seq, tp->snd_nxt) || !before(start_seq, end_seq))
1258                 return false;
1259
1260         /* Nasty start_seq wrap-around check (see comments above) */
1261         if (!before(start_seq, tp->snd_nxt))
1262                 return false;
1263
1264         /* In outstanding window? ...This is valid exit for D-SACKs too.
1265          * start_seq == snd_una is non-sensical (see comments above)
1266          */
1267         if (after(start_seq, tp->snd_una))
1268                 return true;
1269
1270         if (!is_dsack || !tp->undo_marker)
1271                 return false;
1272
1273         /* ...Then it's D-SACK, and must reside below snd_una completely */
1274         if (after(end_seq, tp->snd_una))
1275                 return false;
1276
1277         if (!before(start_seq, tp->undo_marker))
1278                 return true;
1279
1280         /* Too old */
1281         if (!after(end_seq, tp->undo_marker))
1282                 return false;
1283
1284         /* Undo_marker boundary crossing (overestimates a lot). Known already:
1285          *   start_seq < undo_marker and end_seq >= undo_marker.
1286          */
1287         return !before(start_seq, end_seq - tp->max_window);
1288 }
1289
1290 static bool tcp_check_dsack(struct sock *sk, const struct sk_buff *ack_skb,
1291                             struct tcp_sack_block_wire *sp, int num_sacks,
1292                             u32 prior_snd_una, struct tcp_sacktag_state *state)
1293 {
1294         struct tcp_sock *tp = tcp_sk(sk);
1295         u32 start_seq_0 = get_unaligned_be32(&sp[0].start_seq);
1296         u32 end_seq_0 = get_unaligned_be32(&sp[0].end_seq);
1297         u32 dup_segs;
1298
1299         if (before(start_seq_0, TCP_SKB_CB(ack_skb)->ack_seq)) {
1300                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECV);
1301         } else if (num_sacks > 1) {
1302                 u32 end_seq_1 = get_unaligned_be32(&sp[1].end_seq);
1303                 u32 start_seq_1 = get_unaligned_be32(&sp[1].start_seq);
1304
1305                 if (after(end_seq_0, end_seq_1) || before(start_seq_0, start_seq_1))
1306                         return false;
1307                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKOFORECV);
1308         } else {
1309                 return false;
1310         }
1311
1312         dup_segs = tcp_dsack_seen(tp, start_seq_0, end_seq_0, state);
1313         if (!dup_segs) {        /* Skip dubious DSACK */
1314                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKIGNOREDDUBIOUS);
1315                 return false;
1316         }
1317
1318         NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPDSACKRECVSEGS, dup_segs);
1319
1320         /* D-SACK for already forgotten data... Do dumb counting. */
1321         if (tp->undo_marker && tp->undo_retrans > 0 &&
1322             !after(end_seq_0, prior_snd_una) &&
1323             after(end_seq_0, tp->undo_marker))
1324                 tp->undo_retrans = max_t(int, 0, tp->undo_retrans - dup_segs);
1325
1326         return true;
1327 }
1328
1329 /* Check if skb is fully within the SACK block. In presence of GSO skbs,
1330  * the incoming SACK may not exactly match but we can find smaller MSS
1331  * aligned portion of it that matches. Therefore we might need to fragment
1332  * which may fail and creates some hassle (caller must handle error case
1333  * returns).
1334  *
1335  * FIXME: this could be merged to shift decision code
1336  */
1337 static int tcp_match_skb_to_sack(struct sock *sk, struct sk_buff *skb,
1338                                   u32 start_seq, u32 end_seq)
1339 {
1340         int err;
1341         bool in_sack;
1342         unsigned int pkt_len;
1343         unsigned int mss;
1344
1345         in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq) &&
1346                   !before(end_seq, TCP_SKB_CB(skb)->end_seq);
1347
1348         if (tcp_skb_pcount(skb) > 1 && !in_sack &&
1349             after(TCP_SKB_CB(skb)->end_seq, start_seq)) {
1350                 mss = tcp_skb_mss(skb);
1351                 in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);
1352
1353                 if (!in_sack) {
1354                         pkt_len = start_seq - TCP_SKB_CB(skb)->seq;
1355                         if (pkt_len < mss)
1356                                 pkt_len = mss;
1357                 } else {
1358                         pkt_len = end_seq - TCP_SKB_CB(skb)->seq;
1359                         if (pkt_len < mss)
1360                                 return -EINVAL;
1361                 }
1362
1363                 /* Round if necessary so that SACKs cover only full MSSes
1364                  * and/or the remaining small portion (if present)
1365                  */
1366                 if (pkt_len > mss) {
1367                         unsigned int new_len = (pkt_len / mss) * mss;
1368                         if (!in_sack && new_len < pkt_len)
1369                                 new_len += mss;
1370                         pkt_len = new_len;
1371                 }
1372
1373                 if (pkt_len >= skb->len && !in_sack)
1374                         return 0;
1375
1376                 err = tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
1377                                    pkt_len, mss, GFP_ATOMIC);
1378                 if (err < 0)
1379                         return err;
1380         }
1381
1382         return in_sack;
1383 }
1384
1385 /* Mark the given newly-SACKed range as such, adjusting counters and hints. */
1386 static u8 tcp_sacktag_one(struct sock *sk,
1387                           struct tcp_sacktag_state *state, u8 sacked,
1388                           u32 start_seq, u32 end_seq,
1389                           int dup_sack, int pcount,
1390                           u64 xmit_time)
1391 {
1392         struct tcp_sock *tp = tcp_sk(sk);
1393
1394         /* Account D-SACK for retransmitted packet. */
1395         if (dup_sack && (sacked & TCPCB_RETRANS)) {
1396                 if (tp->undo_marker && tp->undo_retrans > 0 &&
1397                     after(end_seq, tp->undo_marker))
1398                         tp->undo_retrans = max_t(int, 0, tp->undo_retrans - pcount);
1399                 if ((sacked & TCPCB_SACKED_ACKED) &&
1400                     before(start_seq, state->reord))
1401                                 state->reord = start_seq;
1402         }
1403
1404         /* Nothing to do; acked frame is about to be dropped (was ACKed). */
1405         if (!after(end_seq, tp->snd_una))
1406                 return sacked;
1407
1408         if (!(sacked & TCPCB_SACKED_ACKED)) {
1409                 tcp_rack_advance(tp, sacked, end_seq, xmit_time);
1410
1411                 if (sacked & TCPCB_SACKED_RETRANS) {
1412                         /* If the segment is not tagged as lost,
1413                          * we do not clear RETRANS, believing
1414                          * that retransmission is still in flight.
1415                          */
1416                         if (sacked & TCPCB_LOST) {
1417                                 sacked &= ~(TCPCB_LOST|TCPCB_SACKED_RETRANS);
1418                                 tp->lost_out -= pcount;
1419                                 tp->retrans_out -= pcount;
1420                         }
1421                 } else {
1422                         if (!(sacked & TCPCB_RETRANS)) {
1423                                 /* New sack for not retransmitted frame,
1424                                  * which was in hole. It is reordering.
1425                                  */
1426                                 if (before(start_seq,
1427                                            tcp_highest_sack_seq(tp)) &&
1428                                     before(start_seq, state->reord))
1429                                         state->reord = start_seq;
1430
1431                                 if (!after(end_seq, tp->high_seq))
1432                                         state->flag |= FLAG_ORIG_SACK_ACKED;
1433                                 if (state->first_sackt == 0)
1434                                         state->first_sackt = xmit_time;
1435                                 state->last_sackt = xmit_time;
1436                         }
1437
1438                         if (sacked & TCPCB_LOST) {
1439                                 sacked &= ~TCPCB_LOST;
1440                                 tp->lost_out -= pcount;
1441                         }
1442                 }
1443
1444                 sacked |= TCPCB_SACKED_ACKED;
1445                 state->flag |= FLAG_DATA_SACKED;
1446                 tp->sacked_out += pcount;
1447                 /* Out-of-order packets delivered */
1448                 state->sack_delivered += pcount;
1449
1450                 /* Lost marker hint past SACKed? Tweak RFC3517 cnt */
1451                 if (tp->lost_skb_hint &&
1452                     before(start_seq, TCP_SKB_CB(tp->lost_skb_hint)->seq))
1453                         tp->lost_cnt_hint += pcount;
1454         }
1455
1456         /* D-SACK. We can detect redundant retransmission in S|R and plain R
1457          * frames and clear it. undo_retrans is decreased above, L|R frames
1458          * are accounted above as well.
1459          */
1460         if (dup_sack && (sacked & TCPCB_SACKED_RETRANS)) {
1461                 sacked &= ~TCPCB_SACKED_RETRANS;
1462                 tp->retrans_out -= pcount;
1463         }
1464
1465         return sacked;
1466 }
1467
1468 /* Shift newly-SACKed bytes from this skb to the immediately previous
1469  * already-SACKed sk_buff. Mark the newly-SACKed bytes as such.
1470  */
1471 static bool tcp_shifted_skb(struct sock *sk, struct sk_buff *prev,
1472                             struct sk_buff *skb,
1473                             struct tcp_sacktag_state *state,
1474                             unsigned int pcount, int shifted, int mss,
1475                             bool dup_sack)
1476 {
1477         struct tcp_sock *tp = tcp_sk(sk);
1478         u32 start_seq = TCP_SKB_CB(skb)->seq;   /* start of newly-SACKed */
1479         u32 end_seq = start_seq + shifted;      /* end of newly-SACKed */
1480
1481         BUG_ON(!pcount);
1482
1483         /* Adjust counters and hints for the newly sacked sequence
1484          * range but discard the return value since prev is already
1485          * marked. We must tag the range first because the seq
1486          * advancement below implicitly advances
1487          * tcp_highest_sack_seq() when skb is highest_sack.
1488          */
1489         tcp_sacktag_one(sk, state, TCP_SKB_CB(skb)->sacked,
1490                         start_seq, end_seq, dup_sack, pcount,
1491                         tcp_skb_timestamp_us(skb));
1492         tcp_rate_skb_delivered(sk, skb, state->rate);
1493
1494         if (skb == tp->lost_skb_hint)
1495                 tp->lost_cnt_hint += pcount;
1496
1497         TCP_SKB_CB(prev)->end_seq += shifted;
1498         TCP_SKB_CB(skb)->seq += shifted;
1499
1500         tcp_skb_pcount_add(prev, pcount);
1501         WARN_ON_ONCE(tcp_skb_pcount(skb) < pcount);
1502         tcp_skb_pcount_add(skb, -pcount);
1503
1504         /* When we're adding to gso_segs == 1, gso_size will be zero,
1505          * in theory this shouldn't be necessary but as long as DSACK
1506          * code can come after this skb later on it's better to keep
1507          * setting gso_size to something.
1508          */
1509         if (!TCP_SKB_CB(prev)->tcp_gso_size)
1510                 TCP_SKB_CB(prev)->tcp_gso_size = mss;
1511
1512         /* CHECKME: To clear or not to clear? Mimics normal skb currently */
1513         if (tcp_skb_pcount(skb) <= 1)
1514                 TCP_SKB_CB(skb)->tcp_gso_size = 0;
1515
1516         /* Difference in this won't matter, both ACKed by the same cumul. ACK */
1517         TCP_SKB_CB(prev)->sacked |= (TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS);
1518
1519         if (skb->len > 0) {
1520                 BUG_ON(!tcp_skb_pcount(skb));
1521                 NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTED);
1522                 return false;
1523         }
1524
1525         /* Whole SKB was eaten :-) */
1526
1527         if (skb == tp->retransmit_skb_hint)
1528                 tp->retransmit_skb_hint = prev;
1529         if (skb == tp->lost_skb_hint) {
1530                 tp->lost_skb_hint = prev;
1531                 tp->lost_cnt_hint -= tcp_skb_pcount(prev);
1532         }
1533
1534         TCP_SKB_CB(prev)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
1535         TCP_SKB_CB(prev)->eor = TCP_SKB_CB(skb)->eor;
1536         if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
1537                 TCP_SKB_CB(prev)->end_seq++;
1538
1539         if (skb == tcp_highest_sack(sk))
1540                 tcp_advance_highest_sack(sk, skb);
1541
1542         tcp_skb_collapse_tstamp(prev, skb);
1543         if (unlikely(TCP_SKB_CB(prev)->tx.delivered_mstamp))
1544                 TCP_SKB_CB(prev)->tx.delivered_mstamp = 0;
1545
1546         tcp_rtx_queue_unlink_and_free(skb, sk);
1547
1548         NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKMERGED);
1549
1550         return true;
1551 }
1552
1553 /* I wish gso_size would have a bit more sane initialization than
1554  * something-or-zero which complicates things
1555  */
1556 static int tcp_skb_seglen(const struct sk_buff *skb)
1557 {
1558         return tcp_skb_pcount(skb) == 1 ? skb->len : tcp_skb_mss(skb);
1559 }
1560
1561 /* Shifting pages past head area doesn't work */
1562 static int skb_can_shift(const struct sk_buff *skb)
1563 {
1564         return !skb_headlen(skb) && skb_is_nonlinear(skb);
1565 }
1566
1567 int tcp_skb_shift(struct sk_buff *to, struct sk_buff *from,
1568                   int pcount, int shiftlen)
1569 {
1570         /* TCP min gso_size is 8 bytes (TCP_MIN_GSO_SIZE)
1571          * Since TCP_SKB_CB(skb)->tcp_gso_segs is 16 bits, we need
1572          * to make sure not storing more than 65535 * 8 bytes per skb,
1573          * even if current MSS is bigger.
1574          */
1575         if (unlikely(to->len + shiftlen >= 65535 * TCP_MIN_GSO_SIZE))
1576                 return 0;
1577         if (unlikely(tcp_skb_pcount(to) + pcount > 65535))
1578                 return 0;
1579         return skb_shift(to, from, shiftlen);
1580 }
1581
1582 /* Try collapsing SACK blocks spanning across multiple skbs to a single
1583  * skb.
1584  */
1585 static struct sk_buff *tcp_shift_skb_data(struct sock *sk, struct sk_buff *skb,
1586                                           struct tcp_sacktag_state *state,
1587                                           u32 start_seq, u32 end_seq,
1588                                           bool dup_sack)
1589 {
1590         struct tcp_sock *tp = tcp_sk(sk);
1591         struct sk_buff *prev;
1592         int mss;
1593         int pcount = 0;
1594         int len;
1595         int in_sack;
1596
1597         /* Normally R but no L won't result in plain S */
1598         if (!dup_sack &&
1599             (TCP_SKB_CB(skb)->sacked & (TCPCB_LOST|TCPCB_SACKED_RETRANS)) == TCPCB_SACKED_RETRANS)
1600                 goto fallback;
1601         if (!skb_can_shift(skb))
1602                 goto fallback;
1603         /* This frame is about to be dropped (was ACKed). */
1604         if (!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una))
1605                 goto fallback;
1606
1607         /* Can only happen with delayed DSACK + discard craziness */
1608         prev = skb_rb_prev(skb);
1609         if (!prev)
1610                 goto fallback;
1611
1612         if ((TCP_SKB_CB(prev)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED)
1613                 goto fallback;
1614
1615         if (!tcp_skb_can_collapse(prev, skb))
1616                 goto fallback;
1617
1618         in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq) &&
1619                   !before(end_seq, TCP_SKB_CB(skb)->end_seq);
1620
1621         if (in_sack) {
1622                 len = skb->len;
1623                 pcount = tcp_skb_pcount(skb);
1624                 mss = tcp_skb_seglen(skb);
1625
1626                 /* TODO: Fix DSACKs to not fragment already SACKed and we can
1627                  * drop this restriction as unnecessary
1628                  */
1629                 if (mss != tcp_skb_seglen(prev))
1630                         goto fallback;
1631         } else {
1632                 if (!after(TCP_SKB_CB(skb)->end_seq, start_seq))
1633                         goto noop;
1634                 /* CHECKME: This is non-MSS split case only?, this will
1635                  * cause skipped skbs due to advancing loop btw, original
1636                  * has that feature too
1637                  */
1638                 if (tcp_skb_pcount(skb) <= 1)
1639                         goto noop;
1640
1641                 in_sack = !after(start_seq, TCP_SKB_CB(skb)->seq);
1642                 if (!in_sack) {
1643                         /* TODO: head merge to next could be attempted here
1644                          * if (!after(TCP_SKB_CB(skb)->end_seq, end_seq)),
1645                          * though it might not be worth of the additional hassle
1646                          *
1647                          * ...we can probably just fallback to what was done
1648                          * previously. We could try merging non-SACKed ones
1649                          * as well but it probably isn't going to buy off
1650                          * because later SACKs might again split them, and
1651                          * it would make skb timestamp tracking considerably
1652                          * harder problem.
1653                          */
1654                         goto fallback;
1655                 }
1656
1657                 len = end_seq - TCP_SKB_CB(skb)->seq;
1658                 BUG_ON(len < 0);
1659                 BUG_ON(len > skb->len);
1660
1661                 /* MSS boundaries should be honoured or else pcount will
1662                  * severely break even though it makes things bit trickier.
1663                  * Optimize common case to avoid most of the divides
1664                  */
1665                 mss = tcp_skb_mss(skb);
1666
1667                 /* TODO: Fix DSACKs to not fragment already SACKed and we can
1668                  * drop this restriction as unnecessary
1669                  */
1670                 if (mss != tcp_skb_seglen(prev))
1671                         goto fallback;
1672
1673                 if (len == mss) {
1674                         pcount = 1;
1675                 } else if (len < mss) {
1676                         goto noop;
1677                 } else {
1678                         pcount = len / mss;
1679                         len = pcount * mss;
1680                 }
1681         }
1682
1683         /* tcp_sacktag_one() won't SACK-tag ranges below snd_una */
1684         if (!after(TCP_SKB_CB(skb)->seq + len, tp->snd_una))
1685                 goto fallback;
1686
1687         if (!tcp_skb_shift(prev, skb, pcount, len))
1688                 goto fallback;
1689         if (!tcp_shifted_skb(sk, prev, skb, state, pcount, len, mss, dup_sack))
1690                 goto out;
1691
1692         /* Hole filled allows collapsing with the next as well, this is very
1693          * useful when hole on every nth skb pattern happens
1694          */
1695         skb = skb_rb_next(prev);
1696         if (!skb)
1697                 goto out;
1698
1699         if (!skb_can_shift(skb) ||
1700             ((TCP_SKB_CB(skb)->sacked & TCPCB_TAGBITS) != TCPCB_SACKED_ACKED) ||
1701             (mss != tcp_skb_seglen(skb)))
1702                 goto out;
1703
1704         if (!tcp_skb_can_collapse(prev, skb))
1705                 goto out;
1706         len = skb->len;
1707         pcount = tcp_skb_pcount(skb);
1708         if (tcp_skb_shift(prev, skb, pcount, len))
1709                 tcp_shifted_skb(sk, prev, skb, state, pcount,
1710                                 len, mss, 0);
1711
1712 out:
1713         return prev;
1714
1715 noop:
1716         return skb;
1717
1718 fallback:
1719         NET_INC_STATS(sock_net(sk), LINUX_MIB_SACKSHIFTFALLBACK);
1720         return NULL;
1721 }
1722
1723 static struct sk_buff *tcp_sacktag_walk(struct sk_buff *skb, struct sock *sk,
1724                                         struct tcp_sack_block *next_dup,
1725                                         struct tcp_sacktag_state *state,
1726                                         u32 start_seq, u32 end_seq,
1727                                         bool dup_sack_in)
1728 {
1729         struct tcp_sock *tp = tcp_sk(sk);
1730         struct sk_buff *tmp;
1731
1732         skb_rbtree_walk_from(skb) {
1733                 int in_sack = 0;
1734                 bool dup_sack = dup_sack_in;
1735
1736                 /* queue is in-order => we can short-circuit the walk early */
1737                 if (!before(TCP_SKB_CB(skb)->seq, end_seq))
1738                         break;
1739
1740                 if (next_dup  &&
1741                     before(TCP_SKB_CB(skb)->seq, next_dup->end_seq)) {
1742                         in_sack = tcp_match_skb_to_sack(sk, skb,
1743                                                         next_dup->start_seq,
1744                                                         next_dup->end_seq);
1745                         if (in_sack > 0)
1746                                 dup_sack = true;
1747                 }
1748
1749                 /* skb reference here is a bit tricky to get right, since
1750                  * shifting can eat and free both this skb and the next,
1751                  * so not even _safe variant of the loop is enough.
1752                  */
1753                 if (in_sack <= 0) {
1754                         tmp = tcp_shift_skb_data(sk, skb, state,
1755                                                  start_seq, end_seq, dup_sack);
1756                         if (tmp) {
1757                                 if (tmp != skb) {
1758                                         skb = tmp;
1759                                         continue;
1760                                 }
1761
1762                                 in_sack = 0;
1763                         } else {
1764                                 in_sack = tcp_match_skb_to_sack(sk, skb,
1765                                                                 start_seq,
1766                                                                 end_seq);
1767                         }
1768                 }
1769
1770                 if (unlikely(in_sack < 0))
1771                         break;
1772
1773                 if (in_sack) {
1774                         TCP_SKB_CB(skb)->sacked =
1775                                 tcp_sacktag_one(sk,
1776                                                 state,
1777                                                 TCP_SKB_CB(skb)->sacked,
1778                                                 TCP_SKB_CB(skb)->seq,
1779                                                 TCP_SKB_CB(skb)->end_seq,
1780                                                 dup_sack,
1781                                                 tcp_skb_pcount(skb),
1782                                                 tcp_skb_timestamp_us(skb));
1783                         tcp_rate_skb_delivered(sk, skb, state->rate);
1784                         if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
1785                                 list_del_init(&skb->tcp_tsorted_anchor);
1786
1787                         if (!before(TCP_SKB_CB(skb)->seq,
1788                                     tcp_highest_sack_seq(tp)))
1789                                 tcp_advance_highest_sack(sk, skb);
1790                 }
1791         }
1792         return skb;
1793 }
1794
1795 static struct sk_buff *tcp_sacktag_bsearch(struct sock *sk, u32 seq)
1796 {
1797         struct rb_node *parent, **p = &sk->tcp_rtx_queue.rb_node;
1798         struct sk_buff *skb;
1799
1800         while (*p) {
1801                 parent = *p;
1802                 skb = rb_to_skb(parent);
1803                 if (before(seq, TCP_SKB_CB(skb)->seq)) {
1804                         p = &parent->rb_left;
1805                         continue;
1806                 }
1807                 if (!before(seq, TCP_SKB_CB(skb)->end_seq)) {
1808                         p = &parent->rb_right;
1809                         continue;
1810                 }
1811                 return skb;
1812         }
1813         return NULL;
1814 }
1815
1816 static struct sk_buff *tcp_sacktag_skip(struct sk_buff *skb, struct sock *sk,
1817                                         u32 skip_to_seq)
1818 {
1819         if (skb && after(TCP_SKB_CB(skb)->seq, skip_to_seq))
1820                 return skb;
1821
1822         return tcp_sacktag_bsearch(sk, skip_to_seq);
1823 }
1824
1825 static struct sk_buff *tcp_maybe_skipping_dsack(struct sk_buff *skb,
1826                                                 struct sock *sk,
1827                                                 struct tcp_sack_block *next_dup,
1828                                                 struct tcp_sacktag_state *state,
1829                                                 u32 skip_to_seq)
1830 {
1831         if (!next_dup)
1832                 return skb;
1833
1834         if (before(next_dup->start_seq, skip_to_seq)) {
1835                 skb = tcp_sacktag_skip(skb, sk, next_dup->start_seq);
1836                 skb = tcp_sacktag_walk(skb, sk, NULL, state,
1837                                        next_dup->start_seq, next_dup->end_seq,
1838                                        1);
1839         }
1840
1841         return skb;
1842 }
1843
1844 static int tcp_sack_cache_ok(const struct tcp_sock *tp, const struct tcp_sack_block *cache)
1845 {
1846         return cache < tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
1847 }
1848
1849 static int
1850 tcp_sacktag_write_queue(struct sock *sk, const struct sk_buff *ack_skb,
1851                         u32 prior_snd_una, struct tcp_sacktag_state *state)
1852 {
1853         struct tcp_sock *tp = tcp_sk(sk);
1854         const unsigned char *ptr = (skb_transport_header(ack_skb) +
1855                                     TCP_SKB_CB(ack_skb)->sacked);
1856         struct tcp_sack_block_wire *sp_wire = (struct tcp_sack_block_wire *)(ptr+2);
1857         struct tcp_sack_block sp[TCP_NUM_SACKS];
1858         struct tcp_sack_block *cache;
1859         struct sk_buff *skb;
1860         int num_sacks = min(TCP_NUM_SACKS, (ptr[1] - TCPOLEN_SACK_BASE) >> 3);
1861         int used_sacks;
1862         bool found_dup_sack = false;
1863         int i, j;
1864         int first_sack_index;
1865
1866         state->flag = 0;
1867         state->reord = tp->snd_nxt;
1868
1869         if (!tp->sacked_out)
1870                 tcp_highest_sack_reset(sk);
1871
1872         found_dup_sack = tcp_check_dsack(sk, ack_skb, sp_wire,
1873                                          num_sacks, prior_snd_una, state);
1874
1875         /* Eliminate too old ACKs, but take into
1876          * account more or less fresh ones, they can
1877          * contain valid SACK info.
1878          */
1879         if (before(TCP_SKB_CB(ack_skb)->ack_seq, prior_snd_una - tp->max_window))
1880                 return 0;
1881
1882         if (!tp->packets_out)
1883                 goto out;
1884
1885         used_sacks = 0;
1886         first_sack_index = 0;
1887         for (i = 0; i < num_sacks; i++) {
1888                 bool dup_sack = !i && found_dup_sack;
1889
1890                 sp[used_sacks].start_seq = get_unaligned_be32(&sp_wire[i].start_seq);
1891                 sp[used_sacks].end_seq = get_unaligned_be32(&sp_wire[i].end_seq);
1892
1893                 if (!tcp_is_sackblock_valid(tp, dup_sack,
1894                                             sp[used_sacks].start_seq,
1895                                             sp[used_sacks].end_seq)) {
1896                         int mib_idx;
1897
1898                         if (dup_sack) {
1899                                 if (!tp->undo_marker)
1900                                         mib_idx = LINUX_MIB_TCPDSACKIGNOREDNOUNDO;
1901                                 else
1902                                         mib_idx = LINUX_MIB_TCPDSACKIGNOREDOLD;
1903                         } else {
1904                                 /* Don't count olds caused by ACK reordering */
1905                                 if ((TCP_SKB_CB(ack_skb)->ack_seq != tp->snd_una) &&
1906                                     !after(sp[used_sacks].end_seq, tp->snd_una))
1907                                         continue;
1908                                 mib_idx = LINUX_MIB_TCPSACKDISCARD;
1909                         }
1910
1911                         NET_INC_STATS(sock_net(sk), mib_idx);
1912                         if (i == 0)
1913                                 first_sack_index = -1;
1914                         continue;
1915                 }
1916
1917                 /* Ignore very old stuff early */
1918                 if (!after(sp[used_sacks].end_seq, prior_snd_una)) {
1919                         if (i == 0)
1920                                 first_sack_index = -1;
1921                         continue;
1922                 }
1923
1924                 used_sacks++;
1925         }
1926
1927         /* order SACK blocks to allow in order walk of the retrans queue */
1928         for (i = used_sacks - 1; i > 0; i--) {
1929                 for (j = 0; j < i; j++) {
1930                         if (after(sp[j].start_seq, sp[j + 1].start_seq)) {
1931                                 swap(sp[j], sp[j + 1]);
1932
1933                                 /* Track where the first SACK block goes to */
1934                                 if (j == first_sack_index)
1935                                         first_sack_index = j + 1;
1936                         }
1937                 }
1938         }
1939
1940         state->mss_now = tcp_current_mss(sk);
1941         skb = NULL;
1942         i = 0;
1943
1944         if (!tp->sacked_out) {
1945                 /* It's already past, so skip checking against it */
1946                 cache = tp->recv_sack_cache + ARRAY_SIZE(tp->recv_sack_cache);
1947         } else {
1948                 cache = tp->recv_sack_cache;
1949                 /* Skip empty blocks in at head of the cache */
1950                 while (tcp_sack_cache_ok(tp, cache) && !cache->start_seq &&
1951                        !cache->end_seq)
1952                         cache++;
1953         }
1954
1955         while (i < used_sacks) {
1956                 u32 start_seq = sp[i].start_seq;
1957                 u32 end_seq = sp[i].end_seq;
1958                 bool dup_sack = (found_dup_sack && (i == first_sack_index));
1959                 struct tcp_sack_block *next_dup = NULL;
1960
1961                 if (found_dup_sack && ((i + 1) == first_sack_index))
1962                         next_dup = &sp[i + 1];
1963
1964                 /* Skip too early cached blocks */
1965                 while (tcp_sack_cache_ok(tp, cache) &&
1966                        !before(start_seq, cache->end_seq))
1967                         cache++;
1968
1969                 /* Can skip some work by looking recv_sack_cache? */
1970                 if (tcp_sack_cache_ok(tp, cache) && !dup_sack &&
1971                     after(end_seq, cache->start_seq)) {
1972
1973                         /* Head todo? */
1974                         if (before(start_seq, cache->start_seq)) {
1975                                 skb = tcp_sacktag_skip(skb, sk, start_seq);
1976                                 skb = tcp_sacktag_walk(skb, sk, next_dup,
1977                                                        state,
1978                                                        start_seq,
1979                                                        cache->start_seq,
1980                                                        dup_sack);
1981                         }
1982
1983                         /* Rest of the block already fully processed? */
1984                         if (!after(end_seq, cache->end_seq))
1985                                 goto advance_sp;
1986
1987                         skb = tcp_maybe_skipping_dsack(skb, sk, next_dup,
1988                                                        state,
1989                                                        cache->end_seq);
1990
1991                         /* ...tail remains todo... */
1992                         if (tcp_highest_sack_seq(tp) == cache->end_seq) {
1993                                 /* ...but better entrypoint exists! */
1994                                 skb = tcp_highest_sack(sk);
1995                                 if (!skb)
1996                                         break;
1997                                 cache++;
1998                                 goto walk;
1999                         }
2000
2001                         skb = tcp_sacktag_skip(skb, sk, cache->end_seq);
2002                         /* Check overlap against next cached too (past this one already) */
2003                         cache++;
2004                         continue;
2005                 }
2006
2007                 if (!before(start_seq, tcp_highest_sack_seq(tp))) {
2008                         skb = tcp_highest_sack(sk);
2009                         if (!skb)
2010                                 break;
2011                 }
2012                 skb = tcp_sacktag_skip(skb, sk, start_seq);
2013
2014 walk:
2015                 skb = tcp_sacktag_walk(skb, sk, next_dup, state,
2016                                        start_seq, end_seq, dup_sack);
2017
2018 advance_sp:
2019                 i++;
2020         }
2021
2022         /* Clear the head of the cache sack blocks so we can skip it next time */
2023         for (i = 0; i < ARRAY_SIZE(tp->recv_sack_cache) - used_sacks; i++) {
2024                 tp->recv_sack_cache[i].start_seq = 0;
2025                 tp->recv_sack_cache[i].end_seq = 0;
2026         }
2027         for (j = 0; j < used_sacks; j++)
2028                 tp->recv_sack_cache[i++] = sp[j];
2029
2030         if (inet_csk(sk)->icsk_ca_state != TCP_CA_Loss || tp->undo_marker)
2031                 tcp_check_sack_reordering(sk, state->reord, 0);
2032
2033         tcp_verify_left_out(tp);
2034 out:
2035
2036 #if FASTRETRANS_DEBUG > 0
2037         WARN_ON((int)tp->sacked_out < 0);
2038         WARN_ON((int)tp->lost_out < 0);
2039         WARN_ON((int)tp->retrans_out < 0);
2040         WARN_ON((int)tcp_packets_in_flight(tp) < 0);
2041 #endif
2042         return state->flag;
2043 }
2044
2045 /* Limits sacked_out so that sum with lost_out isn't ever larger than
2046  * packets_out. Returns false if sacked_out adjustement wasn't necessary.
2047  */
2048 static bool tcp_limit_reno_sacked(struct tcp_sock *tp)
2049 {
2050         u32 holes;
2051
2052         holes = max(tp->lost_out, 1U);
2053         holes = min(holes, tp->packets_out);
2054
2055         if ((tp->sacked_out + holes) > tp->packets_out) {
2056                 tp->sacked_out = tp->packets_out - holes;
2057                 return true;
2058         }
2059         return false;
2060 }
2061
2062 /* If we receive more dupacks than we expected counting segments
2063  * in assumption of absent reordering, interpret this as reordering.
2064  * The only another reason could be bug in receiver TCP.
2065  */
2066 static void tcp_check_reno_reordering(struct sock *sk, const int addend)
2067 {
2068         struct tcp_sock *tp = tcp_sk(sk);
2069
2070         if (!tcp_limit_reno_sacked(tp))
2071                 return;
2072
2073         tp->reordering = min_t(u32, tp->packets_out + addend,
2074                                READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_max_reordering));
2075         tp->reord_seen++;
2076         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRENOREORDER);
2077 }
2078
2079 /* Emulate SACKs for SACKless connection: account for a new dupack. */
2080
2081 static void tcp_add_reno_sack(struct sock *sk, int num_dupack, bool ece_ack)
2082 {
2083         if (num_dupack) {
2084                 struct tcp_sock *tp = tcp_sk(sk);
2085                 u32 prior_sacked = tp->sacked_out;
2086                 s32 delivered;
2087
2088                 tp->sacked_out += num_dupack;
2089                 tcp_check_reno_reordering(sk, 0);
2090                 delivered = tp->sacked_out - prior_sacked;
2091                 if (delivered > 0)
2092                         tcp_count_delivered(tp, delivered, ece_ack);
2093                 tcp_verify_left_out(tp);
2094         }
2095 }
2096
2097 /* Account for ACK, ACKing some data in Reno Recovery phase. */
2098
2099 static void tcp_remove_reno_sacks(struct sock *sk, int acked, bool ece_ack)
2100 {
2101         struct tcp_sock *tp = tcp_sk(sk);
2102
2103         if (acked > 0) {
2104                 /* One ACK acked hole. The rest eat duplicate ACKs. */
2105                 tcp_count_delivered(tp, max_t(int, acked - tp->sacked_out, 1),
2106                                     ece_ack);
2107                 if (acked - 1 >= tp->sacked_out)
2108                         tp->sacked_out = 0;
2109                 else
2110                         tp->sacked_out -= acked - 1;
2111         }
2112         tcp_check_reno_reordering(sk, acked);
2113         tcp_verify_left_out(tp);
2114 }
2115
2116 static inline void tcp_reset_reno_sack(struct tcp_sock *tp)
2117 {
2118         tp->sacked_out = 0;
2119 }
2120
2121 void tcp_clear_retrans(struct tcp_sock *tp)
2122 {
2123         tp->retrans_out = 0;
2124         tp->lost_out = 0;
2125         tp->undo_marker = 0;
2126         tp->undo_retrans = -1;
2127         tp->sacked_out = 0;
2128         tp->rto_stamp = 0;
2129         tp->total_rto = 0;
2130         tp->total_rto_recoveries = 0;
2131         tp->total_rto_time = 0;
2132 }
2133
2134 static inline void tcp_init_undo(struct tcp_sock *tp)
2135 {
2136         tp->undo_marker = tp->snd_una;
2137
2138         /* Retransmission still in flight may cause DSACKs later. */
2139         /* First, account for regular retransmits in flight: */
2140         tp->undo_retrans = tp->retrans_out;
2141         /* Next, account for TLP retransmits in flight: */
2142         if (tp->tlp_high_seq && tp->tlp_retrans)
2143                 tp->undo_retrans++;
2144         /* Finally, avoid 0, because undo_retrans==0 means "can undo now": */
2145         if (!tp->undo_retrans)
2146                 tp->undo_retrans = -1;
2147 }
2148
2149 static bool tcp_is_rack(const struct sock *sk)
2150 {
2151         return READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_recovery) &
2152                 TCP_RACK_LOSS_DETECTION;
2153 }
2154
2155 /* If we detect SACK reneging, forget all SACK information
2156  * and reset tags completely, otherwise preserve SACKs. If receiver
2157  * dropped its ofo queue, we will know this due to reneging detection.
2158  */
2159 static void tcp_timeout_mark_lost(struct sock *sk)
2160 {
2161         struct tcp_sock *tp = tcp_sk(sk);
2162         struct sk_buff *skb, *head;
2163         bool is_reneg;                  /* is receiver reneging on SACKs? */
2164
2165         head = tcp_rtx_queue_head(sk);
2166         is_reneg = head && (TCP_SKB_CB(head)->sacked & TCPCB_SACKED_ACKED);
2167         if (is_reneg) {
2168                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSACKRENEGING);
2169                 tp->sacked_out = 0;
2170                 /* Mark SACK reneging until we recover from this loss event. */
2171                 tp->is_sack_reneg = 1;
2172         } else if (tcp_is_reno(tp)) {
2173                 tcp_reset_reno_sack(tp);
2174         }
2175
2176         skb = head;
2177         skb_rbtree_walk_from(skb) {
2178                 if (is_reneg)
2179                         TCP_SKB_CB(skb)->sacked &= ~TCPCB_SACKED_ACKED;
2180                 else if (tcp_is_rack(sk) && skb != head &&
2181                          tcp_rack_skb_timeout(tp, skb, 0) > 0)
2182                         continue; /* Don't mark recently sent ones lost yet */
2183                 tcp_mark_skb_lost(sk, skb);
2184         }
2185         tcp_verify_left_out(tp);
2186         tcp_clear_all_retrans_hints(tp);
2187 }
2188
2189 /* Enter Loss state. */
2190 void tcp_enter_loss(struct sock *sk)
2191 {
2192         const struct inet_connection_sock *icsk = inet_csk(sk);
2193         struct tcp_sock *tp = tcp_sk(sk);
2194         struct net *net = sock_net(sk);
2195         bool new_recovery = icsk->icsk_ca_state < TCP_CA_Recovery;
2196         u8 reordering;
2197
2198         tcp_timeout_mark_lost(sk);
2199
2200         /* Reduce ssthresh if it has not yet been made inside this window. */
2201         if (icsk->icsk_ca_state <= TCP_CA_Disorder ||
2202             !after(tp->high_seq, tp->snd_una) ||
2203             (icsk->icsk_ca_state == TCP_CA_Loss && !icsk->icsk_retransmits)) {
2204                 tp->prior_ssthresh = tcp_current_ssthresh(sk);
2205                 tp->prior_cwnd = tcp_snd_cwnd(tp);
2206                 tp->snd_ssthresh = icsk->icsk_ca_ops->ssthresh(sk);
2207                 tcp_ca_event(sk, CA_EVENT_LOSS);
2208                 tcp_init_undo(tp);
2209         }
2210         tcp_snd_cwnd_set(tp, tcp_packets_in_flight(tp) + 1);
2211         tp->snd_cwnd_cnt   = 0;
2212         tp->snd_cwnd_stamp = tcp_jiffies32;
2213
2214         /* Timeout in disordered state after receiving substantial DUPACKs
2215          * suggests that the degree of reordering is over-estimated.
2216          */
2217         reordering = READ_ONCE(net->ipv4.sysctl_tcp_reordering);
2218         if (icsk->icsk_ca_state <= TCP_CA_Disorder &&
2219             tp->sacked_out >= reordering)
2220                 tp->reordering = min_t(unsigned int, tp->reordering,
2221                                        reordering);
2222
2223         tcp_set_ca_state(sk, TCP_CA_Loss);
2224         tp->high_seq = tp->snd_nxt;
2225         tp->tlp_high_seq = 0;
2226         tcp_ecn_queue_cwr(tp);
2227
2228         /* F-RTO RFC5682 sec 3.1 step 1: retransmit SND.UNA if no previous
2229          * loss recovery is underway except recurring timeout(s) on
2230          * the same SND.UNA (sec 3.2). Disable F-RTO on path MTU probing
2231          */
2232         tp->frto = READ_ONCE(net->ipv4.sysctl_tcp_frto) &&
2233                    (new_recovery || icsk->icsk_retransmits) &&
2234                    !inet_csk(sk)->icsk_mtup.probe_size;
2235 }
2236
2237 /* If ACK arrived pointing to a remembered SACK, it means that our
2238  * remembered SACKs do not reflect real state of receiver i.e.
2239  * receiver _host_ is heavily congested (or buggy).
2240  *
2241  * To avoid big spurious retransmission bursts due to transient SACK
2242  * scoreboard oddities that look like reneging, we give the receiver a
2243  * little time (max(RTT/2, 10ms)) to send us some more ACKs that will
2244  * restore sanity to the SACK scoreboard. If the apparent reneging
2245  * persists until this RTO then we'll clear the SACK scoreboard.
2246  */
2247 static bool tcp_check_sack_reneging(struct sock *sk, int *ack_flag)
2248 {
2249         if (*ack_flag & FLAG_SACK_RENEGING &&
2250             *ack_flag & FLAG_SND_UNA_ADVANCED) {
2251                 struct tcp_sock *tp = tcp_sk(sk);
2252                 unsigned long delay = max(usecs_to_jiffies(tp->srtt_us >> 4),
2253                                           msecs_to_jiffies(10));
2254
2255                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
2256                                           delay, TCP_RTO_MAX);
2257                 *ack_flag &= ~FLAG_SET_XMIT_TIMER;
2258                 return true;
2259         }
2260         return false;
2261 }
2262
2263 /* Heurestics to calculate number of duplicate ACKs. There's no dupACKs
2264  * counter when SACK is enabled (without SACK, sacked_out is used for
2265  * that purpose).
2266  *
2267  * With reordering, holes may still be in flight, so RFC3517 recovery
2268  * uses pure sacked_out (total number of SACKed segments) even though
2269  * it violates the RFC that uses duplicate ACKs, often these are equal
2270  * but when e.g. out-of-window ACKs or packet duplication occurs,
2271  * they differ. Since neither occurs due to loss, TCP should really
2272  * ignore them.
2273  */
2274 static inline int tcp_dupack_heuristics(const struct tcp_sock *tp)
2275 {
2276         return tp->sacked_out + 1;
2277 }
2278
2279 /* Linux NewReno/SACK/ECN state machine.
2280  * --------------------------------------
2281  *
2282  * "Open"       Normal state, no dubious events, fast path.
2283  * "Disorder"   In all the respects it is "Open",
2284  *              but requires a bit more attention. It is entered when
2285  *              we see some SACKs or dupacks. It is split of "Open"
2286  *              mainly to move some processing from fast path to slow one.
2287  * "CWR"        CWND was reduced due to some Congestion Notification event.
2288  *              It can be ECN, ICMP source quench, local device congestion.
2289  * "Recovery"   CWND was reduced, we are fast-retransmitting.
2290  * "Loss"       CWND was reduced due to RTO timeout or SACK reneging.
2291  *
2292  * tcp_fastretrans_alert() is entered:
2293  * - each incoming ACK, if state is not "Open"
2294  * - when arrived ACK is unusual, namely:
2295  *      * SACK
2296  *      * Duplicate ACK.
2297  *      * ECN ECE.
2298  *
2299  * Counting packets in flight is pretty simple.
2300  *
2301  *      in_flight = packets_out - left_out + retrans_out
2302  *
2303  *      packets_out is SND.NXT-SND.UNA counted in packets.
2304  *
2305  *      retrans_out is number of retransmitted segments.
2306  *
2307  *      left_out is number of segments left network, but not ACKed yet.
2308  *
2309  *              left_out = sacked_out + lost_out
2310  *
2311  *     sacked_out: Packets, which arrived to receiver out of order
2312  *                 and hence not ACKed. With SACKs this number is simply
2313  *                 amount of SACKed data. Even without SACKs
2314  *                 it is easy to give pretty reliable estimate of this number,
2315  *                 counting duplicate ACKs.
2316  *
2317  *       lost_out: Packets lost by network. TCP has no explicit
2318  *                 "loss notification" feedback from network (for now).
2319  *                 It means that this number can be only _guessed_.
2320  *                 Actually, it is the heuristics to predict lossage that
2321  *                 distinguishes different algorithms.
2322  *
2323  *      F.e. after RTO, when all the queue is considered as lost,
2324  *      lost_out = packets_out and in_flight = retrans_out.
2325  *
2326  *              Essentially, we have now a few algorithms detecting
2327  *              lost packets.
2328  *
2329  *              If the receiver supports SACK:
2330  *
2331  *              RFC6675/3517: It is the conventional algorithm. A packet is
2332  *              considered lost if the number of higher sequence packets
2333  *              SACKed is greater than or equal the DUPACK thoreshold
2334  *              (reordering). This is implemented in tcp_mark_head_lost and
2335  *              tcp_update_scoreboard.
2336  *
2337  *              RACK (draft-ietf-tcpm-rack-01): it is a newer algorithm
2338  *              (2017-) that checks timing instead of counting DUPACKs.
2339  *              Essentially a packet is considered lost if it's not S/ACKed
2340  *              after RTT + reordering_window, where both metrics are
2341  *              dynamically measured and adjusted. This is implemented in
2342  *              tcp_rack_mark_lost.
2343  *
2344  *              If the receiver does not support SACK:
2345  *
2346  *              NewReno (RFC6582): in Recovery we assume that one segment
2347  *              is lost (classic Reno). While we are in Recovery and
2348  *              a partial ACK arrives, we assume that one more packet
2349  *              is lost (NewReno). This heuristics are the same in NewReno
2350  *              and SACK.
2351  *
2352  * Really tricky (and requiring careful tuning) part of algorithm
2353  * is hidden in functions tcp_time_to_recover() and tcp_xmit_retransmit_queue().
2354  * The first determines the moment _when_ we should reduce CWND and,
2355  * hence, slow down forward transmission. In fact, it determines the moment
2356  * when we decide that hole is caused by loss, rather than by a reorder.
2357  *
2358  * tcp_xmit_retransmit_queue() decides, _what_ we should retransmit to fill
2359  * holes, caused by lost packets.
2360  *
2361  * And the most logically complicated part of algorithm is undo
2362  * heuristics. We detect false retransmits due to both too early
2363  * fast retransmit (reordering) and underestimated RTO, analyzing
2364  * timestamps and D-SACKs. When we detect that some segments were
2365  * retransmitted by mistake and CWND reduction was wrong, we undo
2366  * window reduction and abort recovery phase. This logic is hidden
2367  * inside several functions named tcp_try_undo_<something>.
2368  */
2369
2370 /* This function decides, when we should leave Disordered state
2371  * and enter Recovery phase, reducing congestion window.
2372  *
2373  * Main question: may we further continue forward transmission
2374  * with the same cwnd?
2375  */
2376 static bool tcp_time_to_recover(struct sock *sk, int flag)
2377 {
2378         struct tcp_sock *tp = tcp_sk(sk);
2379
2380         /* Trick#1: The loss is proven. */
2381         if (tp->lost_out)
2382                 return true;
2383
2384         /* Not-A-Trick#2 : Classic rule... */
2385         if (!tcp_is_rack(sk) && tcp_dupack_heuristics(tp) > tp->reordering)
2386                 return true;
2387
2388         return false;
2389 }
2390
2391 /* Detect loss in event "A" above by marking head of queue up as lost.
2392  * For RFC3517 SACK, a segment is considered lost if it
2393  * has at least tp->reordering SACKed seqments above it; "packets" refers to
2394  * the maximum SACKed segments to pass before reaching this limit.
2395  */
2396 static void tcp_mark_head_lost(struct sock *sk, int packets, int mark_head)
2397 {
2398         struct tcp_sock *tp = tcp_sk(sk);
2399         struct sk_buff *skb;
2400         int cnt;
2401         /* Use SACK to deduce losses of new sequences sent during recovery */
2402         const u32 loss_high = tp->snd_nxt;
2403
2404         WARN_ON(packets > tp->packets_out);
2405         skb = tp->lost_skb_hint;
2406         if (skb) {
2407                 /* Head already handled? */
2408                 if (mark_head && after(TCP_SKB_CB(skb)->seq, tp->snd_una))
2409                         return;
2410                 cnt = tp->lost_cnt_hint;
2411         } else {
2412                 skb = tcp_rtx_queue_head(sk);
2413                 cnt = 0;
2414         }
2415
2416         skb_rbtree_walk_from(skb) {
2417                 /* TODO: do this better */
2418                 /* this is not the most efficient way to do this... */
2419                 tp->lost_skb_hint = skb;
2420                 tp->lost_cnt_hint = cnt;
2421
2422                 if (after(TCP_SKB_CB(skb)->end_seq, loss_high))
2423                         break;
2424
2425                 if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
2426                         cnt += tcp_skb_pcount(skb);
2427
2428                 if (cnt > packets)
2429                         break;
2430
2431                 if (!(TCP_SKB_CB(skb)->sacked & TCPCB_LOST))
2432                         tcp_mark_skb_lost(sk, skb);
2433
2434                 if (mark_head)
2435                         break;
2436         }
2437         tcp_verify_left_out(tp);
2438 }
2439
2440 /* Account newly detected lost packet(s) */
2441
2442 static void tcp_update_scoreboard(struct sock *sk, int fast_rexmit)
2443 {
2444         struct tcp_sock *tp = tcp_sk(sk);
2445
2446         if (tcp_is_sack(tp)) {
2447                 int sacked_upto = tp->sacked_out - tp->reordering;
2448                 if (sacked_upto >= 0)
2449                         tcp_mark_head_lost(sk, sacked_upto, 0);
2450                 else if (fast_rexmit)
2451                         tcp_mark_head_lost(sk, 1, 1);
2452         }
2453 }
2454
2455 static bool tcp_tsopt_ecr_before(const struct tcp_sock *tp, u32 when)
2456 {
2457         return tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
2458                before(tp->rx_opt.rcv_tsecr, when);
2459 }
2460
2461 /* skb is spurious retransmitted if the returned timestamp echo
2462  * reply is prior to the skb transmission time
2463  */
2464 static bool tcp_skb_spurious_retrans(const struct tcp_sock *tp,
2465                                      const struct sk_buff *skb)
2466 {
2467         return (TCP_SKB_CB(skb)->sacked & TCPCB_RETRANS) &&
2468                tcp_tsopt_ecr_before(tp, tcp_skb_timestamp_ts(tp->tcp_usec_ts, skb));
2469 }
2470
2471 /* Nothing was retransmitted or returned timestamp is less
2472  * than timestamp of the first retransmission.
2473  */
2474 static inline bool tcp_packet_delayed(const struct tcp_sock *tp)
2475 {
2476         return tp->retrans_stamp &&
2477                tcp_tsopt_ecr_before(tp, tp->retrans_stamp);
2478 }
2479
2480 /* Undo procedures. */
2481
2482 /* We can clear retrans_stamp when there are no retransmissions in the
2483  * window. It would seem that it is trivially available for us in
2484  * tp->retrans_out, however, that kind of assumptions doesn't consider
2485  * what will happen if errors occur when sending retransmission for the
2486  * second time. ...It could the that such segment has only
2487  * TCPCB_EVER_RETRANS set at the present time. It seems that checking
2488  * the head skb is enough except for some reneging corner cases that
2489  * are not worth the effort.
2490  *
2491  * Main reason for all this complexity is the fact that connection dying
2492  * time now depends on the validity of the retrans_stamp, in particular,
2493  * that successive retransmissions of a segment must not advance
2494  * retrans_stamp under any conditions.
2495  */
2496 static bool tcp_any_retrans_done(const struct sock *sk)
2497 {
2498         const struct tcp_sock *tp = tcp_sk(sk);
2499         struct sk_buff *skb;
2500
2501         if (tp->retrans_out)
2502                 return true;
2503
2504         skb = tcp_rtx_queue_head(sk);
2505         if (unlikely(skb && TCP_SKB_CB(skb)->sacked & TCPCB_EVER_RETRANS))
2506                 return true;
2507
2508         return false;
2509 }
2510
2511 static void DBGUNDO(struct sock *sk, const char *msg)
2512 {
2513 #if FASTRETRANS_DEBUG > 1
2514         struct tcp_sock *tp = tcp_sk(sk);
2515         struct inet_sock *inet = inet_sk(sk);
2516
2517         if (sk->sk_family == AF_INET) {
2518                 pr_debug("Undo %s %pI4/%u c%u l%u ss%u/%u p%u\n",
2519                          msg,
2520                          &inet->inet_daddr, ntohs(inet->inet_dport),
2521                          tcp_snd_cwnd(tp), tcp_left_out(tp),
2522                          tp->snd_ssthresh, tp->prior_ssthresh,
2523                          tp->packets_out);
2524         }
2525 #if IS_ENABLED(CONFIG_IPV6)
2526         else if (sk->sk_family == AF_INET6) {
2527                 pr_debug("Undo %s %pI6/%u c%u l%u ss%u/%u p%u\n",
2528                          msg,
2529                          &sk->sk_v6_daddr, ntohs(inet->inet_dport),
2530                          tcp_snd_cwnd(tp), tcp_left_out(tp),
2531                          tp->snd_ssthresh, tp->prior_ssthresh,
2532                          tp->packets_out);
2533         }
2534 #endif
2535 #endif
2536 }
2537
2538 static void tcp_undo_cwnd_reduction(struct sock *sk, bool unmark_loss)
2539 {
2540         struct tcp_sock *tp = tcp_sk(sk);
2541
2542         if (unmark_loss) {
2543                 struct sk_buff *skb;
2544
2545                 skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
2546                         TCP_SKB_CB(skb)->sacked &= ~TCPCB_LOST;
2547                 }
2548                 tp->lost_out = 0;
2549                 tcp_clear_all_retrans_hints(tp);
2550         }
2551
2552         if (tp->prior_ssthresh) {
2553                 const struct inet_connection_sock *icsk = inet_csk(sk);
2554
2555                 tcp_snd_cwnd_set(tp, icsk->icsk_ca_ops->undo_cwnd(sk));
2556
2557                 if (tp->prior_ssthresh > tp->snd_ssthresh) {
2558                         tp->snd_ssthresh = tp->prior_ssthresh;
2559                         tcp_ecn_withdraw_cwr(tp);
2560                 }
2561         }
2562         tp->snd_cwnd_stamp = tcp_jiffies32;
2563         tp->undo_marker = 0;
2564         tp->rack.advanced = 1; /* Force RACK to re-exam losses */
2565 }
2566
2567 static inline bool tcp_may_undo(const struct tcp_sock *tp)
2568 {
2569         return tp->undo_marker && (!tp->undo_retrans || tcp_packet_delayed(tp));
2570 }
2571
2572 static bool tcp_is_non_sack_preventing_reopen(struct sock *sk)
2573 {
2574         struct tcp_sock *tp = tcp_sk(sk);
2575
2576         if (tp->snd_una == tp->high_seq && tcp_is_reno(tp)) {
2577                 /* Hold old state until something *above* high_seq
2578                  * is ACKed. For Reno it is MUST to prevent false
2579                  * fast retransmits (RFC2582). SACK TCP is safe. */
2580                 if (!tcp_any_retrans_done(sk))
2581                         tp->retrans_stamp = 0;
2582                 return true;
2583         }
2584         return false;
2585 }
2586
2587 /* People celebrate: "We love our President!" */
2588 static bool tcp_try_undo_recovery(struct sock *sk)
2589 {
2590         struct tcp_sock *tp = tcp_sk(sk);
2591
2592         if (tcp_may_undo(tp)) {
2593                 int mib_idx;
2594
2595                 /* Happy end! We did not retransmit anything
2596                  * or our original transmission succeeded.
2597                  */
2598                 DBGUNDO(sk, inet_csk(sk)->icsk_ca_state == TCP_CA_Loss ? "loss" : "retrans");
2599                 tcp_undo_cwnd_reduction(sk, false);
2600                 if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss)
2601                         mib_idx = LINUX_MIB_TCPLOSSUNDO;
2602                 else
2603                         mib_idx = LINUX_MIB_TCPFULLUNDO;
2604
2605                 NET_INC_STATS(sock_net(sk), mib_idx);
2606         } else if (tp->rack.reo_wnd_persist) {
2607                 tp->rack.reo_wnd_persist--;
2608         }
2609         if (tcp_is_non_sack_preventing_reopen(sk))
2610                 return true;
2611         tcp_set_ca_state(sk, TCP_CA_Open);
2612         tp->is_sack_reneg = 0;
2613         return false;
2614 }
2615
2616 /* Try to undo cwnd reduction, because D-SACKs acked all retransmitted data */
2617 static bool tcp_try_undo_dsack(struct sock *sk)
2618 {
2619         struct tcp_sock *tp = tcp_sk(sk);
2620
2621         if (tp->undo_marker && !tp->undo_retrans) {
2622                 tp->rack.reo_wnd_persist = min(TCP_RACK_RECOVERY_THRESH,
2623                                                tp->rack.reo_wnd_persist + 1);
2624                 DBGUNDO(sk, "D-SACK");
2625                 tcp_undo_cwnd_reduction(sk, false);
2626                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDSACKUNDO);
2627                 return true;
2628         }
2629         return false;
2630 }
2631
2632 /* Undo during loss recovery after partial ACK or using F-RTO. */
2633 static bool tcp_try_undo_loss(struct sock *sk, bool frto_undo)
2634 {
2635         struct tcp_sock *tp = tcp_sk(sk);
2636
2637         if (frto_undo || tcp_may_undo(tp)) {
2638                 tcp_undo_cwnd_reduction(sk, true);
2639
2640                 DBGUNDO(sk, "partial loss");
2641                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSUNDO);
2642                 if (frto_undo)
2643                         NET_INC_STATS(sock_net(sk),
2644                                         LINUX_MIB_TCPSPURIOUSRTOS);
2645                 inet_csk(sk)->icsk_retransmits = 0;
2646                 if (tcp_is_non_sack_preventing_reopen(sk))
2647                         return true;
2648                 if (frto_undo || tcp_is_sack(tp)) {
2649                         tcp_set_ca_state(sk, TCP_CA_Open);
2650                         tp->is_sack_reneg = 0;
2651                 }
2652                 return true;
2653         }
2654         return false;
2655 }
2656
2657 /* The cwnd reduction in CWR and Recovery uses the PRR algorithm in RFC 6937.
2658  * It computes the number of packets to send (sndcnt) based on packets newly
2659  * delivered:
2660  *   1) If the packets in flight is larger than ssthresh, PRR spreads the
2661  *      cwnd reductions across a full RTT.
2662  *   2) Otherwise PRR uses packet conservation to send as much as delivered.
2663  *      But when SND_UNA is acked without further losses,
2664  *      slow starts cwnd up to ssthresh to speed up the recovery.
2665  */
2666 static void tcp_init_cwnd_reduction(struct sock *sk)
2667 {
2668         struct tcp_sock *tp = tcp_sk(sk);
2669
2670         tp->high_seq = tp->snd_nxt;
2671         tp->tlp_high_seq = 0;
2672         tp->snd_cwnd_cnt = 0;
2673         tp->prior_cwnd = tcp_snd_cwnd(tp);
2674         tp->prr_delivered = 0;
2675         tp->prr_out = 0;
2676         tp->snd_ssthresh = inet_csk(sk)->icsk_ca_ops->ssthresh(sk);
2677         tcp_ecn_queue_cwr(tp);
2678 }
2679
2680 void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int newly_lost, int flag)
2681 {
2682         struct tcp_sock *tp = tcp_sk(sk);
2683         int sndcnt = 0;
2684         int delta = tp->snd_ssthresh - tcp_packets_in_flight(tp);
2685
2686         if (newly_acked_sacked <= 0 || WARN_ON_ONCE(!tp->prior_cwnd))
2687                 return;
2688
2689         tp->prr_delivered += newly_acked_sacked;
2690         if (delta < 0) {
2691                 u64 dividend = (u64)tp->snd_ssthresh * tp->prr_delivered +
2692                                tp->prior_cwnd - 1;
2693                 sndcnt = div_u64(dividend, tp->prior_cwnd) - tp->prr_out;
2694         } else {
2695                 sndcnt = max_t(int, tp->prr_delivered - tp->prr_out,
2696                                newly_acked_sacked);
2697                 if (flag & FLAG_SND_UNA_ADVANCED && !newly_lost)
2698                         sndcnt++;
2699                 sndcnt = min(delta, sndcnt);
2700         }
2701         /* Force a fast retransmit upon entering fast recovery */
2702         sndcnt = max(sndcnt, (tp->prr_out ? 0 : 1));
2703         tcp_snd_cwnd_set(tp, tcp_packets_in_flight(tp) + sndcnt);
2704 }
2705
2706 static inline void tcp_end_cwnd_reduction(struct sock *sk)
2707 {
2708         struct tcp_sock *tp = tcp_sk(sk);
2709
2710         if (inet_csk(sk)->icsk_ca_ops->cong_control)
2711                 return;
2712
2713         /* Reset cwnd to ssthresh in CWR or Recovery (unless it's undone) */
2714         if (tp->snd_ssthresh < TCP_INFINITE_SSTHRESH &&
2715             (inet_csk(sk)->icsk_ca_state == TCP_CA_CWR || tp->undo_marker)) {
2716                 tcp_snd_cwnd_set(tp, tp->snd_ssthresh);
2717                 tp->snd_cwnd_stamp = tcp_jiffies32;
2718         }
2719         tcp_ca_event(sk, CA_EVENT_COMPLETE_CWR);
2720 }
2721
2722 /* Enter CWR state. Disable cwnd undo since congestion is proven with ECN */
2723 void tcp_enter_cwr(struct sock *sk)
2724 {
2725         struct tcp_sock *tp = tcp_sk(sk);
2726
2727         tp->prior_ssthresh = 0;
2728         if (inet_csk(sk)->icsk_ca_state < TCP_CA_CWR) {
2729                 tp->undo_marker = 0;
2730                 tcp_init_cwnd_reduction(sk);
2731                 tcp_set_ca_state(sk, TCP_CA_CWR);
2732         }
2733 }
2734 EXPORT_SYMBOL(tcp_enter_cwr);
2735
2736 static void tcp_try_keep_open(struct sock *sk)
2737 {
2738         struct tcp_sock *tp = tcp_sk(sk);
2739         int state = TCP_CA_Open;
2740
2741         if (tcp_left_out(tp) || tcp_any_retrans_done(sk))
2742                 state = TCP_CA_Disorder;
2743
2744         if (inet_csk(sk)->icsk_ca_state != state) {
2745                 tcp_set_ca_state(sk, state);
2746                 tp->high_seq = tp->snd_nxt;
2747         }
2748 }
2749
2750 static void tcp_try_to_open(struct sock *sk, int flag)
2751 {
2752         struct tcp_sock *tp = tcp_sk(sk);
2753
2754         tcp_verify_left_out(tp);
2755
2756         if (!tcp_any_retrans_done(sk))
2757                 tp->retrans_stamp = 0;
2758
2759         if (flag & FLAG_ECE)
2760                 tcp_enter_cwr(sk);
2761
2762         if (inet_csk(sk)->icsk_ca_state != TCP_CA_CWR) {
2763                 tcp_try_keep_open(sk);
2764         }
2765 }
2766
2767 static void tcp_mtup_probe_failed(struct sock *sk)
2768 {
2769         struct inet_connection_sock *icsk = inet_csk(sk);
2770
2771         icsk->icsk_mtup.search_high = icsk->icsk_mtup.probe_size - 1;
2772         icsk->icsk_mtup.probe_size = 0;
2773         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPFAIL);
2774 }
2775
2776 static void tcp_mtup_probe_success(struct sock *sk)
2777 {
2778         struct tcp_sock *tp = tcp_sk(sk);
2779         struct inet_connection_sock *icsk = inet_csk(sk);
2780         u64 val;
2781
2782         tp->prior_ssthresh = tcp_current_ssthresh(sk);
2783
2784         val = (u64)tcp_snd_cwnd(tp) * tcp_mss_to_mtu(sk, tp->mss_cache);
2785         do_div(val, icsk->icsk_mtup.probe_size);
2786         DEBUG_NET_WARN_ON_ONCE((u32)val != val);
2787         tcp_snd_cwnd_set(tp, max_t(u32, 1U, val));
2788
2789         tp->snd_cwnd_cnt = 0;
2790         tp->snd_cwnd_stamp = tcp_jiffies32;
2791         tp->snd_ssthresh = tcp_current_ssthresh(sk);
2792
2793         icsk->icsk_mtup.search_low = icsk->icsk_mtup.probe_size;
2794         icsk->icsk_mtup.probe_size = 0;
2795         tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
2796         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMTUPSUCCESS);
2797 }
2798
2799 /* Sometimes we deduce that packets have been dropped due to reasons other than
2800  * congestion, like path MTU reductions or failed client TFO attempts. In these
2801  * cases we call this function to retransmit as many packets as cwnd allows,
2802  * without reducing cwnd. Given that retransmits will set retrans_stamp to a
2803  * non-zero value (and may do so in a later calling context due to TSQ), we
2804  * also enter CA_Loss so that we track when all retransmitted packets are ACKed
2805  * and clear retrans_stamp when that happens (to ensure later recurring RTOs
2806  * are using the correct retrans_stamp and don't declare ETIMEDOUT
2807  * prematurely).
2808  */
2809 static void tcp_non_congestion_loss_retransmit(struct sock *sk)
2810 {
2811         const struct inet_connection_sock *icsk = inet_csk(sk);
2812         struct tcp_sock *tp = tcp_sk(sk);
2813
2814         if (icsk->icsk_ca_state != TCP_CA_Loss) {
2815                 tp->high_seq = tp->snd_nxt;
2816                 tp->snd_ssthresh = tcp_current_ssthresh(sk);
2817                 tp->prior_ssthresh = 0;
2818                 tp->undo_marker = 0;
2819                 tcp_set_ca_state(sk, TCP_CA_Loss);
2820         }
2821         tcp_xmit_retransmit_queue(sk);
2822 }
2823
2824 /* Do a simple retransmit without using the backoff mechanisms in
2825  * tcp_timer. This is used for path mtu discovery.
2826  * The socket is already locked here.
2827  */
2828 void tcp_simple_retransmit(struct sock *sk)
2829 {
2830         struct tcp_sock *tp = tcp_sk(sk);
2831         struct sk_buff *skb;
2832         int mss;
2833
2834         /* A fastopen SYN request is stored as two separate packets within
2835          * the retransmit queue, this is done by tcp_send_syn_data().
2836          * As a result simply checking the MSS of the frames in the queue
2837          * will not work for the SYN packet.
2838          *
2839          * Us being here is an indication of a path MTU issue so we can
2840          * assume that the fastopen SYN was lost and just mark all the
2841          * frames in the retransmit queue as lost. We will use an MSS of
2842          * -1 to mark all frames as lost, otherwise compute the current MSS.
2843          */
2844         if (tp->syn_data && sk->sk_state == TCP_SYN_SENT)
2845                 mss = -1;
2846         else
2847                 mss = tcp_current_mss(sk);
2848
2849         skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
2850                 if (tcp_skb_seglen(skb) > mss)
2851                         tcp_mark_skb_lost(sk, skb);
2852         }
2853
2854         tcp_clear_retrans_hints_partial(tp);
2855
2856         if (!tp->lost_out)
2857                 return;
2858
2859         if (tcp_is_reno(tp))
2860                 tcp_limit_reno_sacked(tp);
2861
2862         tcp_verify_left_out(tp);
2863
2864         /* Don't muck with the congestion window here.
2865          * Reason is that we do not increase amount of _data_
2866          * in network, but units changed and effective
2867          * cwnd/ssthresh really reduced now.
2868          */
2869         tcp_non_congestion_loss_retransmit(sk);
2870 }
2871 EXPORT_SYMBOL(tcp_simple_retransmit);
2872
2873 void tcp_enter_recovery(struct sock *sk, bool ece_ack)
2874 {
2875         struct tcp_sock *tp = tcp_sk(sk);
2876         int mib_idx;
2877
2878         if (tcp_is_reno(tp))
2879                 mib_idx = LINUX_MIB_TCPRENORECOVERY;
2880         else
2881                 mib_idx = LINUX_MIB_TCPSACKRECOVERY;
2882
2883         NET_INC_STATS(sock_net(sk), mib_idx);
2884
2885         tp->prior_ssthresh = 0;
2886         tcp_init_undo(tp);
2887
2888         if (!tcp_in_cwnd_reduction(sk)) {
2889                 if (!ece_ack)
2890                         tp->prior_ssthresh = tcp_current_ssthresh(sk);
2891                 tcp_init_cwnd_reduction(sk);
2892         }
2893         tcp_set_ca_state(sk, TCP_CA_Recovery);
2894 }
2895
2896 static void tcp_update_rto_time(struct tcp_sock *tp)
2897 {
2898         if (tp->rto_stamp) {
2899                 tp->total_rto_time += tcp_time_stamp_ms(tp) - tp->rto_stamp;
2900                 tp->rto_stamp = 0;
2901         }
2902 }
2903
2904 /* Process an ACK in CA_Loss state. Move to CA_Open if lost data are
2905  * recovered or spurious. Otherwise retransmits more on partial ACKs.
2906  */
2907 static void tcp_process_loss(struct sock *sk, int flag, int num_dupack,
2908                              int *rexmit)
2909 {
2910         struct tcp_sock *tp = tcp_sk(sk);
2911         bool recovered = !before(tp->snd_una, tp->high_seq);
2912
2913         if ((flag & FLAG_SND_UNA_ADVANCED || rcu_access_pointer(tp->fastopen_rsk)) &&
2914             tcp_try_undo_loss(sk, false))
2915                 return;
2916
2917         if (tp->frto) { /* F-RTO RFC5682 sec 3.1 (sack enhanced version). */
2918                 /* Step 3.b. A timeout is spurious if not all data are
2919                  * lost, i.e., never-retransmitted data are (s)acked.
2920                  */
2921                 if ((flag & FLAG_ORIG_SACK_ACKED) &&
2922                     tcp_try_undo_loss(sk, true))
2923                         return;
2924
2925                 if (after(tp->snd_nxt, tp->high_seq)) {
2926                         if (flag & FLAG_DATA_SACKED || num_dupack)
2927                                 tp->frto = 0; /* Step 3.a. loss was real */
2928                 } else if (flag & FLAG_SND_UNA_ADVANCED && !recovered) {
2929                         tp->high_seq = tp->snd_nxt;
2930                         /* Step 2.b. Try send new data (but deferred until cwnd
2931                          * is updated in tcp_ack()). Otherwise fall back to
2932                          * the conventional recovery.
2933                          */
2934                         if (!tcp_write_queue_empty(sk) &&
2935                             after(tcp_wnd_end(tp), tp->snd_nxt)) {
2936                                 *rexmit = REXMIT_NEW;
2937                                 return;
2938                         }
2939                         tp->frto = 0;
2940                 }
2941         }
2942
2943         if (recovered) {
2944                 /* F-RTO RFC5682 sec 3.1 step 2.a and 1st part of step 3.a */
2945                 tcp_try_undo_recovery(sk);
2946                 return;
2947         }
2948         if (tcp_is_reno(tp)) {
2949                 /* A Reno DUPACK means new data in F-RTO step 2.b above are
2950                  * delivered. Lower inflight to clock out (re)transmissions.
2951                  */
2952                 if (after(tp->snd_nxt, tp->high_seq) && num_dupack)
2953                         tcp_add_reno_sack(sk, num_dupack, flag & FLAG_ECE);
2954                 else if (flag & FLAG_SND_UNA_ADVANCED)
2955                         tcp_reset_reno_sack(tp);
2956         }
2957         *rexmit = REXMIT_LOST;
2958 }
2959
2960 static bool tcp_force_fast_retransmit(struct sock *sk)
2961 {
2962         struct tcp_sock *tp = tcp_sk(sk);
2963
2964         return after(tcp_highest_sack_seq(tp),
2965                      tp->snd_una + tp->reordering * tp->mss_cache);
2966 }
2967
2968 /* Undo during fast recovery after partial ACK. */
2969 static bool tcp_try_undo_partial(struct sock *sk, u32 prior_snd_una,
2970                                  bool *do_lost)
2971 {
2972         struct tcp_sock *tp = tcp_sk(sk);
2973
2974         if (tp->undo_marker && tcp_packet_delayed(tp)) {
2975                 /* Plain luck! Hole if filled with delayed
2976                  * packet, rather than with a retransmit. Check reordering.
2977                  */
2978                 tcp_check_sack_reordering(sk, prior_snd_una, 1);
2979
2980                 /* We are getting evidence that the reordering degree is higher
2981                  * than we realized. If there are no retransmits out then we
2982                  * can undo. Otherwise we clock out new packets but do not
2983                  * mark more packets lost or retransmit more.
2984                  */
2985                 if (tp->retrans_out)
2986                         return true;
2987
2988                 if (!tcp_any_retrans_done(sk))
2989                         tp->retrans_stamp = 0;
2990
2991                 DBGUNDO(sk, "partial recovery");
2992                 tcp_undo_cwnd_reduction(sk, true);
2993                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPARTIALUNDO);
2994                 tcp_try_keep_open(sk);
2995         } else {
2996                 /* Partial ACK arrived. Force fast retransmit. */
2997                 *do_lost = tcp_force_fast_retransmit(sk);
2998         }
2999         return false;
3000 }
3001
3002 static void tcp_identify_packet_loss(struct sock *sk, int *ack_flag)
3003 {
3004         struct tcp_sock *tp = tcp_sk(sk);
3005
3006         if (tcp_rtx_queue_empty(sk))
3007                 return;
3008
3009         if (unlikely(tcp_is_reno(tp))) {
3010                 tcp_newreno_mark_lost(sk, *ack_flag & FLAG_SND_UNA_ADVANCED);
3011         } else if (tcp_is_rack(sk)) {
3012                 u32 prior_retrans = tp->retrans_out;
3013
3014                 if (tcp_rack_mark_lost(sk))
3015                         *ack_flag &= ~FLAG_SET_XMIT_TIMER;
3016                 if (prior_retrans > tp->retrans_out)
3017                         *ack_flag |= FLAG_LOST_RETRANS;
3018         }
3019 }
3020
3021 /* Process an event, which can update packets-in-flight not trivially.
3022  * Main goal of this function is to calculate new estimate for left_out,
3023  * taking into account both packets sitting in receiver's buffer and
3024  * packets lost by network.
3025  *
3026  * Besides that it updates the congestion state when packet loss or ECN
3027  * is detected. But it does not reduce the cwnd, it is done by the
3028  * congestion control later.
3029  *
3030  * It does _not_ decide what to send, it is made in function
3031  * tcp_xmit_retransmit_queue().
3032  */
3033 static void tcp_fastretrans_alert(struct sock *sk, const u32 prior_snd_una,
3034                                   int num_dupack, int *ack_flag, int *rexmit)
3035 {
3036         struct inet_connection_sock *icsk = inet_csk(sk);
3037         struct tcp_sock *tp = tcp_sk(sk);
3038         int fast_rexmit = 0, flag = *ack_flag;
3039         bool ece_ack = flag & FLAG_ECE;
3040         bool do_lost = num_dupack || ((flag & FLAG_DATA_SACKED) &&
3041                                       tcp_force_fast_retransmit(sk));
3042
3043         if (!tp->packets_out && tp->sacked_out)
3044                 tp->sacked_out = 0;
3045
3046         /* Now state machine starts.
3047          * A. ECE, hence prohibit cwnd undoing, the reduction is required. */
3048         if (ece_ack)
3049                 tp->prior_ssthresh = 0;
3050
3051         /* B. In all the states check for reneging SACKs. */
3052         if (tcp_check_sack_reneging(sk, ack_flag))
3053                 return;
3054
3055         /* C. Check consistency of the current state. */
3056         tcp_verify_left_out(tp);
3057
3058         /* D. Check state exit conditions. State can be terminated
3059          *    when high_seq is ACKed. */
3060         if (icsk->icsk_ca_state == TCP_CA_Open) {
3061                 WARN_ON(tp->retrans_out != 0 && !tp->syn_data);
3062                 tp->retrans_stamp = 0;
3063         } else if (!before(tp->snd_una, tp->high_seq)) {
3064                 switch (icsk->icsk_ca_state) {
3065                 case TCP_CA_CWR:
3066                         /* CWR is to be held something *above* high_seq
3067                          * is ACKed for CWR bit to reach receiver. */
3068                         if (tp->snd_una != tp->high_seq) {
3069                                 tcp_end_cwnd_reduction(sk);
3070                                 tcp_set_ca_state(sk, TCP_CA_Open);
3071                         }
3072                         break;
3073
3074                 case TCP_CA_Recovery:
3075                         if (tcp_is_reno(tp))
3076                                 tcp_reset_reno_sack(tp);
3077                         if (tcp_try_undo_recovery(sk))
3078                                 return;
3079                         tcp_end_cwnd_reduction(sk);
3080                         break;
3081                 }
3082         }
3083
3084         /* E. Process state. */
3085         switch (icsk->icsk_ca_state) {
3086         case TCP_CA_Recovery:
3087                 if (!(flag & FLAG_SND_UNA_ADVANCED)) {
3088                         if (tcp_is_reno(tp))
3089                                 tcp_add_reno_sack(sk, num_dupack, ece_ack);
3090                 } else if (tcp_try_undo_partial(sk, prior_snd_una, &do_lost))
3091                         return;
3092
3093                 if (tcp_try_undo_dsack(sk))
3094                         tcp_try_to_open(sk, flag);
3095
3096                 tcp_identify_packet_loss(sk, ack_flag);
3097                 if (icsk->icsk_ca_state != TCP_CA_Recovery) {
3098                         if (!tcp_time_to_recover(sk, flag))
3099                                 return;
3100                         /* Undo reverts the recovery state. If loss is evident,
3101                          * starts a new recovery (e.g. reordering then loss);
3102                          */
3103                         tcp_enter_recovery(sk, ece_ack);
3104                 }
3105                 break;
3106         case TCP_CA_Loss:
3107                 tcp_process_loss(sk, flag, num_dupack, rexmit);
3108                 if (icsk->icsk_ca_state != TCP_CA_Loss)
3109                         tcp_update_rto_time(tp);
3110                 tcp_identify_packet_loss(sk, ack_flag);
3111                 if (!(icsk->icsk_ca_state == TCP_CA_Open ||
3112                       (*ack_flag & FLAG_LOST_RETRANS)))
3113                         return;
3114                 /* Change state if cwnd is undone or retransmits are lost */
3115                 fallthrough;
3116         default:
3117                 if (tcp_is_reno(tp)) {
3118                         if (flag & FLAG_SND_UNA_ADVANCED)
3119                                 tcp_reset_reno_sack(tp);
3120                         tcp_add_reno_sack(sk, num_dupack, ece_ack);
3121                 }
3122
3123                 if (icsk->icsk_ca_state <= TCP_CA_Disorder)
3124                         tcp_try_undo_dsack(sk);
3125
3126                 tcp_identify_packet_loss(sk, ack_flag);
3127                 if (!tcp_time_to_recover(sk, flag)) {
3128                         tcp_try_to_open(sk, flag);
3129                         return;
3130                 }
3131
3132                 /* MTU probe failure: don't reduce cwnd */
3133                 if (icsk->icsk_ca_state < TCP_CA_CWR &&
3134                     icsk->icsk_mtup.probe_size &&
3135                     tp->snd_una == tp->mtu_probe.probe_seq_start) {
3136                         tcp_mtup_probe_failed(sk);
3137                         /* Restores the reduction we did in tcp_mtup_probe() */
3138                         tcp_snd_cwnd_set(tp, tcp_snd_cwnd(tp) + 1);
3139                         tcp_simple_retransmit(sk);
3140                         return;
3141                 }
3142
3143                 /* Otherwise enter Recovery state */
3144                 tcp_enter_recovery(sk, ece_ack);
3145                 fast_rexmit = 1;
3146         }
3147
3148         if (!tcp_is_rack(sk) && do_lost)
3149                 tcp_update_scoreboard(sk, fast_rexmit);
3150         *rexmit = REXMIT_LOST;
3151 }
3152
3153 static void tcp_update_rtt_min(struct sock *sk, u32 rtt_us, const int flag)
3154 {
3155         u32 wlen = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_min_rtt_wlen) * HZ;
3156         struct tcp_sock *tp = tcp_sk(sk);
3157
3158         if ((flag & FLAG_ACK_MAYBE_DELAYED) && rtt_us > tcp_min_rtt(tp)) {
3159                 /* If the remote keeps returning delayed ACKs, eventually
3160                  * the min filter would pick it up and overestimate the
3161                  * prop. delay when it expires. Skip suspected delayed ACKs.
3162                  */
3163                 return;
3164         }
3165         minmax_running_min(&tp->rtt_min, wlen, tcp_jiffies32,
3166                            rtt_us ? : jiffies_to_usecs(1));
3167 }
3168
3169 static bool tcp_ack_update_rtt(struct sock *sk, const int flag,
3170                                long seq_rtt_us, long sack_rtt_us,
3171                                long ca_rtt_us, struct rate_sample *rs)
3172 {
3173         const struct tcp_sock *tp = tcp_sk(sk);
3174
3175         /* Prefer RTT measured from ACK's timing to TS-ECR. This is because
3176          * broken middle-boxes or peers may corrupt TS-ECR fields. But
3177          * Karn's algorithm forbids taking RTT if some retransmitted data
3178          * is acked (RFC6298).
3179          */
3180         if (seq_rtt_us < 0)
3181                 seq_rtt_us = sack_rtt_us;
3182
3183         /* RTTM Rule: A TSecr value received in a segment is used to
3184          * update the averaged RTT measurement only if the segment
3185          * acknowledges some new data, i.e., only if it advances the
3186          * left edge of the send window.
3187          * See draft-ietf-tcplw-high-performance-00, section 3.3.
3188          */
3189         if (seq_rtt_us < 0 && tp->rx_opt.saw_tstamp &&
3190             tp->rx_opt.rcv_tsecr && flag & FLAG_ACKED)
3191                 seq_rtt_us = ca_rtt_us = tcp_rtt_tsopt_us(tp);
3192
3193         rs->rtt_us = ca_rtt_us; /* RTT of last (S)ACKed packet (or -1) */
3194         if (seq_rtt_us < 0)
3195                 return false;
3196
3197         /* ca_rtt_us >= 0 is counting on the invariant that ca_rtt_us is
3198          * always taken together with ACK, SACK, or TS-opts. Any negative
3199          * values will be skipped with the seq_rtt_us < 0 check above.
3200          */
3201         tcp_update_rtt_min(sk, ca_rtt_us, flag);
3202         tcp_rtt_estimator(sk, seq_rtt_us);
3203         tcp_set_rto(sk);
3204
3205         /* RFC6298: only reset backoff on valid RTT measurement. */
3206         inet_csk(sk)->icsk_backoff = 0;
3207         return true;
3208 }
3209
3210 /* Compute time elapsed between (last) SYNACK and the ACK completing 3WHS. */
3211 void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req)
3212 {
3213         struct rate_sample rs;
3214         long rtt_us = -1L;
3215
3216         if (req && !req->num_retrans && tcp_rsk(req)->snt_synack)
3217                 rtt_us = tcp_stamp_us_delta(tcp_clock_us(), tcp_rsk(req)->snt_synack);
3218
3219         tcp_ack_update_rtt(sk, FLAG_SYN_ACKED, rtt_us, -1L, rtt_us, &rs);
3220 }
3221
3222
3223 static void tcp_cong_avoid(struct sock *sk, u32 ack, u32 acked)
3224 {
3225         const struct inet_connection_sock *icsk = inet_csk(sk);
3226
3227         icsk->icsk_ca_ops->cong_avoid(sk, ack, acked);
3228         tcp_sk(sk)->snd_cwnd_stamp = tcp_jiffies32;
3229 }
3230
3231 /* Restart timer after forward progress on connection.
3232  * RFC2988 recommends to restart timer to now+rto.
3233  */
3234 void tcp_rearm_rto(struct sock *sk)
3235 {
3236         const struct inet_connection_sock *icsk = inet_csk(sk);
3237         struct tcp_sock *tp = tcp_sk(sk);
3238
3239         /* If the retrans timer is currently being used by Fast Open
3240          * for SYN-ACK retrans purpose, stay put.
3241          */
3242         if (rcu_access_pointer(tp->fastopen_rsk))
3243                 return;
3244
3245         if (!tp->packets_out) {
3246                 inet_csk_clear_xmit_timer(sk, ICSK_TIME_RETRANS);
3247         } else {
3248                 u32 rto = inet_csk(sk)->icsk_rto;
3249                 /* Offset the time elapsed after installing regular RTO */
3250                 if (icsk->icsk_pending == ICSK_TIME_REO_TIMEOUT ||
3251                     icsk->icsk_pending == ICSK_TIME_LOSS_PROBE) {
3252                         s64 delta_us = tcp_rto_delta_us(sk);
3253                         /* delta_us may not be positive if the socket is locked
3254                          * when the retrans timer fires and is rescheduled.
3255                          */
3256                         rto = usecs_to_jiffies(max_t(int, delta_us, 1));
3257                 }
3258                 tcp_reset_xmit_timer(sk, ICSK_TIME_RETRANS, rto,
3259                                      TCP_RTO_MAX);
3260         }
3261 }
3262
3263 /* Try to schedule a loss probe; if that doesn't work, then schedule an RTO. */
3264 static void tcp_set_xmit_timer(struct sock *sk)
3265 {
3266         if (!tcp_schedule_loss_probe(sk, true))
3267                 tcp_rearm_rto(sk);
3268 }
3269
3270 /* If we get here, the whole TSO packet has not been acked. */
3271 static u32 tcp_tso_acked(struct sock *sk, struct sk_buff *skb)
3272 {
3273         struct tcp_sock *tp = tcp_sk(sk);
3274         u32 packets_acked;
3275
3276         BUG_ON(!after(TCP_SKB_CB(skb)->end_seq, tp->snd_una));
3277
3278         packets_acked = tcp_skb_pcount(skb);
3279         if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
3280                 return 0;
3281         packets_acked -= tcp_skb_pcount(skb);
3282
3283         if (packets_acked) {
3284                 BUG_ON(tcp_skb_pcount(skb) == 0);
3285                 BUG_ON(!before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq));
3286         }
3287
3288         return packets_acked;
3289 }
3290
3291 static void tcp_ack_tstamp(struct sock *sk, struct sk_buff *skb,
3292                            const struct sk_buff *ack_skb, u32 prior_snd_una)
3293 {
3294         const struct skb_shared_info *shinfo;
3295
3296         /* Avoid cache line misses to get skb_shinfo() and shinfo->tx_flags */
3297         if (likely(!TCP_SKB_CB(skb)->txstamp_ack))
3298                 return;
3299
3300         shinfo = skb_shinfo(skb);
3301         if (!before(shinfo->tskey, prior_snd_una) &&
3302             before(shinfo->tskey, tcp_sk(sk)->snd_una)) {
3303                 tcp_skb_tsorted_save(skb) {
3304                         __skb_tstamp_tx(skb, ack_skb, NULL, sk, SCM_TSTAMP_ACK);
3305                 } tcp_skb_tsorted_restore(skb);
3306         }
3307 }
3308
3309 /* Remove acknowledged frames from the retransmission queue. If our packet
3310  * is before the ack sequence we can discard it as it's confirmed to have
3311  * arrived at the other end.
3312  */
3313 static int tcp_clean_rtx_queue(struct sock *sk, const struct sk_buff *ack_skb,
3314                                u32 prior_fack, u32 prior_snd_una,
3315                                struct tcp_sacktag_state *sack, bool ece_ack)
3316 {
3317         const struct inet_connection_sock *icsk = inet_csk(sk);
3318         u64 first_ackt, last_ackt;
3319         struct tcp_sock *tp = tcp_sk(sk);
3320         u32 prior_sacked = tp->sacked_out;
3321         u32 reord = tp->snd_nxt; /* lowest acked un-retx un-sacked seq */
3322         struct sk_buff *skb, *next;
3323         bool fully_acked = true;
3324         long sack_rtt_us = -1L;
3325         long seq_rtt_us = -1L;
3326         long ca_rtt_us = -1L;
3327         u32 pkts_acked = 0;
3328         bool rtt_update;
3329         int flag = 0;
3330
3331         first_ackt = 0;
3332
3333         for (skb = skb_rb_first(&sk->tcp_rtx_queue); skb; skb = next) {
3334                 struct tcp_skb_cb *scb = TCP_SKB_CB(skb);
3335                 const u32 start_seq = scb->seq;
3336                 u8 sacked = scb->sacked;
3337                 u32 acked_pcount;
3338
3339                 /* Determine how many packets and what bytes were acked, tso and else */
3340                 if (after(scb->end_seq, tp->snd_una)) {
3341                         if (tcp_skb_pcount(skb) == 1 ||
3342                             !after(tp->snd_una, scb->seq))
3343                                 break;
3344
3345                         acked_pcount = tcp_tso_acked(sk, skb);
3346                         if (!acked_pcount)
3347                                 break;
3348                         fully_acked = false;
3349                 } else {
3350                         acked_pcount = tcp_skb_pcount(skb);
3351                 }
3352
3353                 if (unlikely(sacked & TCPCB_RETRANS)) {
3354                         if (sacked & TCPCB_SACKED_RETRANS)
3355                                 tp->retrans_out -= acked_pcount;
3356                         flag |= FLAG_RETRANS_DATA_ACKED;
3357                 } else if (!(sacked & TCPCB_SACKED_ACKED)) {
3358                         last_ackt = tcp_skb_timestamp_us(skb);
3359                         WARN_ON_ONCE(last_ackt == 0);
3360                         if (!first_ackt)
3361                                 first_ackt = last_ackt;
3362
3363                         if (before(start_seq, reord))
3364                                 reord = start_seq;
3365                         if (!after(scb->end_seq, tp->high_seq))
3366                                 flag |= FLAG_ORIG_SACK_ACKED;
3367                 }
3368
3369                 if (sacked & TCPCB_SACKED_ACKED) {
3370                         tp->sacked_out -= acked_pcount;
3371                 } else if (tcp_is_sack(tp)) {
3372                         tcp_count_delivered(tp, acked_pcount, ece_ack);
3373                         if (!tcp_skb_spurious_retrans(tp, skb))
3374                                 tcp_rack_advance(tp, sacked, scb->end_seq,
3375                                                  tcp_skb_timestamp_us(skb));
3376                 }
3377                 if (sacked & TCPCB_LOST)
3378                         tp->lost_out -= acked_pcount;
3379
3380                 tp->packets_out -= acked_pcount;
3381                 pkts_acked += acked_pcount;
3382                 tcp_rate_skb_delivered(sk, skb, sack->rate);
3383
3384                 /* Initial outgoing SYN's get put onto the write_queue
3385                  * just like anything else we transmit.  It is not
3386                  * true data, and if we misinform our callers that
3387                  * this ACK acks real data, we will erroneously exit
3388                  * connection startup slow start one packet too
3389                  * quickly.  This is severely frowned upon behavior.
3390                  */
3391                 if (likely(!(scb->tcp_flags & TCPHDR_SYN))) {
3392                         flag |= FLAG_DATA_ACKED;
3393                 } else {
3394                         flag |= FLAG_SYN_ACKED;
3395                         tp->retrans_stamp = 0;
3396                 }
3397
3398                 if (!fully_acked)
3399                         break;
3400
3401                 tcp_ack_tstamp(sk, skb, ack_skb, prior_snd_una);
3402
3403                 next = skb_rb_next(skb);
3404                 if (unlikely(skb == tp->retransmit_skb_hint))
3405                         tp->retransmit_skb_hint = NULL;
3406                 if (unlikely(skb == tp->lost_skb_hint))
3407                         tp->lost_skb_hint = NULL;
3408                 tcp_highest_sack_replace(sk, skb, next);
3409                 tcp_rtx_queue_unlink_and_free(skb, sk);
3410         }
3411
3412         if (!skb)
3413                 tcp_chrono_stop(sk, TCP_CHRONO_BUSY);
3414
3415         if (likely(between(tp->snd_up, prior_snd_una, tp->snd_una)))
3416                 tp->snd_up = tp->snd_una;
3417
3418         if (skb) {
3419                 tcp_ack_tstamp(sk, skb, ack_skb, prior_snd_una);
3420                 if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
3421                         flag |= FLAG_SACK_RENEGING;
3422         }
3423
3424         if (likely(first_ackt) && !(flag & FLAG_RETRANS_DATA_ACKED)) {
3425                 seq_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, first_ackt);
3426                 ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, last_ackt);
3427
3428                 if (pkts_acked == 1 && fully_acked && !prior_sacked &&
3429                     (tp->snd_una - prior_snd_una) < tp->mss_cache &&
3430                     sack->rate->prior_delivered + 1 == tp->delivered &&
3431                     !(flag & (FLAG_CA_ALERT | FLAG_SYN_ACKED))) {
3432                         /* Conservatively mark a delayed ACK. It's typically
3433                          * from a lone runt packet over the round trip to
3434                          * a receiver w/o out-of-order or CE events.
3435                          */
3436                         flag |= FLAG_ACK_MAYBE_DELAYED;
3437                 }
3438         }
3439         if (sack->first_sackt) {
3440                 sack_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, sack->first_sackt);
3441                 ca_rtt_us = tcp_stamp_us_delta(tp->tcp_mstamp, sack->last_sackt);
3442         }
3443         rtt_update = tcp_ack_update_rtt(sk, flag, seq_rtt_us, sack_rtt_us,
3444                                         ca_rtt_us, sack->rate);
3445
3446         if (flag & FLAG_ACKED) {
3447                 flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
3448                 if (unlikely(icsk->icsk_mtup.probe_size &&
3449                              !after(tp->mtu_probe.probe_seq_end, tp->snd_una))) {
3450                         tcp_mtup_probe_success(sk);
3451                 }
3452
3453                 if (tcp_is_reno(tp)) {
3454                         tcp_remove_reno_sacks(sk, pkts_acked, ece_ack);
3455
3456                         /* If any of the cumulatively ACKed segments was
3457                          * retransmitted, non-SACK case cannot confirm that
3458                          * progress was due to original transmission due to
3459                          * lack of TCPCB_SACKED_ACKED bits even if some of
3460                          * the packets may have been never retransmitted.
3461                          */
3462                         if (flag & FLAG_RETRANS_DATA_ACKED)
3463                                 flag &= ~FLAG_ORIG_SACK_ACKED;
3464                 } else {
3465                         int delta;
3466
3467                         /* Non-retransmitted hole got filled? That's reordering */
3468                         if (before(reord, prior_fack))
3469                                 tcp_check_sack_reordering(sk, reord, 0);
3470
3471                         delta = prior_sacked - tp->sacked_out;
3472                         tp->lost_cnt_hint -= min(tp->lost_cnt_hint, delta);
3473                 }
3474         } else if (skb && rtt_update && sack_rtt_us >= 0 &&
3475                    sack_rtt_us > tcp_stamp_us_delta(tp->tcp_mstamp,
3476                                                     tcp_skb_timestamp_us(skb))) {
3477                 /* Do not re-arm RTO if the sack RTT is measured from data sent
3478                  * after when the head was last (re)transmitted. Otherwise the
3479                  * timeout may continue to extend in loss recovery.
3480                  */
3481                 flag |= FLAG_SET_XMIT_TIMER;  /* set TLP or RTO timer */
3482         }
3483
3484         if (icsk->icsk_ca_ops->pkts_acked) {
3485                 struct ack_sample sample = { .pkts_acked = pkts_acked,
3486                                              .rtt_us = sack->rate->rtt_us };
3487
3488                 sample.in_flight = tp->mss_cache *
3489                         (tp->delivered - sack->rate->prior_delivered);
3490                 icsk->icsk_ca_ops->pkts_acked(sk, &sample);
3491         }
3492
3493 #if FASTRETRANS_DEBUG > 0
3494         WARN_ON((int)tp->sacked_out < 0);
3495         WARN_ON((int)tp->lost_out < 0);
3496         WARN_ON((int)tp->retrans_out < 0);
3497         if (!tp->packets_out && tcp_is_sack(tp)) {
3498                 icsk = inet_csk(sk);
3499                 if (tp->lost_out) {
3500                         pr_debug("Leak l=%u %d\n",
3501                                  tp->lost_out, icsk->icsk_ca_state);
3502                         tp->lost_out = 0;
3503                 }
3504                 if (tp->sacked_out) {
3505                         pr_debug("Leak s=%u %d\n",
3506                                  tp->sacked_out, icsk->icsk_ca_state);
3507                         tp->sacked_out = 0;
3508                 }
3509                 if (tp->retrans_out) {
3510                         pr_debug("Leak r=%u %d\n",
3511                                  tp->retrans_out, icsk->icsk_ca_state);
3512                         tp->retrans_out = 0;
3513                 }
3514         }
3515 #endif
3516         return flag;
3517 }
3518
3519 static void tcp_ack_probe(struct sock *sk)
3520 {
3521         struct inet_connection_sock *icsk = inet_csk(sk);
3522         struct sk_buff *head = tcp_send_head(sk);
3523         const struct tcp_sock *tp = tcp_sk(sk);
3524
3525         /* Was it a usable window open? */
3526         if (!head)
3527                 return;
3528         if (!after(TCP_SKB_CB(head)->end_seq, tcp_wnd_end(tp))) {
3529                 icsk->icsk_backoff = 0;
3530                 icsk->icsk_probes_tstamp = 0;
3531                 inet_csk_clear_xmit_timer(sk, ICSK_TIME_PROBE0);
3532                 /* Socket must be waked up by subsequent tcp_data_snd_check().
3533                  * This function is not for random using!
3534                  */
3535         } else {
3536                 unsigned long when = tcp_probe0_when(sk, TCP_RTO_MAX);
3537
3538                 when = tcp_clamp_probe0_to_user_timeout(sk, when);
3539                 tcp_reset_xmit_timer(sk, ICSK_TIME_PROBE0, when, TCP_RTO_MAX);
3540         }
3541 }
3542
3543 static inline bool tcp_ack_is_dubious(const struct sock *sk, const int flag)
3544 {
3545         return !(flag & FLAG_NOT_DUP) || (flag & FLAG_CA_ALERT) ||
3546                 inet_csk(sk)->icsk_ca_state != TCP_CA_Open;
3547 }
3548
3549 /* Decide wheather to run the increase function of congestion control. */
3550 static inline bool tcp_may_raise_cwnd(const struct sock *sk, const int flag)
3551 {
3552         /* If reordering is high then always grow cwnd whenever data is
3553          * delivered regardless of its ordering. Otherwise stay conservative
3554          * and only grow cwnd on in-order delivery (RFC5681). A stretched ACK w/
3555          * new SACK or ECE mark may first advance cwnd here and later reduce
3556          * cwnd in tcp_fastretrans_alert() based on more states.
3557          */
3558         if (tcp_sk(sk)->reordering >
3559             READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_reordering))
3560                 return flag & FLAG_FORWARD_PROGRESS;
3561
3562         return flag & FLAG_DATA_ACKED;
3563 }
3564
3565 /* The "ultimate" congestion control function that aims to replace the rigid
3566  * cwnd increase and decrease control (tcp_cong_avoid,tcp_*cwnd_reduction).
3567  * It's called toward the end of processing an ACK with precise rate
3568  * information. All transmission or retransmission are delayed afterwards.
3569  */
3570 static void tcp_cong_control(struct sock *sk, u32 ack, u32 acked_sacked,
3571                              int flag, const struct rate_sample *rs)
3572 {
3573         const struct inet_connection_sock *icsk = inet_csk(sk);
3574
3575         if (icsk->icsk_ca_ops->cong_control) {
3576                 icsk->icsk_ca_ops->cong_control(sk, ack, flag, rs);
3577                 return;
3578         }
3579
3580         if (tcp_in_cwnd_reduction(sk)) {
3581                 /* Reduce cwnd if state mandates */
3582                 tcp_cwnd_reduction(sk, acked_sacked, rs->losses, flag);
3583         } else if (tcp_may_raise_cwnd(sk, flag)) {
3584                 /* Advance cwnd if state allows */
3585                 tcp_cong_avoid(sk, ack, acked_sacked);
3586         }
3587         tcp_update_pacing_rate(sk);
3588 }
3589
3590 /* Check that window update is acceptable.
3591  * The function assumes that snd_una<=ack<=snd_next.
3592  */
3593 static inline bool tcp_may_update_window(const struct tcp_sock *tp,
3594                                         const u32 ack, const u32 ack_seq,
3595                                         const u32 nwin)
3596 {
3597         return  after(ack, tp->snd_una) ||
3598                 after(ack_seq, tp->snd_wl1) ||
3599                 (ack_seq == tp->snd_wl1 && (nwin > tp->snd_wnd || !nwin));
3600 }
3601
3602 static void tcp_snd_sne_update(struct tcp_sock *tp, u32 ack)
3603 {
3604 #ifdef CONFIG_TCP_AO
3605         struct tcp_ao_info *ao;
3606
3607         if (!static_branch_unlikely(&tcp_ao_needed.key))
3608                 return;
3609
3610         ao = rcu_dereference_protected(tp->ao_info,
3611                                        lockdep_sock_is_held((struct sock *)tp));
3612         if (ao && ack < tp->snd_una) {
3613                 ao->snd_sne++;
3614                 trace_tcp_ao_snd_sne_update((struct sock *)tp, ao->snd_sne);
3615         }
3616 #endif
3617 }
3618
3619 /* If we update tp->snd_una, also update tp->bytes_acked */
3620 static void tcp_snd_una_update(struct tcp_sock *tp, u32 ack)
3621 {
3622         u32 delta = ack - tp->snd_una;
3623
3624         sock_owned_by_me((struct sock *)tp);
3625         tp->bytes_acked += delta;
3626         tcp_snd_sne_update(tp, ack);
3627         tp->snd_una = ack;
3628 }
3629
3630 static void tcp_rcv_sne_update(struct tcp_sock *tp, u32 seq)
3631 {
3632 #ifdef CONFIG_TCP_AO
3633         struct tcp_ao_info *ao;
3634
3635         if (!static_branch_unlikely(&tcp_ao_needed.key))
3636                 return;
3637
3638         ao = rcu_dereference_protected(tp->ao_info,
3639                                        lockdep_sock_is_held((struct sock *)tp));
3640         if (ao && seq < tp->rcv_nxt) {
3641                 ao->rcv_sne++;
3642                 trace_tcp_ao_rcv_sne_update((struct sock *)tp, ao->rcv_sne);
3643         }
3644 #endif
3645 }
3646
3647 /* If we update tp->rcv_nxt, also update tp->bytes_received */
3648 static void tcp_rcv_nxt_update(struct tcp_sock *tp, u32 seq)
3649 {
3650         u32 delta = seq - tp->rcv_nxt;
3651
3652         sock_owned_by_me((struct sock *)tp);
3653         tp->bytes_received += delta;
3654         tcp_rcv_sne_update(tp, seq);
3655         WRITE_ONCE(tp->rcv_nxt, seq);
3656 }
3657
3658 /* Update our send window.
3659  *
3660  * Window update algorithm, described in RFC793/RFC1122 (used in linux-2.2
3661  * and in FreeBSD. NetBSD's one is even worse.) is wrong.
3662  */
3663 static int tcp_ack_update_window(struct sock *sk, const struct sk_buff *skb, u32 ack,
3664                                  u32 ack_seq)
3665 {
3666         struct tcp_sock *tp = tcp_sk(sk);
3667         int flag = 0;
3668         u32 nwin = ntohs(tcp_hdr(skb)->window);
3669
3670         if (likely(!tcp_hdr(skb)->syn))
3671                 nwin <<= tp->rx_opt.snd_wscale;
3672
3673         if (tcp_may_update_window(tp, ack, ack_seq, nwin)) {
3674                 flag |= FLAG_WIN_UPDATE;
3675                 tcp_update_wl(tp, ack_seq);
3676
3677                 if (tp->snd_wnd != nwin) {
3678                         tp->snd_wnd = nwin;
3679
3680                         /* Note, it is the only place, where
3681                          * fast path is recovered for sending TCP.
3682                          */
3683                         tp->pred_flags = 0;
3684                         tcp_fast_path_check(sk);
3685
3686                         if (!tcp_write_queue_empty(sk))
3687                                 tcp_slow_start_after_idle_check(sk);
3688
3689                         if (nwin > tp->max_window) {
3690                                 tp->max_window = nwin;
3691                                 tcp_sync_mss(sk, inet_csk(sk)->icsk_pmtu_cookie);
3692                         }
3693                 }
3694         }
3695
3696         tcp_snd_una_update(tp, ack);
3697
3698         return flag;
3699 }
3700
3701 static bool __tcp_oow_rate_limited(struct net *net, int mib_idx,
3702                                    u32 *last_oow_ack_time)
3703 {
3704         /* Paired with the WRITE_ONCE() in this function. */
3705         u32 val = READ_ONCE(*last_oow_ack_time);
3706
3707         if (val) {
3708                 s32 elapsed = (s32)(tcp_jiffies32 - val);
3709
3710                 if (0 <= elapsed &&
3711                     elapsed < READ_ONCE(net->ipv4.sysctl_tcp_invalid_ratelimit)) {
3712                         NET_INC_STATS(net, mib_idx);
3713                         return true;    /* rate-limited: don't send yet! */
3714                 }
3715         }
3716
3717         /* Paired with the prior READ_ONCE() and with itself,
3718          * as we might be lockless.
3719          */
3720         WRITE_ONCE(*last_oow_ack_time, tcp_jiffies32);
3721
3722         return false;   /* not rate-limited: go ahead, send dupack now! */
3723 }
3724
3725 /* Return true if we're currently rate-limiting out-of-window ACKs and
3726  * thus shouldn't send a dupack right now. We rate-limit dupacks in
3727  * response to out-of-window SYNs or ACKs to mitigate ACK loops or DoS
3728  * attacks that send repeated SYNs or ACKs for the same connection. To
3729  * do this, we do not send a duplicate SYNACK or ACK if the remote
3730  * endpoint is sending out-of-window SYNs or pure ACKs at a high rate.
3731  */
3732 bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,
3733                           int mib_idx, u32 *last_oow_ack_time)
3734 {
3735         /* Data packets without SYNs are not likely part of an ACK loop. */
3736         if ((TCP_SKB_CB(skb)->seq != TCP_SKB_CB(skb)->end_seq) &&
3737             !tcp_hdr(skb)->syn)
3738                 return false;
3739
3740         return __tcp_oow_rate_limited(net, mib_idx, last_oow_ack_time);
3741 }
3742
3743 /* RFC 5961 7 [ACK Throttling] */
3744 static void tcp_send_challenge_ack(struct sock *sk)
3745 {
3746         struct tcp_sock *tp = tcp_sk(sk);
3747         struct net *net = sock_net(sk);
3748         u32 count, now, ack_limit;
3749
3750         /* First check our per-socket dupack rate limit. */
3751         if (__tcp_oow_rate_limited(net,
3752                                    LINUX_MIB_TCPACKSKIPPEDCHALLENGE,
3753                                    &tp->last_oow_ack_time))
3754                 return;
3755
3756         ack_limit = READ_ONCE(net->ipv4.sysctl_tcp_challenge_ack_limit);
3757         if (ack_limit == INT_MAX)
3758                 goto send_ack;
3759
3760         /* Then check host-wide RFC 5961 rate limit. */
3761         now = jiffies / HZ;
3762         if (now != READ_ONCE(net->ipv4.tcp_challenge_timestamp)) {
3763                 u32 half = (ack_limit + 1) >> 1;
3764
3765                 WRITE_ONCE(net->ipv4.tcp_challenge_timestamp, now);
3766                 WRITE_ONCE(net->ipv4.tcp_challenge_count,
3767                            get_random_u32_inclusive(half, ack_limit + half - 1));
3768         }
3769         count = READ_ONCE(net->ipv4.tcp_challenge_count);
3770         if (count > 0) {
3771                 WRITE_ONCE(net->ipv4.tcp_challenge_count, count - 1);
3772 send_ack:
3773                 NET_INC_STATS(net, LINUX_MIB_TCPCHALLENGEACK);
3774                 tcp_send_ack(sk);
3775         }
3776 }
3777
3778 static void tcp_store_ts_recent(struct tcp_sock *tp)
3779 {
3780         tp->rx_opt.ts_recent = tp->rx_opt.rcv_tsval;
3781         tp->rx_opt.ts_recent_stamp = ktime_get_seconds();
3782 }
3783
3784 static void tcp_replace_ts_recent(struct tcp_sock *tp, u32 seq)
3785 {
3786         if (tp->rx_opt.saw_tstamp && !after(seq, tp->rcv_wup)) {
3787                 /* PAWS bug workaround wrt. ACK frames, the PAWS discard
3788                  * extra check below makes sure this can only happen
3789                  * for pure ACK frames.  -DaveM
3790                  *
3791                  * Not only, also it occurs for expired timestamps.
3792                  */
3793
3794                 if (tcp_paws_check(&tp->rx_opt, 0))
3795                         tcp_store_ts_recent(tp);
3796         }
3797 }
3798
3799 /* This routine deals with acks during a TLP episode and ends an episode by
3800  * resetting tlp_high_seq. Ref: TLP algorithm in draft-ietf-tcpm-rack
3801  */
3802 static void tcp_process_tlp_ack(struct sock *sk, u32 ack, int flag)
3803 {
3804         struct tcp_sock *tp = tcp_sk(sk);
3805
3806         if (before(ack, tp->tlp_high_seq))
3807                 return;
3808
3809         if (!tp->tlp_retrans) {
3810                 /* TLP of new data has been acknowledged */
3811                 tp->tlp_high_seq = 0;
3812         } else if (flag & FLAG_DSACK_TLP) {
3813                 /* This DSACK means original and TLP probe arrived; no loss */
3814                 tp->tlp_high_seq = 0;
3815         } else if (after(ack, tp->tlp_high_seq)) {
3816                 /* ACK advances: there was a loss, so reduce cwnd. Reset
3817                  * tlp_high_seq in tcp_init_cwnd_reduction()
3818                  */
3819                 tcp_init_cwnd_reduction(sk);
3820                 tcp_set_ca_state(sk, TCP_CA_CWR);
3821                 tcp_end_cwnd_reduction(sk);
3822                 tcp_try_keep_open(sk);
3823                 NET_INC_STATS(sock_net(sk),
3824                                 LINUX_MIB_TCPLOSSPROBERECOVERY);
3825         } else if (!(flag & (FLAG_SND_UNA_ADVANCED |
3826                              FLAG_NOT_DUP | FLAG_DATA_SACKED))) {
3827                 /* Pure dupack: original and TLP probe arrived; no loss */
3828                 tp->tlp_high_seq = 0;
3829         }
3830 }
3831
3832 static inline void tcp_in_ack_event(struct sock *sk, u32 flags)
3833 {
3834         const struct inet_connection_sock *icsk = inet_csk(sk);
3835
3836         if (icsk->icsk_ca_ops->in_ack_event)
3837                 icsk->icsk_ca_ops->in_ack_event(sk, flags);
3838 }
3839
3840 /* Congestion control has updated the cwnd already. So if we're in
3841  * loss recovery then now we do any new sends (for FRTO) or
3842  * retransmits (for CA_Loss or CA_recovery) that make sense.
3843  */
3844 static void tcp_xmit_recovery(struct sock *sk, int rexmit)
3845 {
3846         struct tcp_sock *tp = tcp_sk(sk);
3847
3848         if (rexmit == REXMIT_NONE || sk->sk_state == TCP_SYN_SENT)
3849                 return;
3850
3851         if (unlikely(rexmit == REXMIT_NEW)) {
3852                 __tcp_push_pending_frames(sk, tcp_current_mss(sk),
3853                                           TCP_NAGLE_OFF);
3854                 if (after(tp->snd_nxt, tp->high_seq))
3855                         return;
3856                 tp->frto = 0;
3857         }
3858         tcp_xmit_retransmit_queue(sk);
3859 }
3860
3861 /* Returns the number of packets newly acked or sacked by the current ACK */
3862 static u32 tcp_newly_delivered(struct sock *sk, u32 prior_delivered, int flag)
3863 {
3864         const struct net *net = sock_net(sk);
3865         struct tcp_sock *tp = tcp_sk(sk);
3866         u32 delivered;
3867
3868         delivered = tp->delivered - prior_delivered;
3869         NET_ADD_STATS(net, LINUX_MIB_TCPDELIVERED, delivered);
3870         if (flag & FLAG_ECE)
3871                 NET_ADD_STATS(net, LINUX_MIB_TCPDELIVEREDCE, delivered);
3872
3873         return delivered;
3874 }
3875
3876 /* This routine deals with incoming acks, but not outgoing ones. */
3877 static int tcp_ack(struct sock *sk, const struct sk_buff *skb, int flag)
3878 {
3879         struct inet_connection_sock *icsk = inet_csk(sk);
3880         struct tcp_sock *tp = tcp_sk(sk);
3881         struct tcp_sacktag_state sack_state;
3882         struct rate_sample rs = { .prior_delivered = 0 };
3883         u32 prior_snd_una = tp->snd_una;
3884         bool is_sack_reneg = tp->is_sack_reneg;
3885         u32 ack_seq = TCP_SKB_CB(skb)->seq;
3886         u32 ack = TCP_SKB_CB(skb)->ack_seq;
3887         int num_dupack = 0;
3888         int prior_packets = tp->packets_out;
3889         u32 delivered = tp->delivered;
3890         u32 lost = tp->lost;
3891         int rexmit = REXMIT_NONE; /* Flag to (re)transmit to recover losses */
3892         u32 prior_fack;
3893
3894         sack_state.first_sackt = 0;
3895         sack_state.rate = &rs;
3896         sack_state.sack_delivered = 0;
3897
3898         /* We very likely will need to access rtx queue. */
3899         prefetch(sk->tcp_rtx_queue.rb_node);
3900
3901         /* If the ack is older than previous acks
3902          * then we can probably ignore it.
3903          */
3904         if (before(ack, prior_snd_una)) {
3905                 u32 max_window;
3906
3907                 /* do not accept ACK for bytes we never sent. */
3908                 max_window = min_t(u64, tp->max_window, tp->bytes_acked);
3909                 /* RFC 5961 5.2 [Blind Data Injection Attack].[Mitigation] */
3910                 if (before(ack, prior_snd_una - max_window)) {
3911                         if (!(flag & FLAG_NO_CHALLENGE_ACK))
3912                                 tcp_send_challenge_ack(sk);
3913                         return -SKB_DROP_REASON_TCP_TOO_OLD_ACK;
3914                 }
3915                 goto old_ack;
3916         }
3917
3918         /* If the ack includes data we haven't sent yet, discard
3919          * this segment (RFC793 Section 3.9).
3920          */
3921         if (after(ack, tp->snd_nxt))
3922                 return -SKB_DROP_REASON_TCP_ACK_UNSENT_DATA;
3923
3924         if (after(ack, prior_snd_una)) {
3925                 flag |= FLAG_SND_UNA_ADVANCED;
3926                 icsk->icsk_retransmits = 0;
3927
3928 #if IS_ENABLED(CONFIG_TLS_DEVICE)
3929                 if (static_branch_unlikely(&clean_acked_data_enabled.key))
3930                         if (icsk->icsk_clean_acked)
3931                                 icsk->icsk_clean_acked(sk, ack);
3932 #endif
3933         }
3934
3935         prior_fack = tcp_is_sack(tp) ? tcp_highest_sack_seq(tp) : tp->snd_una;
3936         rs.prior_in_flight = tcp_packets_in_flight(tp);
3937
3938         /* ts_recent update must be made after we are sure that the packet
3939          * is in window.
3940          */
3941         if (flag & FLAG_UPDATE_TS_RECENT)
3942                 tcp_replace_ts_recent(tp, TCP_SKB_CB(skb)->seq);
3943
3944         if ((flag & (FLAG_SLOWPATH | FLAG_SND_UNA_ADVANCED)) ==
3945             FLAG_SND_UNA_ADVANCED) {
3946                 /* Window is constant, pure forward advance.
3947                  * No more checks are required.
3948                  * Note, we use the fact that SND.UNA>=SND.WL2.
3949                  */
3950                 tcp_update_wl(tp, ack_seq);
3951                 tcp_snd_una_update(tp, ack);
3952                 flag |= FLAG_WIN_UPDATE;
3953
3954                 tcp_in_ack_event(sk, CA_ACK_WIN_UPDATE);
3955
3956                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPACKS);
3957         } else {
3958                 u32 ack_ev_flags = CA_ACK_SLOWPATH;
3959
3960                 if (ack_seq != TCP_SKB_CB(skb)->end_seq)
3961                         flag |= FLAG_DATA;
3962                 else
3963                         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPPUREACKS);
3964
3965                 flag |= tcp_ack_update_window(sk, skb, ack, ack_seq);
3966
3967                 if (TCP_SKB_CB(skb)->sacked)
3968                         flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
3969                                                         &sack_state);
3970
3971                 if (tcp_ecn_rcv_ecn_echo(tp, tcp_hdr(skb))) {
3972                         flag |= FLAG_ECE;
3973                         ack_ev_flags |= CA_ACK_ECE;
3974                 }
3975
3976                 if (sack_state.sack_delivered)
3977                         tcp_count_delivered(tp, sack_state.sack_delivered,
3978                                             flag & FLAG_ECE);
3979
3980                 if (flag & FLAG_WIN_UPDATE)
3981                         ack_ev_flags |= CA_ACK_WIN_UPDATE;
3982
3983                 tcp_in_ack_event(sk, ack_ev_flags);
3984         }
3985
3986         /* This is a deviation from RFC3168 since it states that:
3987          * "When the TCP data sender is ready to set the CWR bit after reducing
3988          * the congestion window, it SHOULD set the CWR bit only on the first
3989          * new data packet that it transmits."
3990          * We accept CWR on pure ACKs to be more robust
3991          * with widely-deployed TCP implementations that do this.
3992          */
3993         tcp_ecn_accept_cwr(sk, skb);
3994
3995         /* We passed data and got it acked, remove any soft error
3996          * log. Something worked...
3997          */
3998         WRITE_ONCE(sk->sk_err_soft, 0);
3999         icsk->icsk_probes_out = 0;
4000         tp->rcv_tstamp = tcp_jiffies32;
4001         if (!prior_packets)
4002                 goto no_queue;
4003
4004         /* See if we can take anything off of the retransmit queue. */
4005         flag |= tcp_clean_rtx_queue(sk, skb, prior_fack, prior_snd_una,
4006                                     &sack_state, flag & FLAG_ECE);
4007
4008         tcp_rack_update_reo_wnd(sk, &rs);
4009
4010         if (tp->tlp_high_seq)
4011                 tcp_process_tlp_ack(sk, ack, flag);
4012
4013         if (tcp_ack_is_dubious(sk, flag)) {
4014                 if (!(flag & (FLAG_SND_UNA_ADVANCED |
4015                               FLAG_NOT_DUP | FLAG_DSACKING_ACK))) {
4016                         num_dupack = 1;
4017                         /* Consider if pure acks were aggregated in tcp_add_backlog() */
4018                         if (!(flag & FLAG_DATA))
4019                                 num_dupack = max_t(u16, 1, skb_shinfo(skb)->gso_segs);
4020                 }
4021                 tcp_fastretrans_alert(sk, prior_snd_una, num_dupack, &flag,
4022                                       &rexmit);
4023         }
4024
4025         /* If needed, reset TLP/RTO timer when RACK doesn't set. */
4026         if (flag & FLAG_SET_XMIT_TIMER)
4027                 tcp_set_xmit_timer(sk);
4028
4029         if ((flag & FLAG_FORWARD_PROGRESS) || !(flag & FLAG_NOT_DUP))
4030                 sk_dst_confirm(sk);
4031
4032         delivered = tcp_newly_delivered(sk, delivered, flag);
4033         lost = tp->lost - lost;                 /* freshly marked lost */
4034         rs.is_ack_delayed = !!(flag & FLAG_ACK_MAYBE_DELAYED);
4035         tcp_rate_gen(sk, delivered, lost, is_sack_reneg, sack_state.rate);
4036         tcp_cong_control(sk, ack, delivered, flag, sack_state.rate);
4037         tcp_xmit_recovery(sk, rexmit);
4038         return 1;
4039
4040 no_queue:
4041         /* If data was DSACKed, see if we can undo a cwnd reduction. */
4042         if (flag & FLAG_DSACKING_ACK) {
4043                 tcp_fastretrans_alert(sk, prior_snd_una, num_dupack, &flag,
4044                                       &rexmit);
4045                 tcp_newly_delivered(sk, delivered, flag);
4046         }
4047         /* If this ack opens up a zero window, clear backoff.  It was
4048          * being used to time the probes, and is probably far higher than
4049          * it needs to be for normal retransmission.
4050          */
4051         tcp_ack_probe(sk);
4052
4053         if (tp->tlp_high_seq)
4054                 tcp_process_tlp_ack(sk, ack, flag);
4055         return 1;
4056
4057 old_ack:
4058         /* If data was SACKed, tag it and see if we should send more data.
4059          * If data was DSACKed, see if we can undo a cwnd reduction.
4060          */
4061         if (TCP_SKB_CB(skb)->sacked) {
4062                 flag |= tcp_sacktag_write_queue(sk, skb, prior_snd_una,
4063                                                 &sack_state);
4064                 tcp_fastretrans_alert(sk, prior_snd_una, num_dupack, &flag,
4065                                       &rexmit);
4066                 tcp_newly_delivered(sk, delivered, flag);
4067                 tcp_xmit_recovery(sk, rexmit);
4068         }
4069
4070         return 0;
4071 }
4072
4073 static void tcp_parse_fastopen_option(int len, const unsigned char *cookie,
4074                                       bool syn, struct tcp_fastopen_cookie *foc,
4075                                       bool exp_opt)
4076 {
4077         /* Valid only in SYN or SYN-ACK with an even length.  */
4078         if (!foc || !syn || len < 0 || (len & 1))
4079                 return;
4080
4081         if (len >= TCP_FASTOPEN_COOKIE_MIN &&
4082             len <= TCP_FASTOPEN_COOKIE_MAX)
4083                 memcpy(foc->val, cookie, len);
4084         else if (len != 0)
4085                 len = -1;
4086         foc->len = len;
4087         foc->exp = exp_opt;
4088 }
4089
4090 static bool smc_parse_options(const struct tcphdr *th,
4091                               struct tcp_options_received *opt_rx,
4092                               const unsigned char *ptr,
4093                               int opsize)
4094 {
4095 #if IS_ENABLED(CONFIG_SMC)
4096         if (static_branch_unlikely(&tcp_have_smc)) {
4097                 if (th->syn && !(opsize & 1) &&
4098                     opsize >= TCPOLEN_EXP_SMC_BASE &&
4099                     get_unaligned_be32(ptr) == TCPOPT_SMC_MAGIC) {
4100                         opt_rx->smc_ok = 1;
4101                         return true;
4102                 }
4103         }
4104 #endif
4105         return false;
4106 }
4107
4108 /* Try to parse the MSS option from the TCP header. Return 0 on failure, clamped
4109  * value on success.
4110  */
4111 u16 tcp_parse_mss_option(const struct tcphdr *th, u16 user_mss)
4112 {
4113         const unsigned char *ptr = (const unsigned char *)(th + 1);
4114         int length = (th->doff * 4) - sizeof(struct tcphdr);
4115         u16 mss = 0;
4116
4117         while (length > 0) {
4118                 int opcode = *ptr++;
4119                 int opsize;
4120
4121                 switch (opcode) {
4122                 case TCPOPT_EOL:
4123                         return mss;
4124                 case TCPOPT_NOP:        /* Ref: RFC 793 section 3.1 */
4125                         length--;
4126                         continue;
4127                 default:
4128                         if (length < 2)
4129                                 return mss;
4130                         opsize = *ptr++;
4131                         if (opsize < 2) /* "silly options" */
4132                                 return mss;
4133                         if (opsize > length)
4134                                 return mss;     /* fail on partial options */
4135                         if (opcode == TCPOPT_MSS && opsize == TCPOLEN_MSS) {
4136                                 u16 in_mss = get_unaligned_be16(ptr);
4137
4138                                 if (in_mss) {
4139                                         if (user_mss && user_mss < in_mss)
4140                                                 in_mss = user_mss;
4141                                         mss = in_mss;
4142                                 }
4143                         }
4144                         ptr += opsize - 2;
4145                         length -= opsize;
4146                 }
4147         }
4148         return mss;
4149 }
4150 EXPORT_SYMBOL_GPL(tcp_parse_mss_option);
4151
4152 /* Look for tcp options. Normally only called on SYN and SYNACK packets.
4153  * But, this can also be called on packets in the established flow when
4154  * the fast version below fails.
4155  */
4156 void tcp_parse_options(const struct net *net,
4157                        const struct sk_buff *skb,
4158                        struct tcp_options_received *opt_rx, int estab,
4159                        struct tcp_fastopen_cookie *foc)
4160 {
4161         const unsigned char *ptr;
4162         const struct tcphdr *th = tcp_hdr(skb);
4163         int length = (th->doff * 4) - sizeof(struct tcphdr);
4164
4165         ptr = (const unsigned char *)(th + 1);
4166         opt_rx->saw_tstamp = 0;
4167         opt_rx->saw_unknown = 0;
4168
4169         while (length > 0) {
4170                 int opcode = *ptr++;
4171                 int opsize;
4172
4173                 switch (opcode) {
4174                 case TCPOPT_EOL:
4175                         return;
4176                 case TCPOPT_NOP:        /* Ref: RFC 793 section 3.1 */
4177                         length--;
4178                         continue;
4179                 default:
4180                         if (length < 2)
4181                                 return;
4182                         opsize = *ptr++;
4183                         if (opsize < 2) /* "silly options" */
4184                                 return;
4185                         if (opsize > length)
4186                                 return; /* don't parse partial options */
4187                         switch (opcode) {
4188                         case TCPOPT_MSS:
4189                                 if (opsize == TCPOLEN_MSS && th->syn && !estab) {
4190                                         u16 in_mss = get_unaligned_be16(ptr);
4191                                         if (in_mss) {
4192                                                 if (opt_rx->user_mss &&
4193                                                     opt_rx->user_mss < in_mss)
4194                                                         in_mss = opt_rx->user_mss;
4195                                                 opt_rx->mss_clamp = in_mss;
4196                                         }
4197                                 }
4198                                 break;
4199                         case TCPOPT_WINDOW:
4200                                 if (opsize == TCPOLEN_WINDOW && th->syn &&
4201                                     !estab && READ_ONCE(net->ipv4.sysctl_tcp_window_scaling)) {
4202                                         __u8 snd_wscale = *(__u8 *)ptr;
4203                                         opt_rx->wscale_ok = 1;
4204                                         if (snd_wscale > TCP_MAX_WSCALE) {
4205                                                 net_info_ratelimited("%s: Illegal window scaling value %d > %u received\n",
4206                                                                      __func__,
4207                                                                      snd_wscale,
4208                                                                      TCP_MAX_WSCALE);
4209                                                 snd_wscale = TCP_MAX_WSCALE;
4210                                         }
4211                                         opt_rx->snd_wscale = snd_wscale;
4212                                 }
4213                                 break;
4214                         case TCPOPT_TIMESTAMP:
4215                                 if ((opsize == TCPOLEN_TIMESTAMP) &&
4216                                     ((estab && opt_rx->tstamp_ok) ||
4217                                      (!estab && READ_ONCE(net->ipv4.sysctl_tcp_timestamps)))) {
4218                                         opt_rx->saw_tstamp = 1;
4219                                         opt_rx->rcv_tsval = get_unaligned_be32(ptr);
4220                                         opt_rx->rcv_tsecr = get_unaligned_be32(ptr + 4);
4221                                 }
4222                                 break;
4223                         case TCPOPT_SACK_PERM:
4224                                 if (opsize == TCPOLEN_SACK_PERM && th->syn &&
4225                                     !estab && READ_ONCE(net->ipv4.sysctl_tcp_sack)) {
4226                                         opt_rx->sack_ok = TCP_SACK_SEEN;
4227                                         tcp_sack_reset(opt_rx);
4228                                 }
4229                                 break;
4230
4231                         case TCPOPT_SACK:
4232                                 if ((opsize >= (TCPOLEN_SACK_BASE + TCPOLEN_SACK_PERBLOCK)) &&
4233                                    !((opsize - TCPOLEN_SACK_BASE) % TCPOLEN_SACK_PERBLOCK) &&
4234                                    opt_rx->sack_ok) {
4235                                         TCP_SKB_CB(skb)->sacked = (ptr - 2) - (unsigned char *)th;
4236                                 }
4237                                 break;
4238 #ifdef CONFIG_TCP_MD5SIG
4239                         case TCPOPT_MD5SIG:
4240                                 /* The MD5 Hash has already been
4241                                  * checked (see tcp_v{4,6}_rcv()).
4242                                  */
4243                                 break;
4244 #endif
4245 #ifdef CONFIG_TCP_AO
4246                         case TCPOPT_AO:
4247                                 /* TCP AO has already been checked
4248                                  * (see tcp_inbound_ao_hash()).
4249                                  */
4250                                 break;
4251 #endif
4252                         case TCPOPT_FASTOPEN:
4253                                 tcp_parse_fastopen_option(
4254                                         opsize - TCPOLEN_FASTOPEN_BASE,
4255                                         ptr, th->syn, foc, false);
4256                                 break;
4257
4258                         case TCPOPT_EXP:
4259                                 /* Fast Open option shares code 254 using a
4260                                  * 16 bits magic number.
4261                                  */
4262                                 if (opsize >= TCPOLEN_EXP_FASTOPEN_BASE &&
4263                                     get_unaligned_be16(ptr) ==
4264                                     TCPOPT_FASTOPEN_MAGIC) {
4265                                         tcp_parse_fastopen_option(opsize -
4266                                                 TCPOLEN_EXP_FASTOPEN_BASE,
4267                                                 ptr + 2, th->syn, foc, true);
4268                                         break;
4269                                 }
4270
4271                                 if (smc_parse_options(th, opt_rx, ptr, opsize))
4272                                         break;
4273
4274                                 opt_rx->saw_unknown = 1;
4275                                 break;
4276
4277                         default:
4278                                 opt_rx->saw_unknown = 1;
4279                         }
4280                         ptr += opsize-2;
4281                         length -= opsize;
4282                 }
4283         }
4284 }
4285 EXPORT_SYMBOL(tcp_parse_options);
4286
4287 static bool tcp_parse_aligned_timestamp(struct tcp_sock *tp, const struct tcphdr *th)
4288 {
4289         const __be32 *ptr = (const __be32 *)(th + 1);
4290
4291         if (*ptr == htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16)
4292                           | (TCPOPT_TIMESTAMP << 8) | TCPOLEN_TIMESTAMP)) {
4293                 tp->rx_opt.saw_tstamp = 1;
4294                 ++ptr;
4295                 tp->rx_opt.rcv_tsval = ntohl(*ptr);
4296                 ++ptr;
4297                 if (*ptr)
4298                         tp->rx_opt.rcv_tsecr = ntohl(*ptr) - tp->tsoffset;
4299                 else
4300                         tp->rx_opt.rcv_tsecr = 0;
4301                 return true;
4302         }
4303         return false;
4304 }
4305
4306 /* Fast parse options. This hopes to only see timestamps.
4307  * If it is wrong it falls back on tcp_parse_options().
4308  */
4309 static bool tcp_fast_parse_options(const struct net *net,
4310                                    const struct sk_buff *skb,
4311                                    const struct tcphdr *th, struct tcp_sock *tp)
4312 {
4313         /* In the spirit of fast parsing, compare doff directly to constant
4314          * values.  Because equality is used, short doff can be ignored here.
4315          */
4316         if (th->doff == (sizeof(*th) / 4)) {
4317                 tp->rx_opt.saw_tstamp = 0;
4318                 return false;
4319         } else if (tp->rx_opt.tstamp_ok &&
4320                    th->doff == ((sizeof(*th) + TCPOLEN_TSTAMP_ALIGNED) / 4)) {
4321                 if (tcp_parse_aligned_timestamp(tp, th))
4322                         return true;
4323         }
4324
4325         tcp_parse_options(net, skb, &tp->rx_opt, 1, NULL);
4326         if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
4327                 tp->rx_opt.rcv_tsecr -= tp->tsoffset;
4328
4329         return true;
4330 }
4331
4332 #if defined(CONFIG_TCP_MD5SIG) || defined(CONFIG_TCP_AO)
4333 /*
4334  * Parse Signature options
4335  */
4336 int tcp_do_parse_auth_options(const struct tcphdr *th,
4337                               const u8 **md5_hash, const u8 **ao_hash)
4338 {
4339         int length = (th->doff << 2) - sizeof(*th);
4340         const u8 *ptr = (const u8 *)(th + 1);
4341         unsigned int minlen = TCPOLEN_MD5SIG;
4342
4343         if (IS_ENABLED(CONFIG_TCP_AO))
4344                 minlen = sizeof(struct tcp_ao_hdr) + 1;
4345
4346         *md5_hash = NULL;
4347         *ao_hash = NULL;
4348
4349         /* If not enough data remaining, we can short cut */
4350         while (length >= minlen) {
4351                 int opcode = *ptr++;
4352                 int opsize;
4353
4354                 switch (opcode) {
4355                 case TCPOPT_EOL:
4356                         return 0;
4357                 case TCPOPT_NOP:
4358                         length--;
4359                         continue;
4360                 default:
4361                         opsize = *ptr++;
4362                         if (opsize < 2 || opsize > length)
4363                                 return -EINVAL;
4364                         if (opcode == TCPOPT_MD5SIG) {
4365                                 if (opsize != TCPOLEN_MD5SIG)
4366                                         return -EINVAL;
4367                                 if (unlikely(*md5_hash || *ao_hash))
4368                                         return -EEXIST;
4369                                 *md5_hash = ptr;
4370                         } else if (opcode == TCPOPT_AO) {
4371                                 if (opsize <= sizeof(struct tcp_ao_hdr))
4372                                         return -EINVAL;
4373                                 if (unlikely(*md5_hash || *ao_hash))
4374                                         return -EEXIST;
4375                                 *ao_hash = ptr;
4376                         }
4377                 }
4378                 ptr += opsize - 2;
4379                 length -= opsize;
4380         }
4381         return 0;
4382 }
4383 EXPORT_SYMBOL(tcp_do_parse_auth_options);
4384 #endif
4385
4386 /* Sorry, PAWS as specified is broken wrt. pure-ACKs -DaveM
4387  *
4388  * It is not fatal. If this ACK does _not_ change critical state (seqs, window)
4389  * it can pass through stack. So, the following predicate verifies that
4390  * this segment is not used for anything but congestion avoidance or
4391  * fast retransmit. Moreover, we even are able to eliminate most of such
4392  * second order effects, if we apply some small "replay" window (~RTO)
4393  * to timestamp space.
4394  *
4395  * All these measures still do not guarantee that we reject wrapped ACKs
4396  * on networks with high bandwidth, when sequence space is recycled fastly,
4397  * but it guarantees that such events will be very rare and do not affect
4398  * connection seriously. This doesn't look nice, but alas, PAWS is really
4399  * buggy extension.
4400  *
4401  * [ Later note. Even worse! It is buggy for segments _with_ data. RFC
4402  * states that events when retransmit arrives after original data are rare.
4403  * It is a blatant lie. VJ forgot about fast retransmit! 8)8) It is
4404  * the biggest problem on large power networks even with minor reordering.
4405  * OK, let's give it small replay window. If peer clock is even 1hz, it is safe
4406  * up to bandwidth of 18Gigabit/sec. 8) ]
4407  */
4408
4409 /* Estimates max number of increments of remote peer TSval in
4410  * a replay window (based on our current RTO estimation).
4411  */
4412 static u32 tcp_tsval_replay(const struct sock *sk)
4413 {
4414         /* If we use usec TS resolution,
4415          * then expect the remote peer to use the same resolution.
4416          */
4417         if (tcp_sk(sk)->tcp_usec_ts)
4418                 return inet_csk(sk)->icsk_rto * (USEC_PER_SEC / HZ);
4419
4420         /* RFC 7323 recommends a TSval clock between 1ms and 1sec.
4421          * We know that some OS (including old linux) can use 1200 Hz.
4422          */
4423         return inet_csk(sk)->icsk_rto * 1200 / HZ;
4424 }
4425
4426 static int tcp_disordered_ack(const struct sock *sk, const struct sk_buff *skb)
4427 {
4428         const struct tcp_sock *tp = tcp_sk(sk);
4429         const struct tcphdr *th = tcp_hdr(skb);
4430         u32 seq = TCP_SKB_CB(skb)->seq;
4431         u32 ack = TCP_SKB_CB(skb)->ack_seq;
4432
4433         return  /* 1. Pure ACK with correct sequence number. */
4434                 (th->ack && seq == TCP_SKB_CB(skb)->end_seq && seq == tp->rcv_nxt) &&
4435
4436                 /* 2. ... and duplicate ACK. */
4437                 ack == tp->snd_una &&
4438
4439                 /* 3. ... and does not update window. */
4440                 !tcp_may_update_window(tp, ack, seq, ntohs(th->window) << tp->rx_opt.snd_wscale) &&
4441
4442                 /* 4. ... and sits in replay window. */
4443                 (s32)(tp->rx_opt.ts_recent - tp->rx_opt.rcv_tsval) <=
4444                 tcp_tsval_replay(sk);
4445 }
4446
4447 static inline bool tcp_paws_discard(const struct sock *sk,
4448                                    const struct sk_buff *skb)
4449 {
4450         const struct tcp_sock *tp = tcp_sk(sk);
4451
4452         return !tcp_paws_check(&tp->rx_opt, TCP_PAWS_WINDOW) &&
4453                !tcp_disordered_ack(sk, skb);
4454 }
4455
4456 /* Check segment sequence number for validity.
4457  *
4458  * Segment controls are considered valid, if the segment
4459  * fits to the window after truncation to the window. Acceptability
4460  * of data (and SYN, FIN, of course) is checked separately.
4461  * See tcp_data_queue(), for example.
4462  *
4463  * Also, controls (RST is main one) are accepted using RCV.WUP instead
4464  * of RCV.NXT. Peer still did not advance his SND.UNA when we
4465  * delayed ACK, so that hisSND.UNA<=ourRCV.WUP.
4466  * (borrowed from freebsd)
4467  */
4468
4469 static enum skb_drop_reason tcp_sequence(const struct tcp_sock *tp,
4470                                          u32 seq, u32 end_seq)
4471 {
4472         if (before(end_seq, tp->rcv_wup))
4473                 return SKB_DROP_REASON_TCP_OLD_SEQUENCE;
4474
4475         if (after(seq, tp->rcv_nxt + tcp_receive_window(tp)))
4476                 return SKB_DROP_REASON_TCP_INVALID_SEQUENCE;
4477
4478         return SKB_NOT_DROPPED_YET;
4479 }
4480
4481
4482 void tcp_done_with_error(struct sock *sk, int err)
4483 {
4484         /* This barrier is coupled with smp_rmb() in tcp_poll() */
4485         WRITE_ONCE(sk->sk_err, err);
4486         smp_wmb();
4487
4488         tcp_write_queue_purge(sk);
4489         tcp_done(sk);
4490
4491         if (!sock_flag(sk, SOCK_DEAD))
4492                 sk_error_report(sk);
4493 }
4494 EXPORT_SYMBOL(tcp_done_with_error);
4495
4496 /* When we get a reset we do this. */
4497 void tcp_reset(struct sock *sk, struct sk_buff *skb)
4498 {
4499         int err;
4500
4501         trace_tcp_receive_reset(sk);
4502
4503         /* mptcp can't tell us to ignore reset pkts,
4504          * so just ignore the return value of mptcp_incoming_options().
4505          */
4506         if (sk_is_mptcp(sk))
4507                 mptcp_incoming_options(sk, skb);
4508
4509         /* We want the right error as BSD sees it (and indeed as we do). */
4510         switch (sk->sk_state) {
4511         case TCP_SYN_SENT:
4512                 err = ECONNREFUSED;
4513                 break;
4514         case TCP_CLOSE_WAIT:
4515                 err = EPIPE;
4516                 break;
4517         case TCP_CLOSE:
4518                 return;
4519         default:
4520                 err = ECONNRESET;
4521         }
4522         tcp_done_with_error(sk, err);
4523 }
4524
4525 /*
4526  *      Process the FIN bit. This now behaves as it is supposed to work
4527  *      and the FIN takes effect when it is validly part of sequence
4528  *      space. Not before when we get holes.
4529  *
4530  *      If we are ESTABLISHED, a received fin moves us to CLOSE-WAIT
4531  *      (and thence onto LAST-ACK and finally, CLOSE, we never enter
4532  *      TIME-WAIT)
4533  *
4534  *      If we are in FINWAIT-1, a received FIN indicates simultaneous
4535  *      close and we go into CLOSING (and later onto TIME-WAIT)
4536  *
4537  *      If we are in FINWAIT-2, a received FIN moves us to TIME-WAIT.
4538  */
4539 void tcp_fin(struct sock *sk)
4540 {
4541         struct tcp_sock *tp = tcp_sk(sk);
4542
4543         inet_csk_schedule_ack(sk);
4544
4545         WRITE_ONCE(sk->sk_shutdown, sk->sk_shutdown | RCV_SHUTDOWN);
4546         sock_set_flag(sk, SOCK_DONE);
4547
4548         switch (sk->sk_state) {
4549         case TCP_SYN_RECV:
4550         case TCP_ESTABLISHED:
4551                 /* Move to CLOSE_WAIT */
4552                 tcp_set_state(sk, TCP_CLOSE_WAIT);
4553                 inet_csk_enter_pingpong_mode(sk);
4554                 break;
4555
4556         case TCP_CLOSE_WAIT:
4557         case TCP_CLOSING:
4558                 /* Received a retransmission of the FIN, do
4559                  * nothing.
4560                  */
4561                 break;
4562         case TCP_LAST_ACK:
4563                 /* RFC793: Remain in the LAST-ACK state. */
4564                 break;
4565
4566         case TCP_FIN_WAIT1:
4567                 /* This case occurs when a simultaneous close
4568                  * happens, we must ack the received FIN and
4569                  * enter the CLOSING state.
4570                  */
4571                 tcp_send_ack(sk);
4572                 tcp_set_state(sk, TCP_CLOSING);
4573                 break;
4574         case TCP_FIN_WAIT2:
4575                 /* Received a FIN -- send ACK and enter TIME_WAIT. */
4576                 tcp_send_ack(sk);
4577                 tcp_time_wait(sk, TCP_TIME_WAIT, 0);
4578                 break;
4579         default:
4580                 /* Only TCP_LISTEN and TCP_CLOSE are left, in these
4581                  * cases we should never reach this piece of code.
4582                  */
4583                 pr_err("%s: Impossible, sk->sk_state=%d\n",
4584                        __func__, sk->sk_state);
4585                 break;
4586         }
4587
4588         /* It _is_ possible, that we have something out-of-order _after_ FIN.
4589          * Probably, we should reset in this case. For now drop them.
4590          */
4591         skb_rbtree_purge(&tp->out_of_order_queue);
4592         if (tcp_is_sack(tp))
4593                 tcp_sack_reset(&tp->rx_opt);
4594
4595         if (!sock_flag(sk, SOCK_DEAD)) {
4596                 sk->sk_state_change(sk);
4597
4598                 /* Do not send POLL_HUP for half duplex close. */
4599                 if (sk->sk_shutdown == SHUTDOWN_MASK ||
4600                     sk->sk_state == TCP_CLOSE)
4601                         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_HUP);
4602                 else
4603                         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
4604         }
4605 }
4606
4607 static inline bool tcp_sack_extend(struct tcp_sack_block *sp, u32 seq,
4608                                   u32 end_seq)
4609 {
4610         if (!after(seq, sp->end_seq) && !after(sp->start_seq, end_seq)) {
4611                 if (before(seq, sp->start_seq))
4612                         sp->start_seq = seq;
4613                 if (after(end_seq, sp->end_seq))
4614                         sp->end_seq = end_seq;
4615                 return true;
4616         }
4617         return false;
4618 }
4619
4620 static void tcp_dsack_set(struct sock *sk, u32 seq, u32 end_seq)
4621 {
4622         struct tcp_sock *tp = tcp_sk(sk);
4623
4624         if (tcp_is_sack(tp) && READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_dsack)) {
4625                 int mib_idx;
4626
4627                 if (before(seq, tp->rcv_nxt))
4628                         mib_idx = LINUX_MIB_TCPDSACKOLDSENT;
4629                 else
4630                         mib_idx = LINUX_MIB_TCPDSACKOFOSENT;
4631
4632                 NET_INC_STATS(sock_net(sk), mib_idx);
4633
4634                 tp->rx_opt.dsack = 1;
4635                 tp->duplicate_sack[0].start_seq = seq;
4636                 tp->duplicate_sack[0].end_seq = end_seq;
4637         }
4638 }
4639
4640 static void tcp_dsack_extend(struct sock *sk, u32 seq, u32 end_seq)
4641 {
4642         struct tcp_sock *tp = tcp_sk(sk);
4643
4644         if (!tp->rx_opt.dsack)
4645                 tcp_dsack_set(sk, seq, end_seq);
4646         else
4647                 tcp_sack_extend(tp->duplicate_sack, seq, end_seq);
4648 }
4649
4650 static void tcp_rcv_spurious_retrans(struct sock *sk, const struct sk_buff *skb)
4651 {
4652         /* When the ACK path fails or drops most ACKs, the sender would
4653          * timeout and spuriously retransmit the same segment repeatedly.
4654          * If it seems our ACKs are not reaching the other side,
4655          * based on receiving a duplicate data segment with new flowlabel
4656          * (suggesting the sender suffered an RTO), and we are not already
4657          * repathing due to our own RTO, then rehash the socket to repath our
4658          * packets.
4659          */
4660 #if IS_ENABLED(CONFIG_IPV6)
4661         if (inet_csk(sk)->icsk_ca_state != TCP_CA_Loss &&
4662             skb->protocol == htons(ETH_P_IPV6) &&
4663             (tcp_sk(sk)->inet_conn.icsk_ack.lrcv_flowlabel !=
4664              ntohl(ip6_flowlabel(ipv6_hdr(skb)))) &&
4665             sk_rethink_txhash(sk))
4666                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPDUPLICATEDATAREHASH);
4667
4668         /* Save last flowlabel after a spurious retrans. */
4669         tcp_save_lrcv_flowlabel(sk, skb);
4670 #endif
4671 }
4672
4673 static void tcp_send_dupack(struct sock *sk, const struct sk_buff *skb)
4674 {
4675         struct tcp_sock *tp = tcp_sk(sk);
4676
4677         if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
4678             before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
4679                 NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
4680                 tcp_enter_quickack_mode(sk, TCP_MAX_QUICKACKS);
4681
4682                 if (tcp_is_sack(tp) && READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_dsack)) {
4683                         u32 end_seq = TCP_SKB_CB(skb)->end_seq;
4684
4685                         tcp_rcv_spurious_retrans(sk, skb);
4686                         if (after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))
4687                                 end_seq = tp->rcv_nxt;
4688                         tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, end_seq);
4689                 }
4690         }
4691
4692         tcp_send_ack(sk);
4693 }
4694
4695 /* These routines update the SACK block as out-of-order packets arrive or
4696  * in-order packets close up the sequence space.
4697  */
4698 static void tcp_sack_maybe_coalesce(struct tcp_sock *tp)
4699 {
4700         int this_sack;
4701         struct tcp_sack_block *sp = &tp->selective_acks[0];
4702         struct tcp_sack_block *swalk = sp + 1;
4703
4704         /* See if the recent change to the first SACK eats into
4705          * or hits the sequence space of other SACK blocks, if so coalesce.
4706          */
4707         for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;) {
4708                 if (tcp_sack_extend(sp, swalk->start_seq, swalk->end_seq)) {
4709                         int i;
4710
4711                         /* Zap SWALK, by moving every further SACK up by one slot.
4712                          * Decrease num_sacks.
4713                          */
4714                         tp->rx_opt.num_sacks--;
4715                         for (i = this_sack; i < tp->rx_opt.num_sacks; i++)
4716                                 sp[i] = sp[i + 1];
4717                         continue;
4718                 }
4719                 this_sack++;
4720                 swalk++;
4721         }
4722 }
4723
4724 void tcp_sack_compress_send_ack(struct sock *sk)
4725 {
4726         struct tcp_sock *tp = tcp_sk(sk);
4727
4728         if (!tp->compressed_ack)
4729                 return;
4730
4731         if (hrtimer_try_to_cancel(&tp->compressed_ack_timer) == 1)
4732                 __sock_put(sk);
4733
4734         /* Since we have to send one ack finally,
4735          * substract one from tp->compressed_ack to keep
4736          * LINUX_MIB_TCPACKCOMPRESSED accurate.
4737          */
4738         NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPACKCOMPRESSED,
4739                       tp->compressed_ack - 1);
4740
4741         tp->compressed_ack = 0;
4742         tcp_send_ack(sk);
4743 }
4744
4745 /* Reasonable amount of sack blocks included in TCP SACK option
4746  * The max is 4, but this becomes 3 if TCP timestamps are there.
4747  * Given that SACK packets might be lost, be conservative and use 2.
4748  */
4749 #define TCP_SACK_BLOCKS_EXPECTED 2
4750
4751 static void tcp_sack_new_ofo_skb(struct sock *sk, u32 seq, u32 end_seq)
4752 {
4753         struct tcp_sock *tp = tcp_sk(sk);
4754         struct tcp_sack_block *sp = &tp->selective_acks[0];
4755         int cur_sacks = tp->rx_opt.num_sacks;
4756         int this_sack;
4757
4758         if (!cur_sacks)
4759                 goto new_sack;
4760
4761         for (this_sack = 0; this_sack < cur_sacks; this_sack++, sp++) {
4762                 if (tcp_sack_extend(sp, seq, end_seq)) {
4763                         if (this_sack >= TCP_SACK_BLOCKS_EXPECTED)
4764                                 tcp_sack_compress_send_ack(sk);
4765                         /* Rotate this_sack to the first one. */
4766                         for (; this_sack > 0; this_sack--, sp--)
4767                                 swap(*sp, *(sp - 1));
4768                         if (cur_sacks > 1)
4769                                 tcp_sack_maybe_coalesce(tp);
4770                         return;
4771                 }
4772         }
4773
4774         if (this_sack >= TCP_SACK_BLOCKS_EXPECTED)
4775                 tcp_sack_compress_send_ack(sk);
4776
4777         /* Could not find an adjacent existing SACK, build a new one,
4778          * put it at the front, and shift everyone else down.  We
4779          * always know there is at least one SACK present already here.
4780          *
4781          * If the sack array is full, forget about the last one.
4782          */
4783         if (this_sack >= TCP_NUM_SACKS) {
4784                 this_sack--;
4785                 tp->rx_opt.num_sacks--;
4786                 sp--;
4787         }
4788         for (; this_sack > 0; this_sack--, sp--)
4789                 *sp = *(sp - 1);
4790
4791 new_sack:
4792         /* Build the new head SACK, and we're done. */
4793         sp->start_seq = seq;
4794         sp->end_seq = end_seq;
4795         tp->rx_opt.num_sacks++;
4796 }
4797
4798 /* RCV.NXT advances, some SACKs should be eaten. */
4799
4800 static void tcp_sack_remove(struct tcp_sock *tp)
4801 {
4802         struct tcp_sack_block *sp = &tp->selective_acks[0];
4803         int num_sacks = tp->rx_opt.num_sacks;
4804         int this_sack;
4805
4806         /* Empty ofo queue, hence, all the SACKs are eaten. Clear. */
4807         if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
4808                 tp->rx_opt.num_sacks = 0;
4809                 return;
4810         }
4811
4812         for (this_sack = 0; this_sack < num_sacks;) {
4813                 /* Check if the start of the sack is covered by RCV.NXT. */
4814                 if (!before(tp->rcv_nxt, sp->start_seq)) {
4815                         int i;
4816
4817                         /* RCV.NXT must cover all the block! */
4818                         WARN_ON(before(tp->rcv_nxt, sp->end_seq));
4819
4820                         /* Zap this SACK, by moving forward any other SACKS. */
4821                         for (i = this_sack+1; i < num_sacks; i++)
4822                                 tp->selective_acks[i-1] = tp->selective_acks[i];
4823                         num_sacks--;
4824                         continue;
4825                 }
4826                 this_sack++;
4827                 sp++;
4828         }
4829         tp->rx_opt.num_sacks = num_sacks;
4830 }
4831
4832 /**
4833  * tcp_try_coalesce - try to merge skb to prior one
4834  * @sk: socket
4835  * @to: prior buffer
4836  * @from: buffer to add in queue
4837  * @fragstolen: pointer to boolean
4838  *
4839  * Before queueing skb @from after @to, try to merge them
4840  * to reduce overall memory use and queue lengths, if cost is small.
4841  * Packets in ofo or receive queues can stay a long time.
4842  * Better try to coalesce them right now to avoid future collapses.
4843  * Returns true if caller should free @from instead of queueing it
4844  */
4845 static bool tcp_try_coalesce(struct sock *sk,
4846                              struct sk_buff *to,
4847                              struct sk_buff *from,
4848                              bool *fragstolen)
4849 {
4850         int delta;
4851
4852         *fragstolen = false;
4853
4854         /* Its possible this segment overlaps with prior segment in queue */
4855         if (TCP_SKB_CB(from)->seq != TCP_SKB_CB(to)->end_seq)
4856                 return false;
4857
4858         if (!tcp_skb_can_collapse_rx(to, from))
4859                 return false;
4860
4861         if (!skb_try_coalesce(to, from, fragstolen, &delta))
4862                 return false;
4863
4864         atomic_add(delta, &sk->sk_rmem_alloc);
4865         sk_mem_charge(sk, delta);
4866         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOALESCE);
4867         TCP_SKB_CB(to)->end_seq = TCP_SKB_CB(from)->end_seq;
4868         TCP_SKB_CB(to)->ack_seq = TCP_SKB_CB(from)->ack_seq;
4869         TCP_SKB_CB(to)->tcp_flags |= TCP_SKB_CB(from)->tcp_flags;
4870
4871         if (TCP_SKB_CB(from)->has_rxtstamp) {
4872                 TCP_SKB_CB(to)->has_rxtstamp = true;
4873                 to->tstamp = from->tstamp;
4874                 skb_hwtstamps(to)->hwtstamp = skb_hwtstamps(from)->hwtstamp;
4875         }
4876
4877         return true;
4878 }
4879
4880 static bool tcp_ooo_try_coalesce(struct sock *sk,
4881                              struct sk_buff *to,
4882                              struct sk_buff *from,
4883                              bool *fragstolen)
4884 {
4885         bool res = tcp_try_coalesce(sk, to, from, fragstolen);
4886
4887         /* In case tcp_drop_reason() is called later, update to->gso_segs */
4888         if (res) {
4889                 u32 gso_segs = max_t(u16, 1, skb_shinfo(to)->gso_segs) +
4890                                max_t(u16, 1, skb_shinfo(from)->gso_segs);
4891
4892                 skb_shinfo(to)->gso_segs = min_t(u32, gso_segs, 0xFFFF);
4893         }
4894         return res;
4895 }
4896
4897 static void tcp_drop_reason(struct sock *sk, struct sk_buff *skb,
4898                             enum skb_drop_reason reason)
4899 {
4900         sk_drops_add(sk, skb);
4901         sk_skb_reason_drop(sk, skb, reason);
4902 }
4903
4904 /* This one checks to see if we can put data from the
4905  * out_of_order queue into the receive_queue.
4906  */
4907 static void tcp_ofo_queue(struct sock *sk)
4908 {
4909         struct tcp_sock *tp = tcp_sk(sk);
4910         __u32 dsack_high = tp->rcv_nxt;
4911         bool fin, fragstolen, eaten;
4912         struct sk_buff *skb, *tail;
4913         struct rb_node *p;
4914
4915         p = rb_first(&tp->out_of_order_queue);
4916         while (p) {
4917                 skb = rb_to_skb(p);
4918                 if (after(TCP_SKB_CB(skb)->seq, tp->rcv_nxt))
4919                         break;
4920
4921                 if (before(TCP_SKB_CB(skb)->seq, dsack_high)) {
4922                         __u32 dsack = dsack_high;
4923                         if (before(TCP_SKB_CB(skb)->end_seq, dsack_high))
4924                                 dsack_high = TCP_SKB_CB(skb)->end_seq;
4925                         tcp_dsack_extend(sk, TCP_SKB_CB(skb)->seq, dsack);
4926                 }
4927                 p = rb_next(p);
4928                 rb_erase(&skb->rbnode, &tp->out_of_order_queue);
4929
4930                 if (unlikely(!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt))) {
4931                         tcp_drop_reason(sk, skb, SKB_DROP_REASON_TCP_OFO_DROP);
4932                         continue;
4933                 }
4934
4935                 tail = skb_peek_tail(&sk->sk_receive_queue);
4936                 eaten = tail && tcp_try_coalesce(sk, tail, skb, &fragstolen);
4937                 tcp_rcv_nxt_update(tp, TCP_SKB_CB(skb)->end_seq);
4938                 fin = TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN;
4939                 if (!eaten)
4940                         __skb_queue_tail(&sk->sk_receive_queue, skb);
4941                 else
4942                         kfree_skb_partial(skb, fragstolen);
4943
4944                 if (unlikely(fin)) {
4945                         tcp_fin(sk);
4946                         /* tcp_fin() purges tp->out_of_order_queue,
4947                          * so we must end this loop right now.
4948                          */
4949                         break;
4950                 }
4951         }
4952 }
4953
4954 static bool tcp_prune_ofo_queue(struct sock *sk, const struct sk_buff *in_skb);
4955 static int tcp_prune_queue(struct sock *sk, const struct sk_buff *in_skb);
4956
4957 static int tcp_try_rmem_schedule(struct sock *sk, struct sk_buff *skb,
4958                                  unsigned int size)
4959 {
4960         if (atomic_read(&sk->sk_rmem_alloc) > sk->sk_rcvbuf ||
4961             !sk_rmem_schedule(sk, skb, size)) {
4962
4963                 if (tcp_prune_queue(sk, skb) < 0)
4964                         return -1;
4965
4966                 while (!sk_rmem_schedule(sk, skb, size)) {
4967                         if (!tcp_prune_ofo_queue(sk, skb))
4968                                 return -1;
4969                 }
4970         }
4971         return 0;
4972 }
4973
4974 static void tcp_data_queue_ofo(struct sock *sk, struct sk_buff *skb)
4975 {
4976         struct tcp_sock *tp = tcp_sk(sk);
4977         struct rb_node **p, *parent;
4978         struct sk_buff *skb1;
4979         u32 seq, end_seq;
4980         bool fragstolen;
4981
4982         tcp_save_lrcv_flowlabel(sk, skb);
4983         tcp_ecn_check_ce(sk, skb);
4984
4985         if (unlikely(tcp_try_rmem_schedule(sk, skb, skb->truesize))) {
4986                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFODROP);
4987                 sk->sk_data_ready(sk);
4988                 tcp_drop_reason(sk, skb, SKB_DROP_REASON_PROTO_MEM);
4989                 return;
4990         }
4991
4992         /* Disable header prediction. */
4993         tp->pred_flags = 0;
4994         inet_csk_schedule_ack(sk);
4995
4996         tp->rcv_ooopack += max_t(u16, 1, skb_shinfo(skb)->gso_segs);
4997         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOQUEUE);
4998         seq = TCP_SKB_CB(skb)->seq;
4999         end_seq = TCP_SKB_CB(skb)->end_seq;
5000
5001         p = &tp->out_of_order_queue.rb_node;
5002         if (RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
5003                 /* Initial out of order segment, build 1 SACK. */
5004                 if (tcp_is_sack(tp)) {
5005                         tp->rx_opt.num_sacks = 1;
5006                         tp->selective_acks[0].start_seq = seq;
5007                         tp->selective_acks[0].end_seq = end_seq;
5008                 }
5009                 rb_link_node(&skb->rbnode, NULL, p);
5010                 rb_insert_color(&skb->rbnode, &tp->out_of_order_queue);
5011                 tp->ooo_last_skb = skb;
5012                 goto end;
5013         }
5014
5015         /* In the typical case, we are adding an skb to the end of the list.
5016          * Use of ooo_last_skb avoids the O(Log(N)) rbtree lookup.
5017          */
5018         if (tcp_ooo_try_coalesce(sk, tp->ooo_last_skb,
5019                                  skb, &fragstolen)) {
5020 coalesce_done:
5021                 /* For non sack flows, do not grow window to force DUPACK
5022                  * and trigger fast retransmit.
5023                  */
5024                 if (tcp_is_sack(tp))
5025                         tcp_grow_window(sk, skb, true);
5026                 kfree_skb_partial(skb, fragstolen);
5027                 skb = NULL;
5028                 goto add_sack;
5029         }
5030         /* Can avoid an rbtree lookup if we are adding skb after ooo_last_skb */
5031         if (!before(seq, TCP_SKB_CB(tp->ooo_last_skb)->end_seq)) {
5032                 parent = &tp->ooo_last_skb->rbnode;
5033                 p = &parent->rb_right;
5034                 goto insert;
5035         }
5036
5037         /* Find place to insert this segment. Handle overlaps on the way. */
5038         parent = NULL;
5039         while (*p) {
5040                 parent = *p;
5041                 skb1 = rb_to_skb(parent);
5042                 if (before(seq, TCP_SKB_CB(skb1)->seq)) {
5043                         p = &parent->rb_left;
5044                         continue;
5045                 }
5046                 if (before(seq, TCP_SKB_CB(skb1)->end_seq)) {
5047                         if (!after(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
5048                                 /* All the bits are present. Drop. */
5049                                 NET_INC_STATS(sock_net(sk),
5050                                               LINUX_MIB_TCPOFOMERGE);
5051                                 tcp_drop_reason(sk, skb,
5052                                                 SKB_DROP_REASON_TCP_OFOMERGE);
5053                                 skb = NULL;
5054                                 tcp_dsack_set(sk, seq, end_seq);
5055                                 goto add_sack;
5056                         }
5057                         if (after(seq, TCP_SKB_CB(skb1)->seq)) {
5058                                 /* Partial overlap. */
5059                                 tcp_dsack_set(sk, seq, TCP_SKB_CB(skb1)->end_seq);
5060                         } else {
5061                                 /* skb's seq == skb1's seq and skb covers skb1.
5062                                  * Replace skb1 with skb.
5063                                  */
5064                                 rb_replace_node(&skb1->rbnode, &skb->rbnode,
5065                                                 &tp->out_of_order_queue);
5066                                 tcp_dsack_extend(sk,
5067                                                  TCP_SKB_CB(skb1)->seq,
5068                                                  TCP_SKB_CB(skb1)->end_seq);
5069                                 NET_INC_STATS(sock_net(sk),
5070                                               LINUX_MIB_TCPOFOMERGE);
5071                                 tcp_drop_reason(sk, skb1,
5072                                                 SKB_DROP_REASON_TCP_OFOMERGE);
5073                                 goto merge_right;
5074                         }
5075                 } else if (tcp_ooo_try_coalesce(sk, skb1,
5076                                                 skb, &fragstolen)) {
5077                         goto coalesce_done;
5078                 }
5079                 p = &parent->rb_right;
5080         }
5081 insert:
5082         /* Insert segment into RB tree. */
5083         rb_link_node(&skb->rbnode, parent, p);
5084         rb_insert_color(&skb->rbnode, &tp->out_of_order_queue);
5085
5086 merge_right:
5087         /* Remove other segments covered by skb. */
5088         while ((skb1 = skb_rb_next(skb)) != NULL) {
5089                 if (!after(end_seq, TCP_SKB_CB(skb1)->seq))
5090                         break;
5091                 if (before(end_seq, TCP_SKB_CB(skb1)->end_seq)) {
5092                         tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
5093                                          end_seq);
5094                         break;
5095                 }
5096                 rb_erase(&skb1->rbnode, &tp->out_of_order_queue);
5097                 tcp_dsack_extend(sk, TCP_SKB_CB(skb1)->seq,
5098                                  TCP_SKB_CB(skb1)->end_seq);
5099                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPOFOMERGE);
5100                 tcp_drop_reason(sk, skb1, SKB_DROP_REASON_TCP_OFOMERGE);
5101         }
5102         /* If there is no skb after us, we are the last_skb ! */
5103         if (!skb1)
5104                 tp->ooo_last_skb = skb;
5105
5106 add_sack:
5107         if (tcp_is_sack(tp))
5108                 tcp_sack_new_ofo_skb(sk, seq, end_seq);
5109 end:
5110         if (skb) {
5111                 /* For non sack flows, do not grow window to force DUPACK
5112                  * and trigger fast retransmit.
5113                  */
5114                 if (tcp_is_sack(tp))
5115                         tcp_grow_window(sk, skb, false);
5116                 skb_condense(skb);
5117                 skb_set_owner_r(skb, sk);
5118         }
5119 }
5120
5121 static int __must_check tcp_queue_rcv(struct sock *sk, struct sk_buff *skb,
5122                                       bool *fragstolen)
5123 {
5124         int eaten;
5125         struct sk_buff *tail = skb_peek_tail(&sk->sk_receive_queue);
5126
5127         eaten = (tail &&
5128                  tcp_try_coalesce(sk, tail,
5129                                   skb, fragstolen)) ? 1 : 0;
5130         tcp_rcv_nxt_update(tcp_sk(sk), TCP_SKB_CB(skb)->end_seq);
5131         if (!eaten) {
5132                 __skb_queue_tail(&sk->sk_receive_queue, skb);
5133                 skb_set_owner_r(skb, sk);
5134         }
5135         return eaten;
5136 }
5137
5138 int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size)
5139 {
5140         struct sk_buff *skb;
5141         int err = -ENOMEM;
5142         int data_len = 0;
5143         bool fragstolen;
5144
5145         if (size == 0)
5146                 return 0;
5147
5148         if (size > PAGE_SIZE) {
5149                 int npages = min_t(size_t, size >> PAGE_SHIFT, MAX_SKB_FRAGS);
5150
5151                 data_len = npages << PAGE_SHIFT;
5152                 size = data_len + (size & ~PAGE_MASK);
5153         }
5154         skb = alloc_skb_with_frags(size - data_len, data_len,
5155                                    PAGE_ALLOC_COSTLY_ORDER,
5156                                    &err, sk->sk_allocation);
5157         if (!skb)
5158                 goto err;
5159
5160         skb_put(skb, size - data_len);
5161         skb->data_len = data_len;
5162         skb->len = size;
5163
5164         if (tcp_try_rmem_schedule(sk, skb, skb->truesize)) {
5165                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVQDROP);
5166                 goto err_free;
5167         }
5168
5169         err = skb_copy_datagram_from_iter(skb, 0, &msg->msg_iter, size);
5170         if (err)
5171                 goto err_free;
5172
5173         TCP_SKB_CB(skb)->seq = tcp_sk(sk)->rcv_nxt;
5174         TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(skb)->seq + size;
5175         TCP_SKB_CB(skb)->ack_seq = tcp_sk(sk)->snd_una - 1;
5176
5177         if (tcp_queue_rcv(sk, skb, &fragstolen)) {
5178                 WARN_ON_ONCE(fragstolen); /* should not happen */
5179                 __kfree_skb(skb);
5180         }
5181         return size;
5182
5183 err_free:
5184         kfree_skb(skb);
5185 err:
5186         return err;
5187
5188 }
5189
5190 void tcp_data_ready(struct sock *sk)
5191 {
5192         if (tcp_epollin_ready(sk, sk->sk_rcvlowat) || sock_flag(sk, SOCK_DONE))
5193                 sk->sk_data_ready(sk);
5194 }
5195
5196 static void tcp_data_queue(struct sock *sk, struct sk_buff *skb)
5197 {
5198         struct tcp_sock *tp = tcp_sk(sk);
5199         enum skb_drop_reason reason;
5200         bool fragstolen;
5201         int eaten;
5202
5203         /* If a subflow has been reset, the packet should not continue
5204          * to be processed, drop the packet.
5205          */
5206         if (sk_is_mptcp(sk) && !mptcp_incoming_options(sk, skb)) {
5207                 __kfree_skb(skb);
5208                 return;
5209         }
5210
5211         if (TCP_SKB_CB(skb)->seq == TCP_SKB_CB(skb)->end_seq) {
5212                 __kfree_skb(skb);
5213                 return;
5214         }
5215         skb_dst_drop(skb);
5216         __skb_pull(skb, tcp_hdr(skb)->doff * 4);
5217
5218         reason = SKB_DROP_REASON_NOT_SPECIFIED;
5219         tp->rx_opt.dsack = 0;
5220
5221         /*  Queue data for delivery to the user.
5222          *  Packets in sequence go to the receive queue.
5223          *  Out of sequence packets to the out_of_order_queue.
5224          */
5225         if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt) {
5226                 if (tcp_receive_window(tp) == 0) {
5227                         /* Some stacks are known to send bare FIN packets
5228                          * in a loop even if we send RWIN 0 in our ACK.
5229                          * Accepting this FIN does not hurt memory pressure
5230                          * because the FIN flag will simply be merged to the
5231                          * receive queue tail skb in most cases.
5232                          */
5233                         if (!skb->len &&
5234                             (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN))
5235                                 goto queue_and_out;
5236
5237                         reason = SKB_DROP_REASON_TCP_ZEROWINDOW;
5238                         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPZEROWINDOWDROP);
5239                         goto out_of_window;
5240                 }
5241
5242                 /* Ok. In sequence. In window. */
5243 queue_and_out:
5244                 if (tcp_try_rmem_schedule(sk, skb, skb->truesize)) {
5245                         /* TODO: maybe ratelimit these WIN 0 ACK ? */
5246                         inet_csk(sk)->icsk_ack.pending |=
5247                                         (ICSK_ACK_NOMEM | ICSK_ACK_NOW);
5248                         inet_csk_schedule_ack(sk);
5249                         sk->sk_data_ready(sk);
5250
5251                         if (skb_queue_len(&sk->sk_receive_queue) && skb->len) {
5252                                 reason = SKB_DROP_REASON_PROTO_MEM;
5253                                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVQDROP);
5254                                 goto drop;
5255                         }
5256                         sk_forced_mem_schedule(sk, skb->truesize);
5257                 }
5258
5259                 eaten = tcp_queue_rcv(sk, skb, &fragstolen);
5260                 if (skb->len)
5261                         tcp_event_data_recv(sk, skb);
5262                 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
5263                         tcp_fin(sk);
5264
5265                 if (!RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
5266                         tcp_ofo_queue(sk);
5267
5268                         /* RFC5681. 4.2. SHOULD send immediate ACK, when
5269                          * gap in queue is filled.
5270                          */
5271                         if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
5272                                 inet_csk(sk)->icsk_ack.pending |= ICSK_ACK_NOW;
5273                 }
5274
5275                 if (tp->rx_opt.num_sacks)
5276                         tcp_sack_remove(tp);
5277
5278                 tcp_fast_path_check(sk);
5279
5280                 if (eaten > 0)
5281                         kfree_skb_partial(skb, fragstolen);
5282                 if (!sock_flag(sk, SOCK_DEAD))
5283                         tcp_data_ready(sk);
5284                 return;
5285         }
5286
5287         if (!after(TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt)) {
5288                 tcp_rcv_spurious_retrans(sk, skb);
5289                 /* A retransmit, 2nd most common case.  Force an immediate ack. */
5290                 reason = SKB_DROP_REASON_TCP_OLD_DATA;
5291                 NET_INC_STATS(sock_net(sk), LINUX_MIB_DELAYEDACKLOST);
5292                 tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
5293
5294 out_of_window:
5295                 tcp_enter_quickack_mode(sk, TCP_MAX_QUICKACKS);
5296                 inet_csk_schedule_ack(sk);
5297 drop:
5298                 tcp_drop_reason(sk, skb, reason);
5299                 return;
5300         }
5301
5302         /* Out of window. F.e. zero window probe. */
5303         if (!before(TCP_SKB_CB(skb)->seq,
5304                     tp->rcv_nxt + tcp_receive_window(tp))) {
5305                 reason = SKB_DROP_REASON_TCP_OVERWINDOW;
5306                 goto out_of_window;
5307         }
5308
5309         if (before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
5310                 /* Partial packet, seq < rcv_next < end_seq */
5311                 tcp_dsack_set(sk, TCP_SKB_CB(skb)->seq, tp->rcv_nxt);
5312
5313                 /* If window is closed, drop tail of packet. But after
5314                  * remembering D-SACK for its head made in previous line.
5315                  */
5316                 if (!tcp_receive_window(tp)) {
5317                         reason = SKB_DROP_REASON_TCP_ZEROWINDOW;
5318                         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPZEROWINDOWDROP);
5319                         goto out_of_window;
5320                 }
5321                 goto queue_and_out;
5322         }
5323
5324         tcp_data_queue_ofo(sk, skb);
5325 }
5326
5327 static struct sk_buff *tcp_skb_next(struct sk_buff *skb, struct sk_buff_head *list)
5328 {
5329         if (list)
5330                 return !skb_queue_is_last(list, skb) ? skb->next : NULL;
5331
5332         return skb_rb_next(skb);
5333 }
5334
5335 static struct sk_buff *tcp_collapse_one(struct sock *sk, struct sk_buff *skb,
5336                                         struct sk_buff_head *list,
5337                                         struct rb_root *root)
5338 {
5339         struct sk_buff *next = tcp_skb_next(skb, list);
5340
5341         if (list)
5342                 __skb_unlink(skb, list);
5343         else
5344                 rb_erase(&skb->rbnode, root);
5345
5346         __kfree_skb(skb);
5347         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPRCVCOLLAPSED);
5348
5349         return next;
5350 }
5351
5352 /* Insert skb into rb tree, ordered by TCP_SKB_CB(skb)->seq */
5353 void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb)
5354 {
5355         struct rb_node **p = &root->rb_node;
5356         struct rb_node *parent = NULL;
5357         struct sk_buff *skb1;
5358
5359         while (*p) {
5360                 parent = *p;
5361                 skb1 = rb_to_skb(parent);
5362                 if (before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb1)->seq))
5363                         p = &parent->rb_left;
5364                 else
5365                         p = &parent->rb_right;
5366         }
5367         rb_link_node(&skb->rbnode, parent, p);
5368         rb_insert_color(&skb->rbnode, root);
5369 }
5370
5371 /* Collapse contiguous sequence of skbs head..tail with
5372  * sequence numbers start..end.
5373  *
5374  * If tail is NULL, this means until the end of the queue.
5375  *
5376  * Segments with FIN/SYN are not collapsed (only because this
5377  * simplifies code)
5378  */
5379 static void
5380 tcp_collapse(struct sock *sk, struct sk_buff_head *list, struct rb_root *root,
5381              struct sk_buff *head, struct sk_buff *tail, u32 start, u32 end)
5382 {
5383         struct sk_buff *skb = head, *n;
5384         struct sk_buff_head tmp;
5385         bool end_of_skbs;
5386
5387         /* First, check that queue is collapsible and find
5388          * the point where collapsing can be useful.
5389          */
5390 restart:
5391         for (end_of_skbs = true; skb != NULL && skb != tail; skb = n) {
5392                 n = tcp_skb_next(skb, list);
5393
5394                 /* No new bits? It is possible on ofo queue. */
5395                 if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
5396                         skb = tcp_collapse_one(sk, skb, list, root);
5397                         if (!skb)
5398                                 break;
5399                         goto restart;
5400                 }
5401
5402                 /* The first skb to collapse is:
5403                  * - not SYN/FIN and
5404                  * - bloated or contains data before "start" or
5405                  *   overlaps to the next one and mptcp allow collapsing.
5406                  */
5407                 if (!(TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)) &&
5408                     (tcp_win_from_space(sk, skb->truesize) > skb->len ||
5409                      before(TCP_SKB_CB(skb)->seq, start))) {
5410                         end_of_skbs = false;
5411                         break;
5412                 }
5413
5414                 if (n && n != tail && tcp_skb_can_collapse_rx(skb, n) &&
5415                     TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(n)->seq) {
5416                         end_of_skbs = false;
5417                         break;
5418                 }
5419
5420                 /* Decided to skip this, advance start seq. */
5421                 start = TCP_SKB_CB(skb)->end_seq;
5422         }
5423         if (end_of_skbs ||
5424             (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
5425                 return;
5426
5427         __skb_queue_head_init(&tmp);
5428
5429         while (before(start, end)) {
5430                 int copy = min_t(int, SKB_MAX_ORDER(0, 0), end - start);
5431                 struct sk_buff *nskb;
5432
5433                 nskb = alloc_skb(copy, GFP_ATOMIC);
5434                 if (!nskb)
5435                         break;
5436
5437                 memcpy(nskb->cb, skb->cb, sizeof(skb->cb));
5438                 skb_copy_decrypted(nskb, skb);
5439                 TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(nskb)->end_seq = start;
5440                 if (list)
5441                         __skb_queue_before(list, skb, nskb);
5442                 else
5443                         __skb_queue_tail(&tmp, nskb); /* defer rbtree insertion */
5444                 skb_set_owner_r(nskb, sk);
5445                 mptcp_skb_ext_move(nskb, skb);
5446
5447                 /* Copy data, releasing collapsed skbs. */
5448                 while (copy > 0) {
5449                         int offset = start - TCP_SKB_CB(skb)->seq;
5450                         int size = TCP_SKB_CB(skb)->end_seq - start;
5451
5452                         BUG_ON(offset < 0);
5453                         if (size > 0) {
5454                                 size = min(copy, size);
5455                                 if (skb_copy_bits(skb, offset, skb_put(nskb, size), size))
5456                                         BUG();
5457                                 TCP_SKB_CB(nskb)->end_seq += size;
5458                                 copy -= size;
5459                                 start += size;
5460                         }
5461                         if (!before(start, TCP_SKB_CB(skb)->end_seq)) {
5462                                 skb = tcp_collapse_one(sk, skb, list, root);
5463                                 if (!skb ||
5464                                     skb == tail ||
5465                                     !tcp_skb_can_collapse_rx(nskb, skb) ||
5466                                     (TCP_SKB_CB(skb)->tcp_flags & (TCPHDR_SYN | TCPHDR_FIN)))
5467                                         goto end;
5468                         }
5469                 }
5470         }
5471 end:
5472         skb_queue_walk_safe(&tmp, skb, n)
5473                 tcp_rbtree_insert(root, skb);
5474 }
5475
5476 /* Collapse ofo queue. Algorithm: select contiguous sequence of skbs
5477  * and tcp_collapse() them until all the queue is collapsed.
5478  */
5479 static void tcp_collapse_ofo_queue(struct sock *sk)
5480 {
5481         struct tcp_sock *tp = tcp_sk(sk);
5482         u32 range_truesize, sum_tiny = 0;
5483         struct sk_buff *skb, *head;
5484         u32 start, end;
5485
5486         skb = skb_rb_first(&tp->out_of_order_queue);
5487 new_range:
5488         if (!skb) {
5489                 tp->ooo_last_skb = skb_rb_last(&tp->out_of_order_queue);
5490                 return;
5491         }
5492         start = TCP_SKB_CB(skb)->seq;
5493         end = TCP_SKB_CB(skb)->end_seq;
5494         range_truesize = skb->truesize;
5495
5496         for (head = skb;;) {
5497                 skb = skb_rb_next(skb);
5498
5499                 /* Range is terminated when we see a gap or when
5500                  * we are at the queue end.
5501                  */
5502                 if (!skb ||
5503                     after(TCP_SKB_CB(skb)->seq, end) ||
5504                     before(TCP_SKB_CB(skb)->end_seq, start)) {
5505                         /* Do not attempt collapsing tiny skbs */
5506                         if (range_truesize != head->truesize ||
5507                             end - start >= SKB_WITH_OVERHEAD(PAGE_SIZE)) {
5508                                 tcp_collapse(sk, NULL, &tp->out_of_order_queue,
5509                                              head, skb, start, end);
5510                         } else {
5511                                 sum_tiny += range_truesize;
5512                                 if (sum_tiny > sk->sk_rcvbuf >> 3)
5513                                         return;
5514                         }
5515                         goto new_range;
5516                 }
5517
5518                 range_truesize += skb->truesize;
5519                 if (unlikely(before(TCP_SKB_CB(skb)->seq, start)))
5520                         start = TCP_SKB_CB(skb)->seq;
5521                 if (after(TCP_SKB_CB(skb)->end_seq, end))
5522                         end = TCP_SKB_CB(skb)->end_seq;
5523         }
5524 }
5525
5526 /*
5527  * Clean the out-of-order queue to make room.
5528  * We drop high sequences packets to :
5529  * 1) Let a chance for holes to be filled.
5530  *    This means we do not drop packets from ooo queue if their sequence
5531  *    is before incoming packet sequence.
5532  * 2) not add too big latencies if thousands of packets sit there.
5533  *    (But if application shrinks SO_RCVBUF, we could still end up
5534  *     freeing whole queue here)
5535  * 3) Drop at least 12.5 % of sk_rcvbuf to avoid malicious attacks.
5536  *
5537  * Return true if queue has shrunk.
5538  */
5539 static bool tcp_prune_ofo_queue(struct sock *sk, const struct sk_buff *in_skb)
5540 {
5541         struct tcp_sock *tp = tcp_sk(sk);
5542         struct rb_node *node, *prev;
5543         bool pruned = false;
5544         int goal;
5545
5546         if (RB_EMPTY_ROOT(&tp->out_of_order_queue))
5547                 return false;
5548
5549         goal = sk->sk_rcvbuf >> 3;
5550         node = &tp->ooo_last_skb->rbnode;
5551
5552         do {
5553                 struct sk_buff *skb = rb_to_skb(node);
5554
5555                 /* If incoming skb would land last in ofo queue, stop pruning. */
5556                 if (after(TCP_SKB_CB(in_skb)->seq, TCP_SKB_CB(skb)->seq))
5557                         break;
5558                 pruned = true;
5559                 prev = rb_prev(node);
5560                 rb_erase(node, &tp->out_of_order_queue);
5561                 goal -= skb->truesize;
5562                 tcp_drop_reason(sk, skb, SKB_DROP_REASON_TCP_OFO_QUEUE_PRUNE);
5563                 tp->ooo_last_skb = rb_to_skb(prev);
5564                 if (!prev || goal <= 0) {
5565                         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf &&
5566                             !tcp_under_memory_pressure(sk))
5567                                 break;
5568                         goal = sk->sk_rcvbuf >> 3;
5569                 }
5570                 node = prev;
5571         } while (node);
5572
5573         if (pruned) {
5574                 NET_INC_STATS(sock_net(sk), LINUX_MIB_OFOPRUNED);
5575                 /* Reset SACK state.  A conforming SACK implementation will
5576                  * do the same at a timeout based retransmit.  When a connection
5577                  * is in a sad state like this, we care only about integrity
5578                  * of the connection not performance.
5579                  */
5580                 if (tp->rx_opt.sack_ok)
5581                         tcp_sack_reset(&tp->rx_opt);
5582         }
5583         return pruned;
5584 }
5585
5586 /* Reduce allocated memory if we can, trying to get
5587  * the socket within its memory limits again.
5588  *
5589  * Return less than zero if we should start dropping frames
5590  * until the socket owning process reads some of the data
5591  * to stabilize the situation.
5592  */
5593 static int tcp_prune_queue(struct sock *sk, const struct sk_buff *in_skb)
5594 {
5595         struct tcp_sock *tp = tcp_sk(sk);
5596
5597         NET_INC_STATS(sock_net(sk), LINUX_MIB_PRUNECALLED);
5598
5599         if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf)
5600                 tcp_clamp_window(sk);
5601         else if (tcp_under_memory_pressure(sk))
5602                 tcp_adjust_rcv_ssthresh(sk);
5603
5604         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)
5605                 return 0;
5606
5607         tcp_collapse_ofo_queue(sk);
5608         if (!skb_queue_empty(&sk->sk_receive_queue))
5609                 tcp_collapse(sk, &sk->sk_receive_queue, NULL,
5610                              skb_peek(&sk->sk_receive_queue),
5611                              NULL,
5612                              tp->copied_seq, tp->rcv_nxt);
5613
5614         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)
5615                 return 0;
5616
5617         /* Collapsing did not help, destructive actions follow.
5618          * This must not ever occur. */
5619
5620         tcp_prune_ofo_queue(sk, in_skb);
5621
5622         if (atomic_read(&sk->sk_rmem_alloc) <= sk->sk_rcvbuf)
5623                 return 0;
5624
5625         /* If we are really being abused, tell the caller to silently
5626          * drop receive data on the floor.  It will get retransmitted
5627          * and hopefully then we'll have sufficient space.
5628          */
5629         NET_INC_STATS(sock_net(sk), LINUX_MIB_RCVPRUNED);
5630
5631         /* Massive buffer overcommit. */
5632         tp->pred_flags = 0;
5633         return -1;
5634 }
5635
5636 static bool tcp_should_expand_sndbuf(struct sock *sk)
5637 {
5638         const struct tcp_sock *tp = tcp_sk(sk);
5639
5640         /* If the user specified a specific send buffer setting, do
5641          * not modify it.
5642          */
5643         if (sk->sk_userlocks & SOCK_SNDBUF_LOCK)
5644                 return false;
5645
5646         /* If we are under global TCP memory pressure, do not expand.  */
5647         if (tcp_under_memory_pressure(sk)) {
5648                 int unused_mem = sk_unused_reserved_mem(sk);
5649
5650                 /* Adjust sndbuf according to reserved mem. But make sure
5651                  * it never goes below SOCK_MIN_SNDBUF.
5652                  * See sk_stream_moderate_sndbuf() for more details.
5653                  */
5654                 if (unused_mem > SOCK_MIN_SNDBUF)
5655                         WRITE_ONCE(sk->sk_sndbuf, unused_mem);
5656
5657                 return false;
5658         }
5659
5660         /* If we are under soft global TCP memory pressure, do not expand.  */
5661         if (sk_memory_allocated(sk) >= sk_prot_mem_limits(sk, 0))
5662                 return false;
5663
5664         /* If we filled the congestion window, do not expand.  */
5665         if (tcp_packets_in_flight(tp) >= tcp_snd_cwnd(tp))
5666                 return false;
5667
5668         return true;
5669 }
5670
5671 static void tcp_new_space(struct sock *sk)
5672 {
5673         struct tcp_sock *tp = tcp_sk(sk);
5674
5675         if (tcp_should_expand_sndbuf(sk)) {
5676                 tcp_sndbuf_expand(sk);
5677                 tp->snd_cwnd_stamp = tcp_jiffies32;
5678         }
5679
5680         INDIRECT_CALL_1(sk->sk_write_space, sk_stream_write_space, sk);
5681 }
5682
5683 /* Caller made space either from:
5684  * 1) Freeing skbs in rtx queues (after tp->snd_una has advanced)
5685  * 2) Sent skbs from output queue (and thus advancing tp->snd_nxt)
5686  *
5687  * We might be able to generate EPOLLOUT to the application if:
5688  * 1) Space consumed in output/rtx queues is below sk->sk_sndbuf/2
5689  * 2) notsent amount (tp->write_seq - tp->snd_nxt) became
5690  *    small enough that tcp_stream_memory_free() decides it
5691  *    is time to generate EPOLLOUT.
5692  */
5693 void tcp_check_space(struct sock *sk)
5694 {
5695         /* pairs with tcp_poll() */
5696         smp_mb();
5697         if (sk->sk_socket &&
5698             test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
5699                 tcp_new_space(sk);
5700                 if (!test_bit(SOCK_NOSPACE, &sk->sk_socket->flags))
5701                         tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
5702         }
5703 }
5704
5705 static inline void tcp_data_snd_check(struct sock *sk)
5706 {
5707         tcp_push_pending_frames(sk);
5708         tcp_check_space(sk);
5709 }
5710
5711 /*
5712  * Check if sending an ack is needed.
5713  */
5714 static void __tcp_ack_snd_check(struct sock *sk, int ofo_possible)
5715 {
5716         struct tcp_sock *tp = tcp_sk(sk);
5717         unsigned long rtt, delay;
5718
5719             /* More than one full frame received... */
5720         if (((tp->rcv_nxt - tp->rcv_wup) > inet_csk(sk)->icsk_ack.rcv_mss &&
5721              /* ... and right edge of window advances far enough.
5722               * (tcp_recvmsg() will send ACK otherwise).
5723               * If application uses SO_RCVLOWAT, we want send ack now if
5724               * we have not received enough bytes to satisfy the condition.
5725               */
5726             (tp->rcv_nxt - tp->copied_seq < sk->sk_rcvlowat ||
5727              __tcp_select_window(sk) >= tp->rcv_wnd)) ||
5728             /* We ACK each frame or... */
5729             tcp_in_quickack_mode(sk) ||
5730             /* Protocol state mandates a one-time immediate ACK */
5731             inet_csk(sk)->icsk_ack.pending & ICSK_ACK_NOW) {
5732                 /* If we are running from __release_sock() in user context,
5733                  * Defer the ack until tcp_release_cb().
5734                  */
5735                 if (sock_owned_by_user_nocheck(sk) &&
5736                     READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_backlog_ack_defer)) {
5737                         set_bit(TCP_ACK_DEFERRED, &sk->sk_tsq_flags);
5738                         return;
5739                 }
5740 send_now:
5741                 tcp_send_ack(sk);
5742                 return;
5743         }
5744
5745         if (!ofo_possible || RB_EMPTY_ROOT(&tp->out_of_order_queue)) {
5746                 tcp_send_delayed_ack(sk);
5747                 return;
5748         }
5749
5750         if (!tcp_is_sack(tp) ||
5751             tp->compressed_ack >= READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_comp_sack_nr))
5752                 goto send_now;
5753
5754         if (tp->compressed_ack_rcv_nxt != tp->rcv_nxt) {
5755                 tp->compressed_ack_rcv_nxt = tp->rcv_nxt;
5756                 tp->dup_ack_counter = 0;
5757         }
5758         if (tp->dup_ack_counter < TCP_FASTRETRANS_THRESH) {
5759                 tp->dup_ack_counter++;
5760                 goto send_now;
5761         }
5762         tp->compressed_ack++;
5763         if (hrtimer_is_queued(&tp->compressed_ack_timer))
5764                 return;
5765
5766         /* compress ack timer : 5 % of rtt, but no more than tcp_comp_sack_delay_ns */
5767
5768         rtt = tp->rcv_rtt_est.rtt_us;
5769         if (tp->srtt_us && tp->srtt_us < rtt)
5770                 rtt = tp->srtt_us;
5771
5772         delay = min_t(unsigned long,
5773                       READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_comp_sack_delay_ns),
5774                       rtt * (NSEC_PER_USEC >> 3)/20);
5775         sock_hold(sk);
5776         hrtimer_start_range_ns(&tp->compressed_ack_timer, ns_to_ktime(delay),
5777                                READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_comp_sack_slack_ns),
5778                                HRTIMER_MODE_REL_PINNED_SOFT);
5779 }
5780
5781 static inline void tcp_ack_snd_check(struct sock *sk)
5782 {
5783         if (!inet_csk_ack_scheduled(sk)) {
5784                 /* We sent a data segment already. */
5785                 return;
5786         }
5787         __tcp_ack_snd_check(sk, 1);
5788 }
5789
5790 /*
5791  *      This routine is only called when we have urgent data
5792  *      signaled. Its the 'slow' part of tcp_urg. It could be
5793  *      moved inline now as tcp_urg is only called from one
5794  *      place. We handle URGent data wrong. We have to - as
5795  *      BSD still doesn't use the correction from RFC961.
5796  *      For 1003.1g we should support a new option TCP_STDURG to permit
5797  *      either form (or just set the sysctl tcp_stdurg).
5798  */
5799
5800 static void tcp_check_urg(struct sock *sk, const struct tcphdr *th)
5801 {
5802         struct tcp_sock *tp = tcp_sk(sk);
5803         u32 ptr = ntohs(th->urg_ptr);
5804
5805         if (ptr && !READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_stdurg))
5806                 ptr--;
5807         ptr += ntohl(th->seq);
5808
5809         /* Ignore urgent data that we've already seen and read. */
5810         if (after(tp->copied_seq, ptr))
5811                 return;
5812
5813         /* Do not replay urg ptr.
5814          *
5815          * NOTE: interesting situation not covered by specs.
5816          * Misbehaving sender may send urg ptr, pointing to segment,
5817          * which we already have in ofo queue. We are not able to fetch
5818          * such data and will stay in TCP_URG_NOTYET until will be eaten
5819          * by recvmsg(). Seems, we are not obliged to handle such wicked
5820          * situations. But it is worth to think about possibility of some
5821          * DoSes using some hypothetical application level deadlock.
5822          */
5823         if (before(ptr, tp->rcv_nxt))
5824                 return;
5825
5826         /* Do we already have a newer (or duplicate) urgent pointer? */
5827         if (tp->urg_data && !after(ptr, tp->urg_seq))
5828                 return;
5829
5830         /* Tell the world about our new urgent pointer. */
5831         sk_send_sigurg(sk);
5832
5833         /* We may be adding urgent data when the last byte read was
5834          * urgent. To do this requires some care. We cannot just ignore
5835          * tp->copied_seq since we would read the last urgent byte again
5836          * as data, nor can we alter copied_seq until this data arrives
5837          * or we break the semantics of SIOCATMARK (and thus sockatmark())
5838          *
5839          * NOTE. Double Dutch. Rendering to plain English: author of comment
5840          * above did something sort of  send("A", MSG_OOB); send("B", MSG_OOB);
5841          * and expect that both A and B disappear from stream. This is _wrong_.
5842          * Though this happens in BSD with high probability, this is occasional.
5843          * Any application relying on this is buggy. Note also, that fix "works"
5844          * only in this artificial test. Insert some normal data between A and B and we will
5845          * decline of BSD again. Verdict: it is better to remove to trap
5846          * buggy users.
5847          */
5848         if (tp->urg_seq == tp->copied_seq && tp->urg_data &&
5849             !sock_flag(sk, SOCK_URGINLINE) && tp->copied_seq != tp->rcv_nxt) {
5850                 struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
5851                 tp->copied_seq++;
5852                 if (skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq)) {
5853                         __skb_unlink(skb, &sk->sk_receive_queue);
5854                         __kfree_skb(skb);
5855                 }
5856         }
5857
5858         WRITE_ONCE(tp->urg_data, TCP_URG_NOTYET);
5859         WRITE_ONCE(tp->urg_seq, ptr);
5860
5861         /* Disable header prediction. */
5862         tp->pred_flags = 0;
5863 }
5864
5865 /* This is the 'fast' part of urgent handling. */
5866 static void tcp_urg(struct sock *sk, struct sk_buff *skb, const struct tcphdr *th)
5867 {
5868         struct tcp_sock *tp = tcp_sk(sk);
5869
5870         /* Check if we get a new urgent pointer - normally not. */
5871         if (unlikely(th->urg))
5872                 tcp_check_urg(sk, th);
5873
5874         /* Do we wait for any urgent data? - normally not... */
5875         if (unlikely(tp->urg_data == TCP_URG_NOTYET)) {
5876                 u32 ptr = tp->urg_seq - ntohl(th->seq) + (th->doff * 4) -
5877                           th->syn;
5878
5879                 /* Is the urgent pointer pointing into this packet? */
5880                 if (ptr < skb->len) {
5881                         u8 tmp;
5882                         if (skb_copy_bits(skb, ptr, &tmp, 1))
5883                                 BUG();
5884                         WRITE_ONCE(tp->urg_data, TCP_URG_VALID | tmp);
5885                         if (!sock_flag(sk, SOCK_DEAD))
5886                                 sk->sk_data_ready(sk);
5887                 }
5888         }
5889 }
5890
5891 /* Accept RST for rcv_nxt - 1 after a FIN.
5892  * When tcp connections are abruptly terminated from Mac OSX (via ^C), a
5893  * FIN is sent followed by a RST packet. The RST is sent with the same
5894  * sequence number as the FIN, and thus according to RFC 5961 a challenge
5895  * ACK should be sent. However, Mac OSX rate limits replies to challenge
5896  * ACKs on the closed socket. In addition middleboxes can drop either the
5897  * challenge ACK or a subsequent RST.
5898  */
5899 static bool tcp_reset_check(const struct sock *sk, const struct sk_buff *skb)
5900 {
5901         const struct tcp_sock *tp = tcp_sk(sk);
5902
5903         return unlikely(TCP_SKB_CB(skb)->seq == (tp->rcv_nxt - 1) &&
5904                         (1 << sk->sk_state) & (TCPF_CLOSE_WAIT | TCPF_LAST_ACK |
5905                                                TCPF_CLOSING));
5906 }
5907
5908 /* Does PAWS and seqno based validation of an incoming segment, flags will
5909  * play significant role here.
5910  */
5911 static bool tcp_validate_incoming(struct sock *sk, struct sk_buff *skb,
5912                                   const struct tcphdr *th, int syn_inerr)
5913 {
5914         struct tcp_sock *tp = tcp_sk(sk);
5915         SKB_DR(reason);
5916
5917         /* RFC1323: H1. Apply PAWS check first. */
5918         if (tcp_fast_parse_options(sock_net(sk), skb, th, tp) &&
5919             tp->rx_opt.saw_tstamp &&
5920             tcp_paws_discard(sk, skb)) {
5921                 if (!th->rst) {
5922                         if (unlikely(th->syn))
5923                                 goto syn_challenge;
5924                         NET_INC_STATS(sock_net(sk), LINUX_MIB_PAWSESTABREJECTED);
5925                         if (!tcp_oow_rate_limited(sock_net(sk), skb,
5926                                                   LINUX_MIB_TCPACKSKIPPEDPAWS,
5927                                                   &tp->last_oow_ack_time))
5928                                 tcp_send_dupack(sk, skb);
5929                         SKB_DR_SET(reason, TCP_RFC7323_PAWS);
5930                         goto discard;
5931                 }
5932                 /* Reset is accepted even if it did not pass PAWS. */
5933         }
5934
5935         /* Step 1: check sequence number */
5936         reason = tcp_sequence(tp, TCP_SKB_CB(skb)->seq, TCP_SKB_CB(skb)->end_seq);
5937         if (reason) {
5938                 /* RFC793, page 37: "In all states except SYN-SENT, all reset
5939                  * (RST) segments are validated by checking their SEQ-fields."
5940                  * And page 69: "If an incoming segment is not acceptable,
5941                  * an acknowledgment should be sent in reply (unless the RST
5942                  * bit is set, if so drop the segment and return)".
5943                  */
5944                 if (!th->rst) {
5945                         if (th->syn)
5946                                 goto syn_challenge;
5947                         if (!tcp_oow_rate_limited(sock_net(sk), skb,
5948                                                   LINUX_MIB_TCPACKSKIPPEDSEQ,
5949                                                   &tp->last_oow_ack_time))
5950                                 tcp_send_dupack(sk, skb);
5951                 } else if (tcp_reset_check(sk, skb)) {
5952                         goto reset;
5953                 }
5954                 goto discard;
5955         }
5956
5957         /* Step 2: check RST bit */
5958         if (th->rst) {
5959                 /* RFC 5961 3.2 (extend to match against (RCV.NXT - 1) after a
5960                  * FIN and SACK too if available):
5961                  * If seq num matches RCV.NXT or (RCV.NXT - 1) after a FIN, or
5962                  * the right-most SACK block,
5963                  * then
5964                  *     RESET the connection
5965                  * else
5966                  *     Send a challenge ACK
5967                  */
5968                 if (TCP_SKB_CB(skb)->seq == tp->rcv_nxt ||
5969                     tcp_reset_check(sk, skb))
5970                         goto reset;
5971
5972                 if (tcp_is_sack(tp) && tp->rx_opt.num_sacks > 0) {
5973                         struct tcp_sack_block *sp = &tp->selective_acks[0];
5974                         int max_sack = sp[0].end_seq;
5975                         int this_sack;
5976
5977                         for (this_sack = 1; this_sack < tp->rx_opt.num_sacks;
5978                              ++this_sack) {
5979                                 max_sack = after(sp[this_sack].end_seq,
5980                                                  max_sack) ?
5981                                         sp[this_sack].end_seq : max_sack;
5982                         }
5983
5984                         if (TCP_SKB_CB(skb)->seq == max_sack)
5985                                 goto reset;
5986                 }
5987
5988                 /* Disable TFO if RST is out-of-order
5989                  * and no data has been received
5990                  * for current active TFO socket
5991                  */
5992                 if (tp->syn_fastopen && !tp->data_segs_in &&
5993                     sk->sk_state == TCP_ESTABLISHED)
5994                         tcp_fastopen_active_disable(sk);
5995                 tcp_send_challenge_ack(sk);
5996                 SKB_DR_SET(reason, TCP_RESET);
5997                 goto discard;
5998         }
5999
6000         /* step 3: check security and precedence [ignored] */
6001
6002         /* step 4: Check for a SYN
6003          * RFC 5961 4.2 : Send a challenge ack
6004          */
6005         if (th->syn) {
6006                 if (sk->sk_state == TCP_SYN_RECV && sk->sk_socket && th->ack &&
6007                     TCP_SKB_CB(skb)->seq + 1 == TCP_SKB_CB(skb)->end_seq &&
6008                     TCP_SKB_CB(skb)->seq + 1 == tp->rcv_nxt &&
6009                     TCP_SKB_CB(skb)->ack_seq == tp->snd_nxt)
6010                         goto pass;
6011 syn_challenge:
6012                 if (syn_inerr)
6013                         TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
6014                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNCHALLENGE);
6015                 tcp_send_challenge_ack(sk);
6016                 SKB_DR_SET(reason, TCP_INVALID_SYN);
6017                 goto discard;
6018         }
6019
6020 pass:
6021         bpf_skops_parse_hdr(sk, skb);
6022
6023         return true;
6024
6025 discard:
6026         tcp_drop_reason(sk, skb, reason);
6027         return false;
6028
6029 reset:
6030         tcp_reset(sk, skb);
6031         __kfree_skb(skb);
6032         return false;
6033 }
6034
6035 /*
6036  *      TCP receive function for the ESTABLISHED state.
6037  *
6038  *      It is split into a fast path and a slow path. The fast path is
6039  *      disabled when:
6040  *      - A zero window was announced from us - zero window probing
6041  *        is only handled properly in the slow path.
6042  *      - Out of order segments arrived.
6043  *      - Urgent data is expected.
6044  *      - There is no buffer space left
6045  *      - Unexpected TCP flags/window values/header lengths are received
6046  *        (detected by checking the TCP header against pred_flags)
6047  *      - Data is sent in both directions. Fast path only supports pure senders
6048  *        or pure receivers (this means either the sequence number or the ack
6049  *        value must stay constant)
6050  *      - Unexpected TCP option.
6051  *
6052  *      When these conditions are not satisfied it drops into a standard
6053  *      receive procedure patterned after RFC793 to handle all cases.
6054  *      The first three cases are guaranteed by proper pred_flags setting,
6055  *      the rest is checked inline. Fast processing is turned on in
6056  *      tcp_data_queue when everything is OK.
6057  */
6058 void tcp_rcv_established(struct sock *sk, struct sk_buff *skb)
6059 {
6060         enum skb_drop_reason reason = SKB_DROP_REASON_NOT_SPECIFIED;
6061         const struct tcphdr *th = (const struct tcphdr *)skb->data;
6062         struct tcp_sock *tp = tcp_sk(sk);
6063         unsigned int len = skb->len;
6064
6065         /* TCP congestion window tracking */
6066         trace_tcp_probe(sk, skb);
6067
6068         tcp_mstamp_refresh(tp);
6069         if (unlikely(!rcu_access_pointer(sk->sk_rx_dst)))
6070                 inet_csk(sk)->icsk_af_ops->sk_rx_dst_set(sk, skb);
6071         /*
6072          *      Header prediction.
6073          *      The code loosely follows the one in the famous
6074          *      "30 instruction TCP receive" Van Jacobson mail.
6075          *
6076          *      Van's trick is to deposit buffers into socket queue
6077          *      on a device interrupt, to call tcp_recv function
6078          *      on the receive process context and checksum and copy
6079          *      the buffer to user space. smart...
6080          *
6081          *      Our current scheme is not silly either but we take the
6082          *      extra cost of the net_bh soft interrupt processing...
6083          *      We do checksum and copy also but from device to kernel.
6084          */
6085
6086         tp->rx_opt.saw_tstamp = 0;
6087
6088         /*      pred_flags is 0xS?10 << 16 + snd_wnd
6089          *      if header_prediction is to be made
6090          *      'S' will always be tp->tcp_header_len >> 2
6091          *      '?' will be 0 for the fast path, otherwise pred_flags is 0 to
6092          *  turn it off (when there are holes in the receive
6093          *       space for instance)
6094          *      PSH flag is ignored.
6095          */
6096
6097         if ((tcp_flag_word(th) & TCP_HP_BITS) == tp->pred_flags &&
6098             TCP_SKB_CB(skb)->seq == tp->rcv_nxt &&
6099             !after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
6100                 int tcp_header_len = tp->tcp_header_len;
6101
6102                 /* Timestamp header prediction: tcp_header_len
6103                  * is automatically equal to th->doff*4 due to pred_flags
6104                  * match.
6105                  */
6106
6107                 /* Check timestamp */
6108                 if (tcp_header_len == sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) {
6109                         /* No? Slow path! */
6110                         if (!tcp_parse_aligned_timestamp(tp, th))
6111                                 goto slow_path;
6112
6113                         /* If PAWS failed, check it more carefully in slow path */
6114                         if ((s32)(tp->rx_opt.rcv_tsval - tp->rx_opt.ts_recent) < 0)
6115                                 goto slow_path;
6116
6117                         /* DO NOT update ts_recent here, if checksum fails
6118                          * and timestamp was corrupted part, it will result
6119                          * in a hung connection since we will drop all
6120                          * future packets due to the PAWS test.
6121                          */
6122                 }
6123
6124                 if (len <= tcp_header_len) {
6125                         /* Bulk data transfer: sender */
6126                         if (len == tcp_header_len) {
6127                                 /* Predicted packet is in window by definition.
6128                                  * seq == rcv_nxt and rcv_wup <= rcv_nxt.
6129                                  * Hence, check seq<=rcv_wup reduces to:
6130                                  */
6131                                 if (tcp_header_len ==
6132                                     (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&
6133                                     tp->rcv_nxt == tp->rcv_wup)
6134                                         tcp_store_ts_recent(tp);
6135
6136                                 /* We know that such packets are checksummed
6137                                  * on entry.
6138                                  */
6139                                 tcp_ack(sk, skb, 0);
6140                                 __kfree_skb(skb);
6141                                 tcp_data_snd_check(sk);
6142                                 /* When receiving pure ack in fast path, update
6143                                  * last ts ecr directly instead of calling
6144                                  * tcp_rcv_rtt_measure_ts()
6145                                  */
6146                                 tp->rcv_rtt_last_tsecr = tp->rx_opt.rcv_tsecr;
6147                                 return;
6148                         } else { /* Header too small */
6149                                 reason = SKB_DROP_REASON_PKT_TOO_SMALL;
6150                                 TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
6151                                 goto discard;
6152                         }
6153                 } else {
6154                         int eaten = 0;
6155                         bool fragstolen = false;
6156
6157                         if (tcp_checksum_complete(skb))
6158                                 goto csum_error;
6159
6160                         if ((int)skb->truesize > sk->sk_forward_alloc)
6161                                 goto step5;
6162
6163                         /* Predicted packet is in window by definition.
6164                          * seq == rcv_nxt and rcv_wup <= rcv_nxt.
6165                          * Hence, check seq<=rcv_wup reduces to:
6166                          */
6167                         if (tcp_header_len ==
6168                             (sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED) &&
6169                             tp->rcv_nxt == tp->rcv_wup)
6170                                 tcp_store_ts_recent(tp);
6171
6172                         tcp_rcv_rtt_measure_ts(sk, skb);
6173
6174                         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPHPHITS);
6175
6176                         /* Bulk data transfer: receiver */
6177                         skb_dst_drop(skb);
6178                         __skb_pull(skb, tcp_header_len);
6179                         eaten = tcp_queue_rcv(sk, skb, &fragstolen);
6180
6181                         tcp_event_data_recv(sk, skb);
6182
6183                         if (TCP_SKB_CB(skb)->ack_seq != tp->snd_una) {
6184                                 /* Well, only one small jumplet in fast path... */
6185                                 tcp_ack(sk, skb, FLAG_DATA);
6186                                 tcp_data_snd_check(sk);
6187                                 if (!inet_csk_ack_scheduled(sk))
6188                                         goto no_ack;
6189                         } else {
6190                                 tcp_update_wl(tp, TCP_SKB_CB(skb)->seq);
6191                         }
6192
6193                         __tcp_ack_snd_check(sk, 0);
6194 no_ack:
6195                         if (eaten)
6196                                 kfree_skb_partial(skb, fragstolen);
6197                         tcp_data_ready(sk);
6198                         return;
6199                 }
6200         }
6201
6202 slow_path:
6203         if (len < (th->doff << 2) || tcp_checksum_complete(skb))
6204                 goto csum_error;
6205
6206         if (!th->ack && !th->rst && !th->syn) {
6207                 reason = SKB_DROP_REASON_TCP_FLAGS;
6208                 goto discard;
6209         }
6210
6211         /*
6212          *      Standard slow path.
6213          */
6214
6215         if (!tcp_validate_incoming(sk, skb, th, 1))
6216                 return;
6217
6218 step5:
6219         reason = tcp_ack(sk, skb, FLAG_SLOWPATH | FLAG_UPDATE_TS_RECENT);
6220         if ((int)reason < 0) {
6221                 reason = -reason;
6222                 goto discard;
6223         }
6224         tcp_rcv_rtt_measure_ts(sk, skb);
6225
6226         /* Process urgent data. */
6227         tcp_urg(sk, skb, th);
6228
6229         /* step 7: process the segment text */
6230         tcp_data_queue(sk, skb);
6231
6232         tcp_data_snd_check(sk);
6233         tcp_ack_snd_check(sk);
6234         return;
6235
6236 csum_error:
6237         reason = SKB_DROP_REASON_TCP_CSUM;
6238         trace_tcp_bad_csum(skb);
6239         TCP_INC_STATS(sock_net(sk), TCP_MIB_CSUMERRORS);
6240         TCP_INC_STATS(sock_net(sk), TCP_MIB_INERRS);
6241
6242 discard:
6243         tcp_drop_reason(sk, skb, reason);
6244 }
6245 EXPORT_SYMBOL(tcp_rcv_established);
6246
6247 void tcp_init_transfer(struct sock *sk, int bpf_op, struct sk_buff *skb)
6248 {
6249         struct inet_connection_sock *icsk = inet_csk(sk);
6250         struct tcp_sock *tp = tcp_sk(sk);
6251
6252         tcp_mtup_init(sk);
6253         icsk->icsk_af_ops->rebuild_header(sk);
6254         tcp_init_metrics(sk);
6255
6256         /* Initialize the congestion window to start the transfer.
6257          * Cut cwnd down to 1 per RFC5681 if SYN or SYN-ACK has been
6258          * retransmitted. In light of RFC6298 more aggressive 1sec
6259          * initRTO, we only reset cwnd when more than 1 SYN/SYN-ACK
6260          * retransmission has occurred.
6261          */
6262         if (tp->total_retrans > 1 && tp->undo_marker)
6263                 tcp_snd_cwnd_set(tp, 1);
6264         else
6265                 tcp_snd_cwnd_set(tp, tcp_init_cwnd(tp, __sk_dst_get(sk)));
6266         tp->snd_cwnd_stamp = tcp_jiffies32;
6267
6268         bpf_skops_established(sk, bpf_op, skb);
6269         /* Initialize congestion control unless BPF initialized it already: */
6270         if (!icsk->icsk_ca_initialized)
6271                 tcp_init_congestion_control(sk);
6272         tcp_init_buffer_space(sk);
6273 }
6274
6275 void tcp_finish_connect(struct sock *sk, struct sk_buff *skb)
6276 {
6277         struct tcp_sock *tp = tcp_sk(sk);
6278         struct inet_connection_sock *icsk = inet_csk(sk);
6279
6280         tcp_ao_finish_connect(sk, skb);
6281         tcp_set_state(sk, TCP_ESTABLISHED);
6282         icsk->icsk_ack.lrcvtime = tcp_jiffies32;
6283
6284         if (skb) {
6285                 icsk->icsk_af_ops->sk_rx_dst_set(sk, skb);
6286                 security_inet_conn_established(sk, skb);
6287                 sk_mark_napi_id(sk, skb);
6288         }
6289
6290         tcp_init_transfer(sk, BPF_SOCK_OPS_ACTIVE_ESTABLISHED_CB, skb);
6291
6292         /* Prevent spurious tcp_cwnd_restart() on first data
6293          * packet.
6294          */
6295         tp->lsndtime = tcp_jiffies32;
6296
6297         if (sock_flag(sk, SOCK_KEEPOPEN))
6298                 inet_csk_reset_keepalive_timer(sk, keepalive_time_when(tp));
6299
6300         if (!tp->rx_opt.snd_wscale)
6301                 __tcp_fast_path_on(tp, tp->snd_wnd);
6302         else
6303                 tp->pred_flags = 0;
6304 }
6305
6306 static bool tcp_rcv_fastopen_synack(struct sock *sk, struct sk_buff *synack,
6307                                     struct tcp_fastopen_cookie *cookie)
6308 {
6309         struct tcp_sock *tp = tcp_sk(sk);
6310         struct sk_buff *data = tp->syn_data ? tcp_rtx_queue_head(sk) : NULL;
6311         u16 mss = tp->rx_opt.mss_clamp, try_exp = 0;
6312         bool syn_drop = false;
6313
6314         if (mss == tp->rx_opt.user_mss) {
6315                 struct tcp_options_received opt;
6316
6317                 /* Get original SYNACK MSS value if user MSS sets mss_clamp */
6318                 tcp_clear_options(&opt);
6319                 opt.user_mss = opt.mss_clamp = 0;
6320                 tcp_parse_options(sock_net(sk), synack, &opt, 0, NULL);
6321                 mss = opt.mss_clamp;
6322         }
6323
6324         if (!tp->syn_fastopen) {
6325                 /* Ignore an unsolicited cookie */
6326                 cookie->len = -1;
6327         } else if (tp->total_retrans) {
6328                 /* SYN timed out and the SYN-ACK neither has a cookie nor
6329                  * acknowledges data. Presumably the remote received only
6330                  * the retransmitted (regular) SYNs: either the original
6331                  * SYN-data or the corresponding SYN-ACK was dropped.
6332                  */
6333                 syn_drop = (cookie->len < 0 && data);
6334         } else if (cookie->len < 0 && !tp->syn_data) {
6335                 /* We requested a cookie but didn't get it. If we did not use
6336                  * the (old) exp opt format then try so next time (try_exp=1).
6337                  * Otherwise we go back to use the RFC7413 opt (try_exp=2).
6338                  */
6339                 try_exp = tp->syn_fastopen_exp ? 2 : 1;
6340         }
6341
6342         tcp_fastopen_cache_set(sk, mss, cookie, syn_drop, try_exp);
6343
6344         if (data) { /* Retransmit unacked data in SYN */
6345                 if (tp->total_retrans)
6346                         tp->fastopen_client_fail = TFO_SYN_RETRANSMITTED;
6347                 else
6348                         tp->fastopen_client_fail = TFO_DATA_NOT_ACKED;
6349                 skb_rbtree_walk_from(data)
6350                          tcp_mark_skb_lost(sk, data);
6351                 tcp_non_congestion_loss_retransmit(sk);
6352                 NET_INC_STATS(sock_net(sk),
6353                                 LINUX_MIB_TCPFASTOPENACTIVEFAIL);
6354                 return true;
6355         }
6356         tp->syn_data_acked = tp->syn_data;
6357         if (tp->syn_data_acked) {
6358                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFASTOPENACTIVE);
6359                 /* SYN-data is counted as two separate packets in tcp_ack() */
6360                 if (tp->delivered > 1)
6361                         --tp->delivered;
6362         }
6363
6364         tcp_fastopen_add_skb(sk, synack);
6365
6366         return false;
6367 }
6368
6369 static void smc_check_reset_syn(struct tcp_sock *tp)
6370 {
6371 #if IS_ENABLED(CONFIG_SMC)
6372         if (static_branch_unlikely(&tcp_have_smc)) {
6373                 if (tp->syn_smc && !tp->rx_opt.smc_ok)
6374                         tp->syn_smc = 0;
6375         }
6376 #endif
6377 }
6378
6379 static void tcp_try_undo_spurious_syn(struct sock *sk)
6380 {
6381         struct tcp_sock *tp = tcp_sk(sk);
6382         u32 syn_stamp;
6383
6384         /* undo_marker is set when SYN or SYNACK times out. The timeout is
6385          * spurious if the ACK's timestamp option echo value matches the
6386          * original SYN timestamp.
6387          */
6388         syn_stamp = tp->retrans_stamp;
6389         if (tp->undo_marker && syn_stamp && tp->rx_opt.saw_tstamp &&
6390             syn_stamp == tp->rx_opt.rcv_tsecr)
6391                 tp->undo_marker = 0;
6392 }
6393
6394 static int tcp_rcv_synsent_state_process(struct sock *sk, struct sk_buff *skb,
6395                                          const struct tcphdr *th)
6396 {
6397         struct inet_connection_sock *icsk = inet_csk(sk);
6398         struct tcp_sock *tp = tcp_sk(sk);
6399         struct tcp_fastopen_cookie foc = { .len = -1 };
6400         int saved_clamp = tp->rx_opt.mss_clamp;
6401         bool fastopen_fail;
6402         SKB_DR(reason);
6403
6404         tcp_parse_options(sock_net(sk), skb, &tp->rx_opt, 0, &foc);
6405         if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr)
6406                 tp->rx_opt.rcv_tsecr -= tp->tsoffset;
6407
6408         if (th->ack) {
6409                 /* rfc793:
6410                  * "If the state is SYN-SENT then
6411                  *    first check the ACK bit
6412                  *      If the ACK bit is set
6413                  *        If SEG.ACK =< ISS, or SEG.ACK > SND.NXT, send
6414                  *        a reset (unless the RST bit is set, if so drop
6415                  *        the segment and return)"
6416                  */
6417                 if (!after(TCP_SKB_CB(skb)->ack_seq, tp->snd_una) ||
6418                     after(TCP_SKB_CB(skb)->ack_seq, tp->snd_nxt)) {
6419                         /* Previous FIN/ACK or RST/ACK might be ignored. */
6420                         if (icsk->icsk_retransmits == 0)
6421                                 inet_csk_reset_xmit_timer(sk,
6422                                                 ICSK_TIME_RETRANS,
6423                                                 TCP_TIMEOUT_MIN, TCP_RTO_MAX);
6424                         SKB_DR_SET(reason, TCP_INVALID_ACK_SEQUENCE);
6425                         goto reset_and_undo;
6426                 }
6427
6428                 if (tp->rx_opt.saw_tstamp && tp->rx_opt.rcv_tsecr &&
6429                     !between(tp->rx_opt.rcv_tsecr, tp->retrans_stamp,
6430                              tcp_time_stamp_ts(tp))) {
6431                         NET_INC_STATS(sock_net(sk),
6432                                         LINUX_MIB_PAWSACTIVEREJECTED);
6433                         SKB_DR_SET(reason, TCP_RFC7323_PAWS);
6434                         goto reset_and_undo;
6435                 }
6436
6437                 /* Now ACK is acceptable.
6438                  *
6439                  * "If the RST bit is set
6440                  *    If the ACK was acceptable then signal the user "error:
6441                  *    connection reset", drop the segment, enter CLOSED state,
6442                  *    delete TCB, and return."
6443                  */
6444
6445                 if (th->rst) {
6446                         tcp_reset(sk, skb);
6447 consume:
6448                         __kfree_skb(skb);
6449                         return 0;
6450                 }
6451
6452                 /* rfc793:
6453                  *   "fifth, if neither of the SYN or RST bits is set then
6454                  *    drop the segment and return."
6455                  *
6456                  *    See note below!
6457                  *                                        --ANK(990513)
6458                  */
6459                 if (!th->syn) {
6460                         SKB_DR_SET(reason, TCP_FLAGS);
6461                         goto discard_and_undo;
6462                 }
6463                 /* rfc793:
6464                  *   "If the SYN bit is on ...
6465                  *    are acceptable then ...
6466                  *    (our SYN has been ACKed), change the connection
6467                  *    state to ESTABLISHED..."
6468                  */
6469
6470                 tcp_ecn_rcv_synack(tp, th);
6471
6472                 tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
6473                 tcp_try_undo_spurious_syn(sk);
6474                 tcp_ack(sk, skb, FLAG_SLOWPATH);
6475
6476                 /* Ok.. it's good. Set up sequence numbers and
6477                  * move to established.
6478                  */
6479                 WRITE_ONCE(tp->rcv_nxt, TCP_SKB_CB(skb)->seq + 1);
6480                 tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1;
6481
6482                 /* RFC1323: The window in SYN & SYN/ACK segments is
6483                  * never scaled.
6484                  */
6485                 tp->snd_wnd = ntohs(th->window);
6486
6487                 if (!tp->rx_opt.wscale_ok) {
6488                         tp->rx_opt.snd_wscale = tp->rx_opt.rcv_wscale = 0;
6489                         WRITE_ONCE(tp->window_clamp,
6490                                    min(tp->window_clamp, 65535U));
6491                 }
6492
6493                 if (tp->rx_opt.saw_tstamp) {
6494                         tp->rx_opt.tstamp_ok       = 1;
6495                         tp->tcp_header_len =
6496                                 sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
6497                         tp->advmss          -= TCPOLEN_TSTAMP_ALIGNED;
6498                         tcp_store_ts_recent(tp);
6499                 } else {
6500                         tp->tcp_header_len = sizeof(struct tcphdr);
6501                 }
6502
6503                 tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
6504                 tcp_initialize_rcv_mss(sk);
6505
6506                 /* Remember, tcp_poll() does not lock socket!
6507                  * Change state from SYN-SENT only after copied_seq
6508                  * is initialized. */
6509                 WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
6510
6511                 smc_check_reset_syn(tp);
6512
6513                 smp_mb();
6514
6515                 tcp_finish_connect(sk, skb);
6516
6517                 fastopen_fail = (tp->syn_fastopen || tp->syn_data) &&
6518                                 tcp_rcv_fastopen_synack(sk, skb, &foc);
6519
6520                 if (!sock_flag(sk, SOCK_DEAD)) {
6521                         sk->sk_state_change(sk);
6522                         sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
6523                 }
6524                 if (fastopen_fail)
6525                         return -1;
6526                 if (sk->sk_write_pending ||
6527                     READ_ONCE(icsk->icsk_accept_queue.rskq_defer_accept) ||
6528                     inet_csk_in_pingpong_mode(sk)) {
6529                         /* Save one ACK. Data will be ready after
6530                          * several ticks, if write_pending is set.
6531                          *
6532                          * It may be deleted, but with this feature tcpdumps
6533                          * look so _wonderfully_ clever, that I was not able
6534                          * to stand against the temptation 8)     --ANK
6535                          */
6536                         inet_csk_schedule_ack(sk);
6537                         tcp_enter_quickack_mode(sk, TCP_MAX_QUICKACKS);
6538                         inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
6539                                                   TCP_DELACK_MAX, TCP_RTO_MAX);
6540                         goto consume;
6541                 }
6542                 tcp_send_ack(sk);
6543                 return -1;
6544         }
6545
6546         /* No ACK in the segment */
6547
6548         if (th->rst) {
6549                 /* rfc793:
6550                  * "If the RST bit is set
6551                  *
6552                  *      Otherwise (no ACK) drop the segment and return."
6553                  */
6554                 SKB_DR_SET(reason, TCP_RESET);
6555                 goto discard_and_undo;
6556         }
6557
6558         /* PAWS check. */
6559         if (tp->rx_opt.ts_recent_stamp && tp->rx_opt.saw_tstamp &&
6560             tcp_paws_reject(&tp->rx_opt, 0)) {
6561                 SKB_DR_SET(reason, TCP_RFC7323_PAWS);
6562                 goto discard_and_undo;
6563         }
6564         if (th->syn) {
6565                 /* We see SYN without ACK. It is attempt of
6566                  * simultaneous connect with crossed SYNs.
6567                  * Particularly, it can be connect to self.
6568                  */
6569 #ifdef CONFIG_TCP_AO
6570                 struct tcp_ao_info *ao;
6571
6572                 ao = rcu_dereference_protected(tp->ao_info,
6573                                                lockdep_sock_is_held(sk));
6574                 if (ao) {
6575                         WRITE_ONCE(ao->risn, th->seq);
6576                         ao->rcv_sne = 0;
6577                 }
6578 #endif
6579                 tcp_set_state(sk, TCP_SYN_RECV);
6580
6581                 if (tp->rx_opt.saw_tstamp) {
6582                         tp->rx_opt.tstamp_ok = 1;
6583                         tcp_store_ts_recent(tp);
6584                         tp->tcp_header_len =
6585                                 sizeof(struct tcphdr) + TCPOLEN_TSTAMP_ALIGNED;
6586                 } else {
6587                         tp->tcp_header_len = sizeof(struct tcphdr);
6588                 }
6589
6590                 WRITE_ONCE(tp->rcv_nxt, TCP_SKB_CB(skb)->seq + 1);
6591                 WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
6592                 tp->rcv_wup = TCP_SKB_CB(skb)->seq + 1;
6593
6594                 /* RFC1323: The window in SYN & SYN/ACK segments is
6595                  * never scaled.
6596                  */
6597                 tp->snd_wnd    = ntohs(th->window);
6598                 tp->snd_wl1    = TCP_SKB_CB(skb)->seq;
6599                 tp->max_window = tp->snd_wnd;
6600
6601                 tcp_ecn_rcv_syn(tp, th);
6602
6603                 tcp_mtup_init(sk);
6604                 tcp_sync_mss(sk, icsk->icsk_pmtu_cookie);
6605                 tcp_initialize_rcv_mss(sk);
6606
6607                 tcp_send_synack(sk);
6608 #if 0
6609                 /* Note, we could accept data and URG from this segment.
6610                  * There are no obstacles to make this (except that we must
6611                  * either change tcp_recvmsg() to prevent it from returning data
6612                  * before 3WHS completes per RFC793, or employ TCP Fast Open).
6613                  *
6614                  * However, if we ignore data in ACKless segments sometimes,
6615                  * we have no reasons to accept it sometimes.
6616                  * Also, seems the code doing it in step6 of tcp_rcv_state_process
6617                  * is not flawless. So, discard packet for sanity.
6618                  * Uncomment this return to process the data.
6619                  */
6620                 return -1;
6621 #else
6622                 goto consume;
6623 #endif
6624         }
6625         /* "fifth, if neither of the SYN or RST bits is set then
6626          * drop the segment and return."
6627          */
6628
6629 discard_and_undo:
6630         tcp_clear_options(&tp->rx_opt);
6631         tp->rx_opt.mss_clamp = saved_clamp;
6632         tcp_drop_reason(sk, skb, reason);
6633         return 0;
6634
6635 reset_and_undo:
6636         tcp_clear_options(&tp->rx_opt);
6637         tp->rx_opt.mss_clamp = saved_clamp;
6638         /* we can reuse/return @reason to its caller to handle the exception */
6639         return reason;
6640 }
6641
6642 static void tcp_rcv_synrecv_state_fastopen(struct sock *sk)
6643 {
6644         struct tcp_sock *tp = tcp_sk(sk);
6645         struct request_sock *req;
6646
6647         /* If we are still handling the SYNACK RTO, see if timestamp ECR allows
6648          * undo. If peer SACKs triggered fast recovery, we can't undo here.
6649          */
6650         if (inet_csk(sk)->icsk_ca_state == TCP_CA_Loss && !tp->packets_out)
6651                 tcp_try_undo_recovery(sk);
6652
6653         /* Reset rtx states to prevent spurious retransmits_timed_out() */
6654         tcp_update_rto_time(tp);
6655         tp->retrans_stamp = 0;
6656         inet_csk(sk)->icsk_retransmits = 0;
6657
6658         /* Once we leave TCP_SYN_RECV or TCP_FIN_WAIT_1,
6659          * we no longer need req so release it.
6660          */
6661         req = rcu_dereference_protected(tp->fastopen_rsk,
6662                                         lockdep_sock_is_held(sk));
6663         reqsk_fastopen_remove(sk, req, false);
6664
6665         /* Re-arm the timer because data may have been sent out.
6666          * This is similar to the regular data transmission case
6667          * when new data has just been ack'ed.
6668          *
6669          * (TFO) - we could try to be more aggressive and
6670          * retransmitting any data sooner based on when they
6671          * are sent out.
6672          */
6673         tcp_rearm_rto(sk);
6674 }
6675
6676 /*
6677  *      This function implements the receiving procedure of RFC 793 for
6678  *      all states except ESTABLISHED and TIME_WAIT.
6679  *      It's called from both tcp_v4_rcv and tcp_v6_rcv and should be
6680  *      address independent.
6681  */
6682
6683 enum skb_drop_reason
6684 tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb)
6685 {
6686         struct tcp_sock *tp = tcp_sk(sk);
6687         struct inet_connection_sock *icsk = inet_csk(sk);
6688         const struct tcphdr *th = tcp_hdr(skb);
6689         struct request_sock *req;
6690         int queued = 0;
6691         SKB_DR(reason);
6692
6693         switch (sk->sk_state) {
6694         case TCP_CLOSE:
6695                 SKB_DR_SET(reason, TCP_CLOSE);
6696                 goto discard;
6697
6698         case TCP_LISTEN:
6699                 if (th->ack)
6700                         return SKB_DROP_REASON_TCP_FLAGS;
6701
6702                 if (th->rst) {
6703                         SKB_DR_SET(reason, TCP_RESET);
6704                         goto discard;
6705                 }
6706                 if (th->syn) {
6707                         if (th->fin) {
6708                                 SKB_DR_SET(reason, TCP_FLAGS);
6709                                 goto discard;
6710                         }
6711                         /* It is possible that we process SYN packets from backlog,
6712                          * so we need to make sure to disable BH and RCU right there.
6713                          */
6714                         rcu_read_lock();
6715                         local_bh_disable();
6716                         icsk->icsk_af_ops->conn_request(sk, skb);
6717                         local_bh_enable();
6718                         rcu_read_unlock();
6719
6720                         consume_skb(skb);
6721                         return 0;
6722                 }
6723                 SKB_DR_SET(reason, TCP_FLAGS);
6724                 goto discard;
6725
6726         case TCP_SYN_SENT:
6727                 tp->rx_opt.saw_tstamp = 0;
6728                 tcp_mstamp_refresh(tp);
6729                 queued = tcp_rcv_synsent_state_process(sk, skb, th);
6730                 if (queued >= 0)
6731                         return queued;
6732
6733                 /* Do step6 onward by hand. */
6734                 tcp_urg(sk, skb, th);
6735                 __kfree_skb(skb);
6736                 tcp_data_snd_check(sk);
6737                 return 0;
6738         }
6739
6740         tcp_mstamp_refresh(tp);
6741         tp->rx_opt.saw_tstamp = 0;
6742         req = rcu_dereference_protected(tp->fastopen_rsk,
6743                                         lockdep_sock_is_held(sk));
6744         if (req) {
6745                 bool req_stolen;
6746
6747                 WARN_ON_ONCE(sk->sk_state != TCP_SYN_RECV &&
6748                     sk->sk_state != TCP_FIN_WAIT1);
6749
6750                 if (!tcp_check_req(sk, skb, req, true, &req_stolen)) {
6751                         SKB_DR_SET(reason, TCP_FASTOPEN);
6752                         goto discard;
6753                 }
6754         }
6755
6756         if (!th->ack && !th->rst && !th->syn) {
6757                 SKB_DR_SET(reason, TCP_FLAGS);
6758                 goto discard;
6759         }
6760         if (!tcp_validate_incoming(sk, skb, th, 0))
6761                 return 0;
6762
6763         /* step 5: check the ACK field */
6764         reason = tcp_ack(sk, skb, FLAG_SLOWPATH |
6765                                   FLAG_UPDATE_TS_RECENT |
6766                                   FLAG_NO_CHALLENGE_ACK);
6767
6768         if ((int)reason <= 0) {
6769                 if (sk->sk_state == TCP_SYN_RECV) {
6770                         /* send one RST */
6771                         if (!reason)
6772                                 return SKB_DROP_REASON_TCP_OLD_ACK;
6773                         return -reason;
6774                 }
6775                 /* accept old ack during closing */
6776                 if ((int)reason < 0) {
6777                         tcp_send_challenge_ack(sk);
6778                         reason = -reason;
6779                         goto discard;
6780                 }
6781         }
6782         SKB_DR_SET(reason, NOT_SPECIFIED);
6783         switch (sk->sk_state) {
6784         case TCP_SYN_RECV:
6785                 tp->delivered++; /* SYN-ACK delivery isn't tracked in tcp_ack */
6786                 if (!tp->srtt_us)
6787                         tcp_synack_rtt_meas(sk, req);
6788
6789                 if (req) {
6790                         tcp_rcv_synrecv_state_fastopen(sk);
6791                 } else {
6792                         tcp_try_undo_spurious_syn(sk);
6793                         tp->retrans_stamp = 0;
6794                         tcp_init_transfer(sk, BPF_SOCK_OPS_PASSIVE_ESTABLISHED_CB,
6795                                           skb);
6796                         WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
6797                 }
6798                 tcp_ao_established(sk);
6799                 smp_mb();
6800                 tcp_set_state(sk, TCP_ESTABLISHED);
6801                 sk->sk_state_change(sk);
6802
6803                 /* Note, that this wakeup is only for marginal crossed SYN case.
6804                  * Passively open sockets are not waked up, because
6805                  * sk->sk_sleep == NULL and sk->sk_socket == NULL.
6806                  */
6807                 if (sk->sk_socket)
6808                         sk_wake_async(sk, SOCK_WAKE_IO, POLL_OUT);
6809
6810                 tp->snd_una = TCP_SKB_CB(skb)->ack_seq;
6811                 tp->snd_wnd = ntohs(th->window) << tp->rx_opt.snd_wscale;
6812                 tcp_init_wl(tp, TCP_SKB_CB(skb)->seq);
6813
6814                 if (tp->rx_opt.tstamp_ok)
6815                         tp->advmss -= TCPOLEN_TSTAMP_ALIGNED;
6816
6817                 if (!inet_csk(sk)->icsk_ca_ops->cong_control)
6818                         tcp_update_pacing_rate(sk);
6819
6820                 /* Prevent spurious tcp_cwnd_restart() on first data packet */
6821                 tp->lsndtime = tcp_jiffies32;
6822
6823                 tcp_initialize_rcv_mss(sk);
6824                 tcp_fast_path_on(tp);
6825                 if (sk->sk_shutdown & SEND_SHUTDOWN)
6826                         tcp_shutdown(sk, SEND_SHUTDOWN);
6827                 break;
6828
6829         case TCP_FIN_WAIT1: {
6830                 int tmo;
6831
6832                 if (req)
6833                         tcp_rcv_synrecv_state_fastopen(sk);
6834
6835                 if (tp->snd_una != tp->write_seq)
6836                         break;
6837
6838                 tcp_set_state(sk, TCP_FIN_WAIT2);
6839                 WRITE_ONCE(sk->sk_shutdown, sk->sk_shutdown | SEND_SHUTDOWN);
6840
6841                 sk_dst_confirm(sk);
6842
6843                 if (!sock_flag(sk, SOCK_DEAD)) {
6844                         /* Wake up lingering close() */
6845                         sk->sk_state_change(sk);
6846                         break;
6847                 }
6848
6849                 if (READ_ONCE(tp->linger2) < 0) {
6850                         tcp_done(sk);
6851                         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
6852                         return SKB_DROP_REASON_TCP_ABORT_ON_DATA;
6853                 }
6854                 if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
6855                     after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
6856                         /* Receive out of order FIN after close() */
6857                         if (tp->syn_fastopen && th->fin)
6858                                 tcp_fastopen_active_disable(sk);
6859                         tcp_done(sk);
6860                         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
6861                         return SKB_DROP_REASON_TCP_ABORT_ON_DATA;
6862                 }
6863
6864                 tmo = tcp_fin_time(sk);
6865                 if (tmo > TCP_TIMEWAIT_LEN) {
6866                         inet_csk_reset_keepalive_timer(sk, tmo - TCP_TIMEWAIT_LEN);
6867                 } else if (th->fin || sock_owned_by_user(sk)) {
6868                         /* Bad case. We could lose such FIN otherwise.
6869                          * It is not a big problem, but it looks confusing
6870                          * and not so rare event. We still can lose it now,
6871                          * if it spins in bh_lock_sock(), but it is really
6872                          * marginal case.
6873                          */
6874                         inet_csk_reset_keepalive_timer(sk, tmo);
6875                 } else {
6876                         tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
6877                         goto consume;
6878                 }
6879                 break;
6880         }
6881
6882         case TCP_CLOSING:
6883                 if (tp->snd_una == tp->write_seq) {
6884                         tcp_time_wait(sk, TCP_TIME_WAIT, 0);
6885                         goto consume;
6886                 }
6887                 break;
6888
6889         case TCP_LAST_ACK:
6890                 if (tp->snd_una == tp->write_seq) {
6891                         tcp_update_metrics(sk);
6892                         tcp_done(sk);
6893                         goto consume;
6894                 }
6895                 break;
6896         }
6897
6898         /* step 6: check the URG bit */
6899         tcp_urg(sk, skb, th);
6900
6901         /* step 7: process the segment text */
6902         switch (sk->sk_state) {
6903         case TCP_CLOSE_WAIT:
6904         case TCP_CLOSING:
6905         case TCP_LAST_ACK:
6906                 if (!before(TCP_SKB_CB(skb)->seq, tp->rcv_nxt)) {
6907                         /* If a subflow has been reset, the packet should not
6908                          * continue to be processed, drop the packet.
6909                          */
6910                         if (sk_is_mptcp(sk) && !mptcp_incoming_options(sk, skb))
6911                                 goto discard;
6912                         break;
6913                 }
6914                 fallthrough;
6915         case TCP_FIN_WAIT1:
6916         case TCP_FIN_WAIT2:
6917                 /* RFC 793 says to queue data in these states,
6918                  * RFC 1122 says we MUST send a reset.
6919                  * BSD 4.4 also does reset.
6920                  */
6921                 if (sk->sk_shutdown & RCV_SHUTDOWN) {
6922                         if (TCP_SKB_CB(skb)->end_seq != TCP_SKB_CB(skb)->seq &&
6923                             after(TCP_SKB_CB(skb)->end_seq - th->fin, tp->rcv_nxt)) {
6924                                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
6925                                 tcp_reset(sk, skb);
6926                                 return SKB_DROP_REASON_TCP_ABORT_ON_DATA;
6927                         }
6928                 }
6929                 fallthrough;
6930         case TCP_ESTABLISHED:
6931                 tcp_data_queue(sk, skb);
6932                 queued = 1;
6933                 break;
6934         }
6935
6936         /* tcp_data could move socket to TIME-WAIT */
6937         if (sk->sk_state != TCP_CLOSE) {
6938                 tcp_data_snd_check(sk);
6939                 tcp_ack_snd_check(sk);
6940         }
6941
6942         if (!queued) {
6943 discard:
6944                 tcp_drop_reason(sk, skb, reason);
6945         }
6946         return 0;
6947
6948 consume:
6949         __kfree_skb(skb);
6950         return 0;
6951 }
6952 EXPORT_SYMBOL(tcp_rcv_state_process);
6953
6954 static inline void pr_drop_req(struct request_sock *req, __u16 port, int family)
6955 {
6956         struct inet_request_sock *ireq = inet_rsk(req);
6957
6958         if (family == AF_INET)
6959                 net_dbg_ratelimited("drop open request from %pI4/%u\n",
6960                                     &ireq->ir_rmt_addr, port);
6961 #if IS_ENABLED(CONFIG_IPV6)
6962         else if (family == AF_INET6)
6963                 net_dbg_ratelimited("drop open request from %pI6/%u\n",
6964                                     &ireq->ir_v6_rmt_addr, port);
6965 #endif
6966 }
6967
6968 /* RFC3168 : 6.1.1 SYN packets must not have ECT/ECN bits set
6969  *
6970  * If we receive a SYN packet with these bits set, it means a
6971  * network is playing bad games with TOS bits. In order to
6972  * avoid possible false congestion notifications, we disable
6973  * TCP ECN negotiation.
6974  *
6975  * Exception: tcp_ca wants ECN. This is required for DCTCP
6976  * congestion control: Linux DCTCP asserts ECT on all packets,
6977  * including SYN, which is most optimal solution; however,
6978  * others, such as FreeBSD do not.
6979  *
6980  * Exception: At least one of the reserved bits of the TCP header (th->res1) is
6981  * set, indicating the use of a future TCP extension (such as AccECN). See
6982  * RFC8311 Â§4.3 which updates RFC3168 to allow the development of such
6983  * extensions.
6984  */
6985 static void tcp_ecn_create_request(struct request_sock *req,
6986                                    const struct sk_buff *skb,
6987                                    const struct sock *listen_sk,
6988                                    const struct dst_entry *dst)
6989 {
6990         const struct tcphdr *th = tcp_hdr(skb);
6991         const struct net *net = sock_net(listen_sk);
6992         bool th_ecn = th->ece && th->cwr;
6993         bool ect, ecn_ok;
6994         u32 ecn_ok_dst;
6995
6996         if (!th_ecn)
6997                 return;
6998
6999         ect = !INET_ECN_is_not_ect(TCP_SKB_CB(skb)->ip_dsfield);
7000         ecn_ok_dst = dst_feature(dst, DST_FEATURE_ECN_MASK);
7001         ecn_ok = READ_ONCE(net->ipv4.sysctl_tcp_ecn) || ecn_ok_dst;
7002
7003         if (((!ect || th->res1) && ecn_ok) || tcp_ca_needs_ecn(listen_sk) ||
7004             (ecn_ok_dst & DST_FEATURE_ECN_CA) ||
7005             tcp_bpf_ca_needs_ecn((struct sock *)req))
7006                 inet_rsk(req)->ecn_ok = 1;
7007 }
7008
7009 static void tcp_openreq_init(struct request_sock *req,
7010                              const struct tcp_options_received *rx_opt,
7011                              struct sk_buff *skb, const struct sock *sk)
7012 {
7013         struct inet_request_sock *ireq = inet_rsk(req);
7014
7015         req->rsk_rcv_wnd = 0;           /* So that tcp_send_synack() knows! */
7016         tcp_rsk(req)->rcv_isn = TCP_SKB_CB(skb)->seq;
7017         tcp_rsk(req)->rcv_nxt = TCP_SKB_CB(skb)->seq + 1;
7018         tcp_rsk(req)->snt_synack = 0;
7019         tcp_rsk(req)->last_oow_ack_time = 0;
7020         req->mss = rx_opt->mss_clamp;
7021         req->ts_recent = rx_opt->saw_tstamp ? rx_opt->rcv_tsval : 0;
7022         ireq->tstamp_ok = rx_opt->tstamp_ok;
7023         ireq->sack_ok = rx_opt->sack_ok;
7024         ireq->snd_wscale = rx_opt->snd_wscale;
7025         ireq->wscale_ok = rx_opt->wscale_ok;
7026         ireq->acked = 0;
7027         ireq->ecn_ok = 0;
7028         ireq->ir_rmt_port = tcp_hdr(skb)->source;
7029         ireq->ir_num = ntohs(tcp_hdr(skb)->dest);
7030         ireq->ir_mark = inet_request_mark(sk, skb);
7031 #if IS_ENABLED(CONFIG_SMC)
7032         ireq->smc_ok = rx_opt->smc_ok && !(tcp_sk(sk)->smc_hs_congested &&
7033                         tcp_sk(sk)->smc_hs_congested(sk));
7034 #endif
7035 }
7036
7037 /*
7038  * Return true if a syncookie should be sent
7039  */
7040 static bool tcp_syn_flood_action(struct sock *sk, const char *proto)
7041 {
7042         struct request_sock_queue *queue = &inet_csk(sk)->icsk_accept_queue;
7043         const char *msg = "Dropping request";
7044         struct net *net = sock_net(sk);
7045         bool want_cookie = false;
7046         u8 syncookies;
7047
7048         syncookies = READ_ONCE(net->ipv4.sysctl_tcp_syncookies);
7049
7050 #ifdef CONFIG_SYN_COOKIES
7051         if (syncookies) {
7052                 msg = "Sending cookies";
7053                 want_cookie = true;
7054                 __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDOCOOKIES);
7055         } else
7056 #endif
7057                 __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPREQQFULLDROP);
7058
7059         if (!READ_ONCE(queue->synflood_warned) && syncookies != 2 &&
7060             xchg(&queue->synflood_warned, 1) == 0) {
7061                 if (IS_ENABLED(CONFIG_IPV6) && sk->sk_family == AF_INET6) {
7062                         net_info_ratelimited("%s: Possible SYN flooding on port [%pI6c]:%u. %s.\n",
7063                                         proto, inet6_rcv_saddr(sk),
7064                                         sk->sk_num, msg);
7065                 } else {
7066                         net_info_ratelimited("%s: Possible SYN flooding on port %pI4:%u. %s.\n",
7067                                         proto, &sk->sk_rcv_saddr,
7068                                         sk->sk_num, msg);
7069                 }
7070         }
7071
7072         return want_cookie;
7073 }
7074
7075 static void tcp_reqsk_record_syn(const struct sock *sk,
7076                                  struct request_sock *req,
7077                                  const struct sk_buff *skb)
7078 {
7079         if (tcp_sk(sk)->save_syn) {
7080                 u32 len = skb_network_header_len(skb) + tcp_hdrlen(skb);
7081                 struct saved_syn *saved_syn;
7082                 u32 mac_hdrlen;
7083                 void *base;
7084
7085                 if (tcp_sk(sk)->save_syn == 2) {  /* Save full header. */
7086                         base = skb_mac_header(skb);
7087                         mac_hdrlen = skb_mac_header_len(skb);
7088                         len += mac_hdrlen;
7089                 } else {
7090                         base = skb_network_header(skb);
7091                         mac_hdrlen = 0;
7092                 }
7093
7094                 saved_syn = kmalloc(struct_size(saved_syn, data, len),
7095                                     GFP_ATOMIC);
7096                 if (saved_syn) {
7097                         saved_syn->mac_hdrlen = mac_hdrlen;
7098                         saved_syn->network_hdrlen = skb_network_header_len(skb);
7099                         saved_syn->tcp_hdrlen = tcp_hdrlen(skb);
7100                         memcpy(saved_syn->data, base, len);
7101                         req->saved_syn = saved_syn;
7102                 }
7103         }
7104 }
7105
7106 /* If a SYN cookie is required and supported, returns a clamped MSS value to be
7107  * used for SYN cookie generation.
7108  */
7109 u16 tcp_get_syncookie_mss(struct request_sock_ops *rsk_ops,
7110                           const struct tcp_request_sock_ops *af_ops,
7111                           struct sock *sk, struct tcphdr *th)
7112 {
7113         struct tcp_sock *tp = tcp_sk(sk);
7114         u16 mss;
7115
7116         if (READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_syncookies) != 2 &&
7117             !inet_csk_reqsk_queue_is_full(sk))
7118                 return 0;
7119
7120         if (!tcp_syn_flood_action(sk, rsk_ops->slab_name))
7121                 return 0;
7122
7123         if (sk_acceptq_is_full(sk)) {
7124                 NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
7125                 return 0;
7126         }
7127
7128         mss = tcp_parse_mss_option(th, tp->rx_opt.user_mss);
7129         if (!mss)
7130                 mss = af_ops->mss_clamp;
7131
7132         return mss;
7133 }
7134 EXPORT_SYMBOL_GPL(tcp_get_syncookie_mss);
7135
7136 int tcp_conn_request(struct request_sock_ops *rsk_ops,
7137                      const struct tcp_request_sock_ops *af_ops,
7138                      struct sock *sk, struct sk_buff *skb)
7139 {
7140         struct tcp_fastopen_cookie foc = { .len = -1 };
7141         struct tcp_options_received tmp_opt;
7142         struct tcp_sock *tp = tcp_sk(sk);
7143         struct net *net = sock_net(sk);
7144         struct sock *fastopen_sk = NULL;
7145         struct request_sock *req;
7146         bool want_cookie = false;
7147         struct dst_entry *dst;
7148         struct flowi fl;
7149         u8 syncookies;
7150         u32 isn;
7151
7152 #ifdef CONFIG_TCP_AO
7153         const struct tcp_ao_hdr *aoh;
7154 #endif
7155
7156         isn = __this_cpu_read(tcp_tw_isn);
7157         if (isn) {
7158                 /* TW buckets are converted to open requests without
7159                  * limitations, they conserve resources and peer is
7160                  * evidently real one.
7161                  */
7162                 __this_cpu_write(tcp_tw_isn, 0);
7163         } else {
7164                 syncookies = READ_ONCE(net->ipv4.sysctl_tcp_syncookies);
7165
7166                 if (syncookies == 2 || inet_csk_reqsk_queue_is_full(sk)) {
7167                         want_cookie = tcp_syn_flood_action(sk,
7168                                                            rsk_ops->slab_name);
7169                         if (!want_cookie)
7170                                 goto drop;
7171                 }
7172         }
7173
7174         if (sk_acceptq_is_full(sk)) {
7175                 NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENOVERFLOWS);
7176                 goto drop;
7177         }
7178
7179         req = inet_reqsk_alloc(rsk_ops, sk, !want_cookie);
7180         if (!req)
7181                 goto drop;
7182
7183         req->syncookie = want_cookie;
7184         tcp_rsk(req)->af_specific = af_ops;
7185         tcp_rsk(req)->ts_off = 0;
7186         tcp_rsk(req)->req_usec_ts = false;
7187 #if IS_ENABLED(CONFIG_MPTCP)
7188         tcp_rsk(req)->is_mptcp = 0;
7189 #endif
7190
7191         tcp_clear_options(&tmp_opt);
7192         tmp_opt.mss_clamp = af_ops->mss_clamp;
7193         tmp_opt.user_mss  = tp->rx_opt.user_mss;
7194         tcp_parse_options(sock_net(sk), skb, &tmp_opt, 0,
7195                           want_cookie ? NULL : &foc);
7196
7197         if (want_cookie && !tmp_opt.saw_tstamp)
7198                 tcp_clear_options(&tmp_opt);
7199
7200         if (IS_ENABLED(CONFIG_SMC) && want_cookie)
7201                 tmp_opt.smc_ok = 0;
7202
7203         tmp_opt.tstamp_ok = tmp_opt.saw_tstamp;
7204         tcp_openreq_init(req, &tmp_opt, skb, sk);
7205         inet_rsk(req)->no_srccheck = inet_test_bit(TRANSPARENT, sk);
7206
7207         /* Note: tcp_v6_init_req() might override ir_iif for link locals */
7208         inet_rsk(req)->ir_iif = inet_request_bound_dev_if(sk, skb);
7209
7210         dst = af_ops->route_req(sk, skb, &fl, req, isn);
7211         if (!dst)
7212                 goto drop_and_free;
7213
7214         if (tmp_opt.tstamp_ok) {
7215                 tcp_rsk(req)->req_usec_ts = dst_tcp_usec_ts(dst);
7216                 tcp_rsk(req)->ts_off = af_ops->init_ts_off(net, skb);
7217         }
7218         if (!want_cookie && !isn) {
7219                 int max_syn_backlog = READ_ONCE(net->ipv4.sysctl_max_syn_backlog);
7220
7221                 /* Kill the following clause, if you dislike this way. */
7222                 if (!syncookies &&
7223                     (max_syn_backlog - inet_csk_reqsk_queue_len(sk) <
7224                      (max_syn_backlog >> 2)) &&
7225                     !tcp_peer_is_proven(req, dst)) {
7226                         /* Without syncookies last quarter of
7227                          * backlog is filled with destinations,
7228                          * proven to be alive.
7229                          * It means that we continue to communicate
7230                          * to destinations, already remembered
7231                          * to the moment of synflood.
7232                          */
7233                         pr_drop_req(req, ntohs(tcp_hdr(skb)->source),
7234                                     rsk_ops->family);
7235                         goto drop_and_release;
7236                 }
7237
7238                 isn = af_ops->init_seq(skb);
7239         }
7240
7241         tcp_ecn_create_request(req, skb, sk, dst);
7242
7243         if (want_cookie) {
7244                 isn = cookie_init_sequence(af_ops, sk, skb, &req->mss);
7245                 if (!tmp_opt.tstamp_ok)
7246                         inet_rsk(req)->ecn_ok = 0;
7247         }
7248
7249 #ifdef CONFIG_TCP_AO
7250         if (tcp_parse_auth_options(tcp_hdr(skb), NULL, &aoh))
7251                 goto drop_and_release; /* Invalid TCP options */
7252         if (aoh) {
7253                 tcp_rsk(req)->used_tcp_ao = true;
7254                 tcp_rsk(req)->ao_rcv_next = aoh->keyid;
7255                 tcp_rsk(req)->ao_keyid = aoh->rnext_keyid;
7256
7257         } else {
7258                 tcp_rsk(req)->used_tcp_ao = false;
7259         }
7260 #endif
7261         tcp_rsk(req)->snt_isn = isn;
7262         tcp_rsk(req)->txhash = net_tx_rndhash();
7263         tcp_rsk(req)->syn_tos = TCP_SKB_CB(skb)->ip_dsfield;
7264         tcp_openreq_init_rwin(req, sk, dst);
7265         sk_rx_queue_set(req_to_sk(req), skb);
7266         if (!want_cookie) {
7267                 tcp_reqsk_record_syn(sk, req, skb);
7268                 fastopen_sk = tcp_try_fastopen(sk, skb, req, &foc, dst);
7269         }
7270         if (fastopen_sk) {
7271                 af_ops->send_synack(fastopen_sk, dst, &fl, req,
7272                                     &foc, TCP_SYNACK_FASTOPEN, skb);
7273                 /* Add the child socket directly into the accept queue */
7274                 if (!inet_csk_reqsk_queue_add(sk, req, fastopen_sk)) {
7275                         reqsk_fastopen_remove(fastopen_sk, req, false);
7276                         bh_unlock_sock(fastopen_sk);
7277                         sock_put(fastopen_sk);
7278                         goto drop_and_free;
7279                 }
7280                 sk->sk_data_ready(sk);
7281                 bh_unlock_sock(fastopen_sk);
7282                 sock_put(fastopen_sk);
7283         } else {
7284                 tcp_rsk(req)->tfo_listener = false;
7285                 if (!want_cookie) {
7286                         req->timeout = tcp_timeout_init((struct sock *)req);
7287                         if (unlikely(!inet_csk_reqsk_queue_hash_add(sk, req,
7288                                                                     req->timeout))) {
7289                                 reqsk_free(req);
7290                                 return 0;
7291                         }
7292
7293                 }
7294                 af_ops->send_synack(sk, dst, &fl, req, &foc,
7295                                     !want_cookie ? TCP_SYNACK_NORMAL :
7296                                                    TCP_SYNACK_COOKIE,
7297                                     skb);
7298                 if (want_cookie) {
7299                         reqsk_free(req);
7300                         return 0;
7301                 }
7302         }
7303         reqsk_put(req);
7304         return 0;
7305
7306 drop_and_release:
7307         dst_release(dst);
7308 drop_and_free:
7309         __reqsk_free(req);
7310 drop:
7311         tcp_listendrop(sk);
7312         return 0;
7313 }
7314 EXPORT_SYMBOL(tcp_conn_request);
This page took 0.463249 seconds and 4 git commands to generate.