LCOV - code coverage report
Current view: top level - net/ipv4 - tcp_output.c (source / functions) Hit Total Coverage
Test: Real Lines: 657 1313 50.0 %
Date: 2020-10-17 15:46:16 Functions: 0 85 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 0 0 -

           Branch data     Line data    Source code
       1                 :            : // SPDX-License-Identifier: GPL-2.0-only
       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, <waltje@uWalt.NL.Mugnet.ORG>
      11                 :            :  *              Mark Evans, <evansmp@uhura.aston.ac.uk>
      12                 :            :  *              Corey Minyard <wf-rch!minyard@relay.EU.net>
      13                 :            :  *              Florian La Roche, <flla@stud.uni-sb.de>
      14                 :            :  *              Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
      15                 :            :  *              Linus Torvalds, <torvalds@cs.helsinki.fi>
      16                 :            :  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
      17                 :            :  *              Matthew Dillon, <dillon@apollo.west.oic.com>
      18                 :            :  *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
      19                 :            :  *              Jorge Cwik, <jorge@laser.satlink.net>
      20                 :            :  */
      21                 :            : 
      22                 :            : /*
      23                 :            :  * Changes:     Pedro Roque     :       Retransmit queue handled by TCP.
      24                 :            :  *                              :       Fragmentation on mtu decrease
      25                 :            :  *                              :       Segment collapse on retransmit
      26                 :            :  *                              :       AF independence
      27                 :            :  *
      28                 :            :  *              Linus Torvalds  :       send_delayed_ack
      29                 :            :  *              David S. Miller :       Charge memory using the right skb
      30                 :            :  *                                      during syn/ack processing.
      31                 :            :  *              David S. Miller :       Output engine completely rewritten.
      32                 :            :  *              Andrea Arcangeli:       SYNACK carry ts_recent in tsecr.
      33                 :            :  *              Cacophonix Gaul :       draft-minshall-nagle-01
      34                 :            :  *              J Hadi Salim    :       ECN support
      35                 :            :  *
      36                 :            :  */
      37                 :            : 
      38                 :            : #define pr_fmt(fmt) "TCP: " fmt
      39                 :            : 
      40                 :            : #include <net/tcp.h>
      41                 :            : 
      42                 :            : #include <linux/compiler.h>
      43                 :            : #include <linux/gfp.h>
      44                 :            : #include <linux/module.h>
      45                 :            : #include <linux/static_key.h>
      46                 :            : 
      47                 :            : #include <trace/events/tcp.h>
      48                 :            : 
      49                 :            : /* Refresh clocks of a TCP socket,
      50                 :            :  * ensuring monotically increasing values.
      51                 :            :  */
      52                 :          1 : void tcp_mstamp_refresh(struct tcp_sock *tp)
      53                 :            : {
      54                 :            :         u64 val = tcp_clock_ns();
      55                 :            : 
      56                 :          1 :         tp->tcp_clock_cache = val;
      57                 :          1 :         tp->tcp_mstamp = div_u64(val, NSEC_PER_USEC);
      58                 :          1 : }
      59                 :            : 
      60                 :            : static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
      61                 :            :                            int push_one, gfp_t gfp);
      62                 :            : 
      63                 :            : /* Account for new data that has been sent to the network. */
      64                 :          1 : static void tcp_event_new_data_sent(struct sock *sk, struct sk_buff *skb)
      65                 :            : {
      66                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
      67                 :            :         struct tcp_sock *tp = tcp_sk(sk);
      68                 :          1 :         unsigned int prior_packets = tp->packets_out;
      69                 :            : 
      70                 :          1 :         WRITE_ONCE(tp->snd_nxt, TCP_SKB_CB(skb)->end_seq);
      71                 :            : 
      72                 :            :         __skb_unlink(skb, &sk->sk_write_queue);
      73                 :          1 :         tcp_rbtree_insert(&sk->tcp_rtx_queue, skb);
      74                 :            : 
      75                 :          1 :         if (tp->highest_sack == NULL)
      76                 :          1 :                 tp->highest_sack = skb;
      77                 :            : 
      78                 :          1 :         tp->packets_out += tcp_skb_pcount(skb);
      79                 :          1 :         if (!prior_packets || icsk->icsk_pending == ICSK_TIME_LOSS_PROBE)
      80                 :          1 :                 tcp_rearm_rto(sk);
      81                 :            : 
      82                 :          1 :         NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPORIGDATASENT,
      83                 :            :                       tcp_skb_pcount(skb));
      84                 :          1 : }
      85                 :            : 
      86                 :            : /* SND.NXT, if window was not shrunk or the amount of shrunk was less than one
      87                 :            :  * window scaling factor due to loss of precision.
      88                 :            :  * If window has been shrunk, what should we make? It is not clear at all.
      89                 :            :  * Using SND.UNA we will fail to open window, SND.NXT is out of window. :-(
      90                 :            :  * Anything in between SND.UNA...SND.UNA+SND.WND also can be already
      91                 :            :  * invalid. OK, let's make this for now:
      92                 :            :  */
      93                 :            : static inline __u32 tcp_acceptable_seq(const struct sock *sk)
      94                 :            : {
      95                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
      96                 :            : 
      97                 :          1 :         if (!before(tcp_wnd_end(tp), tp->snd_nxt) ||
      98                 :          0 :             (tp->rx_opt.wscale_ok &&
      99                 :          0 :              ((tp->snd_nxt - tcp_wnd_end(tp)) < (1 << tp->rx_opt.rcv_wscale))))
     100                 :            :                 return tp->snd_nxt;
     101                 :            :         else
     102                 :            :                 return tcp_wnd_end(tp);
     103                 :            : }
     104                 :            : 
     105                 :            : /* Calculate mss to advertise in SYN segment.
     106                 :            :  * RFC1122, RFC1063, draft-ietf-tcpimpl-pmtud-01 state that:
     107                 :            :  *
     108                 :            :  * 1. It is independent of path mtu.
     109                 :            :  * 2. Ideally, it is maximal possible segment size i.e. 65535-40.
     110                 :            :  * 3. For IPv4 it is reasonable to calculate it from maximal MTU of
     111                 :            :  *    attached devices, because some buggy hosts are confused by
     112                 :            :  *    large MSS.
     113                 :            :  * 4. We do not make 3, we advertise MSS, calculated from first
     114                 :            :  *    hop device mtu, but allow to raise it to ip_rt_min_advmss.
     115                 :            :  *    This may be overridden via information stored in routing table.
     116                 :            :  * 5. Value 65535 for MSS is valid in IPv6 and means "as large as possible,
     117                 :            :  *    probably even Jumbo".
     118                 :            :  */
     119                 :          1 : static __u16 tcp_advertise_mss(struct sock *sk)
     120                 :            : {
     121                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     122                 :            :         const struct dst_entry *dst = __sk_dst_get(sk);
     123                 :          1 :         int mss = tp->advmss;
     124                 :            : 
     125                 :          1 :         if (dst) {
     126                 :            :                 unsigned int metric = dst_metric_advmss(dst);
     127                 :            : 
     128                 :          1 :                 if (metric < mss) {
     129                 :          0 :                         mss = metric;
     130                 :          0 :                         tp->advmss = mss;
     131                 :            :                 }
     132                 :            :         }
     133                 :            : 
     134                 :          1 :         return (__u16)mss;
     135                 :            : }
     136                 :            : 
     137                 :            : /* RFC2861. Reset CWND after idle period longer RTO to "restart window".
     138                 :            :  * This is the first part of cwnd validation mechanism.
     139                 :            :  */
     140                 :          1 : void tcp_cwnd_restart(struct sock *sk, s32 delta)
     141                 :            : {
     142                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     143                 :          1 :         u32 restart_cwnd = tcp_init_cwnd(tp, __sk_dst_get(sk));
     144                 :          1 :         u32 cwnd = tp->snd_cwnd;
     145                 :            : 
     146                 :            :         tcp_ca_event(sk, CA_EVENT_CWND_RESTART);
     147                 :            : 
     148                 :          1 :         tp->snd_ssthresh = tcp_current_ssthresh(sk);
     149                 :          1 :         restart_cwnd = min(restart_cwnd, cwnd);
     150                 :            : 
     151                 :          1 :         while ((delta -= inet_csk(sk)->icsk_rto) > 0 && cwnd > restart_cwnd)
     152                 :          0 :                 cwnd >>= 1;
     153                 :          1 :         tp->snd_cwnd = max(cwnd, restart_cwnd);
     154                 :          1 :         tp->snd_cwnd_stamp = tcp_jiffies32;
     155                 :          1 :         tp->snd_cwnd_used = 0;
     156                 :          1 : }
     157                 :            : 
     158                 :            : /* Congestion state accounting after a packet has been sent. */
     159                 :          1 : static void tcp_event_data_sent(struct tcp_sock *tp,
     160                 :            :                                 struct sock *sk)
     161                 :            : {
     162                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
     163                 :          1 :         const u32 now = tcp_jiffies32;
     164                 :            : 
     165                 :          1 :         if (tcp_packets_in_flight(tp) == 0)
     166                 :            :                 tcp_ca_event(sk, CA_EVENT_TX_START);
     167                 :            : 
     168                 :            :         /* If this is the first data packet sent in response to the
     169                 :            :          * previous received data,
     170                 :            :          * and it is a reply for ato after last received packet,
     171                 :            :          * increase pingpong count.
     172                 :            :          */
     173                 :          1 :         if (before(tp->lsndtime, icsk->icsk_ack.lrcvtime) &&
     174                 :          1 :             (u32)(now - icsk->icsk_ack.lrcvtime) < icsk->icsk_ack.ato)
     175                 :            :                 inet_csk_inc_pingpong_cnt(sk);
     176                 :            : 
     177                 :          1 :         tp->lsndtime = now;
     178                 :          1 : }
     179                 :            : 
     180                 :            : /* Account for an ACK we sent. */
     181                 :          1 : static inline void tcp_event_ack_sent(struct sock *sk, unsigned int pkts,
     182                 :            :                                       u32 rcv_nxt)
     183                 :            : {
     184                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     185                 :            : 
     186                 :          1 :         if (unlikely(tp->compressed_ack > TCP_FASTRETRANS_THRESH)) {
     187                 :          0 :                 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPACKCOMPRESSED,
     188                 :            :                               tp->compressed_ack - TCP_FASTRETRANS_THRESH);
     189                 :          0 :                 tp->compressed_ack = TCP_FASTRETRANS_THRESH;
     190                 :          0 :                 if (hrtimer_try_to_cancel(&tp->compressed_ack_timer) == 1)
     191                 :            :                         __sock_put(sk);
     192                 :            :         }
     193                 :            : 
     194                 :          1 :         if (unlikely(rcv_nxt != tp->rcv_nxt))
     195                 :          1 :                 return;  /* Special ACK sent by DCTCP to reflect ECN */
     196                 :            :         tcp_dec_quickack_mode(sk, pkts);
     197                 :            :         inet_csk_clear_xmit_timer(sk, ICSK_TIME_DACK);
     198                 :            : }
     199                 :            : 
     200                 :            : /* Determine a window scaling and initial window to offer.
     201                 :            :  * Based on the assumption that the given amount of space
     202                 :            :  * will be offered. Store the results in the tp structure.
     203                 :            :  * NOTE: for smooth operation initial space offering should
     204                 :            :  * be a multiple of mss if possible. We assume here that mss >= 1.
     205                 :            :  * This MUST be enforced by all callers.
     206                 :            :  */
     207                 :          1 : void tcp_select_initial_window(const struct sock *sk, int __space, __u32 mss,
     208                 :            :                                __u32 *rcv_wnd, __u32 *window_clamp,
     209                 :            :                                int wscale_ok, __u8 *rcv_wscale,
     210                 :            :                                __u32 init_rcv_wnd)
     211                 :            : {
     212                 :          1 :         unsigned int space = (__space < 0 ? 0 : __space);
     213                 :            : 
     214                 :            :         /* If no clamp set the clamp to the max possible scaled window */
     215                 :          1 :         if (*window_clamp == 0)
     216                 :          1 :                 (*window_clamp) = (U16_MAX << TCP_MAX_WSCALE);
     217                 :          1 :         space = min(*window_clamp, space);
     218                 :            : 
     219                 :            :         /* Quantize space offering to a multiple of mss if possible. */
     220                 :          1 :         if (space > mss)
     221                 :          1 :                 space = rounddown(space, mss);
     222                 :            : 
     223                 :            :         /* NOTE: offering an initial window larger than 32767
     224                 :            :          * will break some buggy TCP stacks. If the admin tells us
     225                 :            :          * it is likely we could be speaking with such a buggy stack
     226                 :            :          * we will truncate our initial window offering to 32K-1
     227                 :            :          * unless the remote has sent us a window scaling option,
     228                 :            :          * which we interpret as a sign the remote TCP is not
     229                 :            :          * misinterpreting the window field as a signed quantity.
     230                 :            :          */
     231                 :          1 :         if (sock_net(sk)->ipv4.sysctl_tcp_workaround_signed_windows)
     232                 :          0 :                 (*rcv_wnd) = min(space, MAX_TCP_WINDOW);
     233                 :            :         else
     234                 :          1 :                 (*rcv_wnd) = min_t(u32, space, U16_MAX);
     235                 :            : 
     236                 :          1 :         if (init_rcv_wnd)
     237                 :          0 :                 *rcv_wnd = min(*rcv_wnd, init_rcv_wnd * mss);
     238                 :            : 
     239                 :          1 :         *rcv_wscale = 0;
     240                 :          1 :         if (wscale_ok) {
     241                 :            :                 /* Set window scaling on max possible window */
     242                 :          1 :                 space = max_t(u32, space, sock_net(sk)->ipv4.sysctl_tcp_rmem[2]);
     243                 :          1 :                 space = max_t(u32, space, sysctl_rmem_max);
     244                 :          1 :                 space = min_t(u32, space, *window_clamp);
     245                 :          1 :                 *rcv_wscale = clamp_t(int, ilog2(space) - 15,
     246                 :            :                                       0, TCP_MAX_WSCALE);
     247                 :            :         }
     248                 :            :         /* Set the clamp no higher than max representable value */
     249                 :          1 :         (*window_clamp) = min_t(__u32, U16_MAX << (*rcv_wscale), *window_clamp);
     250                 :          1 : }
     251                 :            : EXPORT_SYMBOL(tcp_select_initial_window);
     252                 :            : 
     253                 :            : /* Chose a new window to advertise, update state in tcp_sock for the
     254                 :            :  * socket, and return result with RFC1323 scaling applied.  The return
     255                 :            :  * value can be stuffed directly into th->window for an outgoing
     256                 :            :  * frame.
     257                 :            :  */
     258                 :          1 : static u16 tcp_select_window(struct sock *sk)
     259                 :            : {
     260                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     261                 :          1 :         u32 old_win = tp->rcv_wnd;
     262                 :            :         u32 cur_win = tcp_receive_window(tp);
     263                 :          1 :         u32 new_win = __tcp_select_window(sk);
     264                 :            : 
     265                 :            :         /* Never shrink the offered window */
     266                 :          1 :         if (new_win < cur_win) {
     267                 :            :                 /* Danger Will Robinson!
     268                 :            :                  * Don't update rcv_wup/rcv_wnd here or else
     269                 :            :                  * we will not be able to advertise a zero
     270                 :            :                  * window in time.  --DaveM
     271                 :            :                  *
     272                 :            :                  * Relax Will Robinson.
     273                 :            :                  */
     274                 :          1 :                 if (new_win == 0)
     275                 :          0 :                         NET_INC_STATS(sock_net(sk),
     276                 :            :                                       LINUX_MIB_TCPWANTZEROWINDOWADV);
     277                 :          1 :                 new_win = ALIGN(cur_win, 1 << tp->rx_opt.rcv_wscale);
     278                 :            :         }
     279                 :          1 :         tp->rcv_wnd = new_win;
     280                 :          1 :         tp->rcv_wup = tp->rcv_nxt;
     281                 :            : 
     282                 :            :         /* Make sure we do not exceed the maximum possible
     283                 :            :          * scaled window.
     284                 :            :          */
     285                 :          1 :         if (!tp->rx_opt.rcv_wscale &&
     286                 :          1 :             sock_net(sk)->ipv4.sysctl_tcp_workaround_signed_windows)
     287                 :          0 :                 new_win = min(new_win, MAX_TCP_WINDOW);
     288                 :            :         else
     289                 :          1 :                 new_win = min(new_win, (65535U << tp->rx_opt.rcv_wscale));
     290                 :            : 
     291                 :            :         /* RFC1323 scaling applied */
     292                 :          1 :         new_win >>= tp->rx_opt.rcv_wscale;
     293                 :            : 
     294                 :            :         /* If we advertise zero window, disable fast path. */
     295                 :          1 :         if (new_win == 0) {
     296                 :          0 :                 tp->pred_flags = 0;
     297                 :          0 :                 if (old_win)
     298                 :          0 :                         NET_INC_STATS(sock_net(sk),
     299                 :            :                                       LINUX_MIB_TCPTOZEROWINDOWADV);
     300                 :          1 :         } else if (old_win == 0) {
     301                 :          0 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPFROMZEROWINDOWADV);
     302                 :            :         }
     303                 :            : 
     304                 :          1 :         return new_win;
     305                 :            : }
     306                 :            : 
     307                 :            : /* Packet ECN state for a SYN-ACK */
     308                 :          0 : static void tcp_ecn_send_synack(struct sock *sk, struct sk_buff *skb)
     309                 :            : {
     310                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
     311                 :            : 
     312                 :          0 :         TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_CWR;
     313                 :          0 :         if (!(tp->ecn_flags & TCP_ECN_OK))
     314                 :          0 :                 TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_ECE;
     315                 :          0 :         else if (tcp_ca_needs_ecn(sk) ||
     316                 :            :                  tcp_bpf_ca_needs_ecn(sk))
     317                 :          0 :                 INET_ECN_xmit(sk);
     318                 :          0 : }
     319                 :            : 
     320                 :            : /* Packet ECN state for a SYN.  */
     321                 :          1 : static void tcp_ecn_send_syn(struct sock *sk, struct sk_buff *skb)
     322                 :            : {
     323                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     324                 :            :         bool bpf_needs_ecn = tcp_bpf_ca_needs_ecn(sk);
     325                 :          1 :         bool use_ecn = sock_net(sk)->ipv4.sysctl_tcp_ecn == 1 ||
     326                 :          1 :                 tcp_ca_needs_ecn(sk) || bpf_needs_ecn;
     327                 :            : 
     328                 :          1 :         if (!use_ecn) {
     329                 :            :                 const struct dst_entry *dst = __sk_dst_get(sk);
     330                 :            : 
     331                 :          1 :                 if (dst && dst_feature(dst, RTAX_FEATURE_ECN))
     332                 :            :                         use_ecn = true;
     333                 :            :         }
     334                 :            : 
     335                 :          1 :         tp->ecn_flags = 0;
     336                 :            : 
     337                 :          1 :         if (use_ecn) {
     338                 :          0 :                 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ECE | TCPHDR_CWR;
     339                 :          0 :                 tp->ecn_flags = TCP_ECN_OK;
     340                 :          0 :                 if (tcp_ca_needs_ecn(sk) || bpf_needs_ecn)
     341                 :          0 :                         INET_ECN_xmit(sk);
     342                 :            :         }
     343                 :          1 : }
     344                 :            : 
     345                 :            : static void tcp_ecn_clear_syn(struct sock *sk, struct sk_buff *skb)
     346                 :            : {
     347                 :          0 :         if (sock_net(sk)->ipv4.sysctl_tcp_ecn_fallback)
     348                 :            :                 /* tp->ecn_flags are cleared at a later point in time when
     349                 :            :                  * SYN ACK is ultimatively being received.
     350                 :            :                  */
     351                 :          0 :                 TCP_SKB_CB(skb)->tcp_flags &= ~(TCPHDR_ECE | TCPHDR_CWR);
     352                 :            : }
     353                 :            : 
     354                 :            : static void
     355                 :            : tcp_ecn_make_synack(const struct request_sock *req, struct tcphdr *th)
     356                 :            : {
     357                 :          0 :         if (inet_rsk(req)->ecn_ok)
     358                 :          0 :                 th->ece = 1;
     359                 :            : }
     360                 :            : 
     361                 :            : /* Set up ECN state for a packet on a ESTABLISHED socket that is about to
     362                 :            :  * be sent.
     363                 :            :  */
     364                 :          1 : static void tcp_ecn_send(struct sock *sk, struct sk_buff *skb,
     365                 :            :                          struct tcphdr *th, int tcp_header_len)
     366                 :            : {
     367                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     368                 :            : 
     369                 :          1 :         if (tp->ecn_flags & TCP_ECN_OK) {
     370                 :            :                 /* Not-retransmitted data segment: set ECT and inject CWR. */
     371                 :          0 :                 if (skb->len != tcp_header_len &&
     372                 :          0 :                     !before(TCP_SKB_CB(skb)->seq, tp->snd_nxt)) {
     373                 :          0 :                         INET_ECN_xmit(sk);
     374                 :          0 :                         if (tp->ecn_flags & TCP_ECN_QUEUE_CWR) {
     375                 :          0 :                                 tp->ecn_flags &= ~TCP_ECN_QUEUE_CWR;
     376                 :          0 :                                 th->cwr = 1;
     377                 :          0 :                                 skb_shinfo(skb)->gso_type |= SKB_GSO_TCP_ECN;
     378                 :            :                         }
     379                 :          0 :                 } else if (!tcp_ca_needs_ecn(sk)) {
     380                 :            :                         /* ACK or retransmitted segment: clear ECT|CE */
     381                 :          0 :                         INET_ECN_dontxmit(sk);
     382                 :            :                 }
     383                 :          0 :                 if (tp->ecn_flags & TCP_ECN_DEMAND_CWR)
     384                 :          0 :                         th->ece = 1;
     385                 :            :         }
     386                 :          1 : }
     387                 :            : 
     388                 :            : /* Constructs common control bits of non-data skb. If SYN/FIN is present,
     389                 :            :  * auto increment end seqno.
     390                 :            :  */
     391                 :            : static void tcp_init_nondata_skb(struct sk_buff *skb, u32 seq, u8 flags)
     392                 :            : {
     393                 :          1 :         skb->ip_summed = CHECKSUM_PARTIAL;
     394                 :            : 
     395                 :          1 :         TCP_SKB_CB(skb)->tcp_flags = flags;
     396                 :          1 :         TCP_SKB_CB(skb)->sacked = 0;
     397                 :            : 
     398                 :            :         tcp_skb_pcount_set(skb, 1);
     399                 :            : 
     400                 :          1 :         TCP_SKB_CB(skb)->seq = seq;
     401                 :            :         if (flags & (TCPHDR_SYN | TCPHDR_FIN))
     402                 :          1 :                 seq++;
     403                 :          1 :         TCP_SKB_CB(skb)->end_seq = seq;
     404                 :            : }
     405                 :            : 
     406                 :            : static inline bool tcp_urg_mode(const struct tcp_sock *tp)
     407                 :            : {
     408                 :          1 :         return tp->snd_una != tp->snd_up;
     409                 :            : }
     410                 :            : 
     411                 :            : #define OPTION_SACK_ADVERTISE   (1 << 0)
     412                 :            : #define OPTION_TS               (1 << 1)
     413                 :            : #define OPTION_MD5              (1 << 2)
     414                 :            : #define OPTION_WSCALE           (1 << 3)
     415                 :            : #define OPTION_FAST_OPEN_COOKIE (1 << 8)
     416                 :            : #define OPTION_SMC              (1 << 9)
     417                 :            : 
     418                 :            : static void smc_options_write(__be32 *ptr, u16 *options)
     419                 :            : {
     420                 :            : #if IS_ENABLED(CONFIG_SMC)
     421                 :            :         if (static_branch_unlikely(&tcp_have_smc)) {
     422                 :            :                 if (unlikely(OPTION_SMC & *options)) {
     423                 :            :                         *ptr++ = htonl((TCPOPT_NOP  << 24) |
     424                 :            :                                        (TCPOPT_NOP  << 16) |
     425                 :            :                                        (TCPOPT_EXP <<  8) |
     426                 :            :                                        (TCPOLEN_EXP_SMC_BASE));
     427                 :            :                         *ptr++ = htonl(TCPOPT_SMC_MAGIC);
     428                 :            :                 }
     429                 :            :         }
     430                 :            : #endif
     431                 :            : }
     432                 :            : 
     433                 :            : struct tcp_out_options {
     434                 :            :         u16 options;            /* bit field of OPTION_* */
     435                 :            :         u16 mss;                /* 0 to disable */
     436                 :            :         u8 ws;                  /* window scale, 0 to disable */
     437                 :            :         u8 num_sack_blocks;     /* number of SACK blocks to include */
     438                 :            :         u8 hash_size;           /* bytes in hash_location */
     439                 :            :         __u8 *hash_location;    /* temporary pointer, overloaded */
     440                 :            :         __u32 tsval, tsecr;     /* need to include OPTION_TS */
     441                 :            :         struct tcp_fastopen_cookie *fastopen_cookie;    /* Fast open cookie */
     442                 :            : };
     443                 :            : 
     444                 :            : /* Write previously computed TCP options to the packet.
     445                 :            :  *
     446                 :            :  * Beware: Something in the Internet is very sensitive to the ordering of
     447                 :            :  * TCP options, we learned this through the hard way, so be careful here.
     448                 :            :  * Luckily we can at least blame others for their non-compliance but from
     449                 :            :  * inter-operability perspective it seems that we're somewhat stuck with
     450                 :            :  * the ordering which we have been using if we want to keep working with
     451                 :            :  * those broken things (not that it currently hurts anybody as there isn't
     452                 :            :  * particular reason why the ordering would need to be changed).
     453                 :            :  *
     454                 :            :  * At least SACK_PERM as the first option is known to lead to a disaster
     455                 :            :  * (but it may well be that other scenarios fail similarly).
     456                 :            :  */
     457                 :          1 : static void tcp_options_write(__be32 *ptr, struct tcp_sock *tp,
     458                 :            :                               struct tcp_out_options *opts)
     459                 :            : {
     460                 :          1 :         u16 options = opts->options; /* mungable copy */
     461                 :            : 
     462                 :          1 :         if (unlikely(OPTION_MD5 & options)) {
     463                 :          0 :                 *ptr++ = htonl((TCPOPT_NOP << 24) | (TCPOPT_NOP << 16) |
     464                 :            :                                (TCPOPT_MD5SIG << 8) | TCPOLEN_MD5SIG);
     465                 :            :                 /* overload cookie hash location */
     466                 :          0 :                 opts->hash_location = (__u8 *)ptr;
     467                 :          0 :                 ptr += 4;
     468                 :            :         }
     469                 :            : 
     470                 :          1 :         if (unlikely(opts->mss)) {
     471                 :          1 :                 *ptr++ = htonl((TCPOPT_MSS << 24) |
     472                 :            :                                (TCPOLEN_MSS << 16) |
     473                 :            :                                opts->mss);
     474                 :            :         }
     475                 :            : 
     476                 :          1 :         if (likely(OPTION_TS & options)) {
     477                 :          1 :                 if (unlikely(OPTION_SACK_ADVERTISE & options)) {
     478                 :          1 :                         *ptr++ = htonl((TCPOPT_SACK_PERM << 24) |
     479                 :            :                                        (TCPOLEN_SACK_PERM << 16) |
     480                 :            :                                        (TCPOPT_TIMESTAMP << 8) |
     481                 :            :                                        TCPOLEN_TIMESTAMP);
     482                 :          1 :                         options &= ~OPTION_SACK_ADVERTISE;
     483                 :            :                 } else {
     484                 :          0 :                         *ptr++ = htonl((TCPOPT_NOP << 24) |
     485                 :            :                                        (TCPOPT_NOP << 16) |
     486                 :            :                                        (TCPOPT_TIMESTAMP << 8) |
     487                 :            :                                        TCPOLEN_TIMESTAMP);
     488                 :            :                 }
     489                 :          1 :                 *ptr++ = htonl(opts->tsval);
     490                 :          1 :                 *ptr++ = htonl(opts->tsecr);
     491                 :            :         }
     492                 :            : 
     493                 :          1 :         if (unlikely(OPTION_SACK_ADVERTISE & options)) {
     494                 :          0 :                 *ptr++ = htonl((TCPOPT_NOP << 24) |
     495                 :            :                                (TCPOPT_NOP << 16) |
     496                 :            :                                (TCPOPT_SACK_PERM << 8) |
     497                 :            :                                TCPOLEN_SACK_PERM);
     498                 :            :         }
     499                 :            : 
     500                 :          1 :         if (unlikely(OPTION_WSCALE & options)) {
     501                 :          1 :                 *ptr++ = htonl((TCPOPT_NOP << 24) |
     502                 :            :                                (TCPOPT_WINDOW << 16) |
     503                 :            :                                (TCPOLEN_WINDOW << 8) |
     504                 :            :                                opts->ws);
     505                 :            :         }
     506                 :            : 
     507                 :          1 :         if (unlikely(opts->num_sack_blocks)) {
     508                 :          0 :                 struct tcp_sack_block *sp = tp->rx_opt.dsack ?
     509                 :          0 :                         tp->duplicate_sack : tp->selective_acks;
     510                 :            :                 int this_sack;
     511                 :            : 
     512                 :          0 :                 *ptr++ = htonl((TCPOPT_NOP  << 24) |
     513                 :            :                                (TCPOPT_NOP  << 16) |
     514                 :            :                                (TCPOPT_SACK <<  8) |
     515                 :            :                                (TCPOLEN_SACK_BASE + (opts->num_sack_blocks *
     516                 :            :                                                      TCPOLEN_SACK_PERBLOCK)));
     517                 :            : 
     518                 :          0 :                 for (this_sack = 0; this_sack < opts->num_sack_blocks;
     519                 :          0 :                      ++this_sack) {
     520                 :          0 :                         *ptr++ = htonl(sp[this_sack].start_seq);
     521                 :          0 :                         *ptr++ = htonl(sp[this_sack].end_seq);
     522                 :            :                 }
     523                 :            : 
     524                 :          0 :                 tp->rx_opt.dsack = 0;
     525                 :            :         }
     526                 :            : 
     527                 :          1 :         if (unlikely(OPTION_FAST_OPEN_COOKIE & options)) {
     528                 :          0 :                 struct tcp_fastopen_cookie *foc = opts->fastopen_cookie;
     529                 :            :                 u8 *p = (u8 *)ptr;
     530                 :            :                 u32 len; /* Fast Open option length */
     531                 :            : 
     532                 :          0 :                 if (foc->exp) {
     533                 :          0 :                         len = TCPOLEN_EXP_FASTOPEN_BASE + foc->len;
     534                 :          0 :                         *ptr = htonl((TCPOPT_EXP << 24) | (len << 16) |
     535                 :            :                                      TCPOPT_FASTOPEN_MAGIC);
     536                 :          0 :                         p += TCPOLEN_EXP_FASTOPEN_BASE;
     537                 :            :                 } else {
     538                 :          0 :                         len = TCPOLEN_FASTOPEN_BASE + foc->len;
     539                 :          0 :                         *p++ = TCPOPT_FASTOPEN;
     540                 :          0 :                         *p++ = len;
     541                 :            :                 }
     542                 :            : 
     543                 :          0 :                 memcpy(p, foc->val, foc->len);
     544                 :          0 :                 if ((len & 3) == 2) {
     545                 :          0 :                         p[foc->len] = TCPOPT_NOP;
     546                 :          0 :                         p[foc->len + 1] = TCPOPT_NOP;
     547                 :            :                 }
     548                 :            :                 ptr += (len + 3) >> 2;
     549                 :            :         }
     550                 :            : 
     551                 :            :         smc_options_write(ptr, &options);
     552                 :          1 : }
     553                 :            : 
     554                 :            : static void smc_set_option(const struct tcp_sock *tp,
     555                 :            :                            struct tcp_out_options *opts,
     556                 :            :                            unsigned int *remaining)
     557                 :            : {
     558                 :            : #if IS_ENABLED(CONFIG_SMC)
     559                 :            :         if (static_branch_unlikely(&tcp_have_smc)) {
     560                 :            :                 if (tp->syn_smc) {
     561                 :            :                         if (*remaining >= TCPOLEN_EXP_SMC_BASE_ALIGNED) {
     562                 :            :                                 opts->options |= OPTION_SMC;
     563                 :            :                                 *remaining -= TCPOLEN_EXP_SMC_BASE_ALIGNED;
     564                 :            :                         }
     565                 :            :                 }
     566                 :            :         }
     567                 :            : #endif
     568                 :            : }
     569                 :            : 
     570                 :            : static void smc_set_option_cond(const struct tcp_sock *tp,
     571                 :            :                                 const struct inet_request_sock *ireq,
     572                 :            :                                 struct tcp_out_options *opts,
     573                 :            :                                 unsigned int *remaining)
     574                 :            : {
     575                 :            : #if IS_ENABLED(CONFIG_SMC)
     576                 :            :         if (static_branch_unlikely(&tcp_have_smc)) {
     577                 :            :                 if (tp->syn_smc && ireq->smc_ok) {
     578                 :            :                         if (*remaining >= TCPOLEN_EXP_SMC_BASE_ALIGNED) {
     579                 :            :                                 opts->options |= OPTION_SMC;
     580                 :            :                                 *remaining -= TCPOLEN_EXP_SMC_BASE_ALIGNED;
     581                 :            :                         }
     582                 :            :                 }
     583                 :            :         }
     584                 :            : #endif
     585                 :            : }
     586                 :            : 
     587                 :            : /* Compute TCP options for SYN packets. This is not the final
     588                 :            :  * network wire format yet.
     589                 :            :  */
     590                 :          1 : static unsigned int tcp_syn_options(struct sock *sk, struct sk_buff *skb,
     591                 :            :                                 struct tcp_out_options *opts,
     592                 :            :                                 struct tcp_md5sig_key **md5)
     593                 :            : {
     594                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     595                 :            :         unsigned int remaining = MAX_TCP_OPTION_SPACE;
     596                 :          1 :         struct tcp_fastopen_request *fastopen = tp->fastopen_req;
     597                 :            : 
     598                 :          1 :         *md5 = NULL;
     599                 :            : #ifdef CONFIG_TCP_MD5SIG
     600                 :            :         if (static_branch_unlikely(&tcp_md5_needed) &&
     601                 :            :             rcu_access_pointer(tp->md5sig_info)) {
     602                 :            :                 *md5 = tp->af_specific->md5_lookup(sk, sk);
     603                 :            :                 if (*md5) {
     604                 :            :                         opts->options |= OPTION_MD5;
     605                 :            :                         remaining -= TCPOLEN_MD5SIG_ALIGNED;
     606                 :            :                 }
     607                 :            :         }
     608                 :            : #endif
     609                 :            : 
     610                 :            :         /* We always get an MSS option.  The option bytes which will be seen in
     611                 :            :          * normal data packets should timestamps be used, must be in the MSS
     612                 :            :          * advertised.  But we subtract them from tp->mss_cache so that
     613                 :            :          * calculations in tcp_sendmsg are simpler etc.  So account for this
     614                 :            :          * fact here if necessary.  If we don't do this correctly, as a
     615                 :            :          * receiver we won't recognize data packets as being full sized when we
     616                 :            :          * should, and thus we won't abide by the delayed ACK rules correctly.
     617                 :            :          * SACKs don't matter, we never delay an ACK when we have any of those
     618                 :            :          * going out.  */
     619                 :          1 :         opts->mss = tcp_advertise_mss(sk);
     620                 :            :         remaining -= TCPOLEN_MSS_ALIGNED;
     621                 :            : 
     622                 :          1 :         if (likely(sock_net(sk)->ipv4.sysctl_tcp_timestamps && !*md5)) {
     623                 :          1 :                 opts->options |= OPTION_TS;
     624                 :          1 :                 opts->tsval = tcp_skb_timestamp(skb) + tp->tsoffset;
     625                 :          1 :                 opts->tsecr = tp->rx_opt.ts_recent;
     626                 :            :                 remaining -= TCPOLEN_TSTAMP_ALIGNED;
     627                 :            :         }
     628                 :          1 :         if (likely(sock_net(sk)->ipv4.sysctl_tcp_window_scaling)) {
     629                 :          1 :                 opts->ws = tp->rx_opt.rcv_wscale;
     630                 :          1 :                 opts->options |= OPTION_WSCALE;
     631                 :          1 :                 remaining -= TCPOLEN_WSCALE_ALIGNED;
     632                 :            :         }
     633                 :          1 :         if (likely(sock_net(sk)->ipv4.sysctl_tcp_sack)) {
     634                 :          1 :                 opts->options |= OPTION_SACK_ADVERTISE;
     635                 :          1 :                 if (unlikely(!(OPTION_TS & opts->options)))
     636                 :          0 :                         remaining -= TCPOLEN_SACKPERM_ALIGNED;
     637                 :            :         }
     638                 :            : 
     639                 :          1 :         if (fastopen && fastopen->cookie.len >= 0) {
     640                 :          0 :                 u32 need = fastopen->cookie.len;
     641                 :            : 
     642                 :          0 :                 need += fastopen->cookie.exp ? TCPOLEN_EXP_FASTOPEN_BASE :
     643                 :            :                                                TCPOLEN_FASTOPEN_BASE;
     644                 :          0 :                 need = (need + 3) & ~3U;  /* Align to 32 bits */
     645                 :          0 :                 if (remaining >= need) {
     646                 :          0 :                         opts->options |= OPTION_FAST_OPEN_COOKIE;
     647                 :          0 :                         opts->fastopen_cookie = &fastopen->cookie;
     648                 :          0 :                         remaining -= need;
     649                 :          0 :                         tp->syn_fastopen = 1;
     650                 :          0 :                         tp->syn_fastopen_exp = fastopen->cookie.exp ? 1 : 0;
     651                 :            :                 }
     652                 :            :         }
     653                 :            : 
     654                 :            :         smc_set_option(tp, opts, &remaining);
     655                 :            : 
     656                 :          1 :         return MAX_TCP_OPTION_SPACE - remaining;
     657                 :            : }
     658                 :            : 
     659                 :            : /* Set up TCP options for SYN-ACKs. */
     660                 :          0 : static unsigned int tcp_synack_options(const struct sock *sk,
     661                 :            :                                        struct request_sock *req,
     662                 :            :                                        unsigned int mss, struct sk_buff *skb,
     663                 :            :                                        struct tcp_out_options *opts,
     664                 :            :                                        const struct tcp_md5sig_key *md5,
     665                 :            :                                        struct tcp_fastopen_cookie *foc,
     666                 :            :                                        enum tcp_synack_type synack_type)
     667                 :            : {
     668                 :            :         struct inet_request_sock *ireq = inet_rsk(req);
     669                 :            :         unsigned int remaining = MAX_TCP_OPTION_SPACE;
     670                 :            : 
     671                 :            : #ifdef CONFIG_TCP_MD5SIG
     672                 :            :         if (md5) {
     673                 :            :                 opts->options |= OPTION_MD5;
     674                 :            :                 remaining -= TCPOLEN_MD5SIG_ALIGNED;
     675                 :            : 
     676                 :            :                 /* We can't fit any SACK blocks in a packet with MD5 + TS
     677                 :            :                  * options. There was discussion about disabling SACK
     678                 :            :                  * rather than TS in order to fit in better with old,
     679                 :            :                  * buggy kernels, but that was deemed to be unnecessary.
     680                 :            :                  */
     681                 :            :                 if (synack_type != TCP_SYNACK_COOKIE)
     682                 :            :                         ireq->tstamp_ok &= !ireq->sack_ok;
     683                 :            :         }
     684                 :            : #endif
     685                 :            : 
     686                 :            :         /* We always send an MSS option. */
     687                 :          0 :         opts->mss = mss;
     688                 :            :         remaining -= TCPOLEN_MSS_ALIGNED;
     689                 :            : 
     690                 :          0 :         if (likely(ireq->wscale_ok)) {
     691                 :          0 :                 opts->ws = ireq->rcv_wscale;
     692                 :          0 :                 opts->options |= OPTION_WSCALE;
     693                 :            :                 remaining -= TCPOLEN_WSCALE_ALIGNED;
     694                 :            :         }
     695                 :          0 :         if (likely(ireq->tstamp_ok)) {
     696                 :          0 :                 opts->options |= OPTION_TS;
     697                 :          0 :                 opts->tsval = tcp_skb_timestamp(skb) + tcp_rsk(req)->ts_off;
     698                 :          0 :                 opts->tsecr = req->ts_recent;
     699                 :          0 :                 remaining -= TCPOLEN_TSTAMP_ALIGNED;
     700                 :            :         }
     701                 :          0 :         if (likely(ireq->sack_ok)) {
     702                 :          0 :                 opts->options |= OPTION_SACK_ADVERTISE;
     703                 :          0 :                 if (unlikely(!ireq->tstamp_ok))
     704                 :          0 :                         remaining -= TCPOLEN_SACKPERM_ALIGNED;
     705                 :            :         }
     706                 :          0 :         if (foc != NULL && foc->len >= 0) {
     707                 :          0 :                 u32 need = foc->len;
     708                 :            : 
     709                 :          0 :                 need += foc->exp ? TCPOLEN_EXP_FASTOPEN_BASE :
     710                 :            :                                    TCPOLEN_FASTOPEN_BASE;
     711                 :          0 :                 need = (need + 3) & ~3U;  /* Align to 32 bits */
     712                 :          0 :                 if (remaining >= need) {
     713                 :          0 :                         opts->options |= OPTION_FAST_OPEN_COOKIE;
     714                 :          0 :                         opts->fastopen_cookie = foc;
     715                 :          0 :                         remaining -= need;
     716                 :            :                 }
     717                 :            :         }
     718                 :            : 
     719                 :            :         smc_set_option_cond(tcp_sk(sk), ireq, opts, &remaining);
     720                 :            : 
     721                 :          0 :         return MAX_TCP_OPTION_SPACE - remaining;
     722                 :            : }
     723                 :            : 
     724                 :            : /* Compute TCP options for ESTABLISHED sockets. This is not the
     725                 :            :  * final wire format yet.
     726                 :            :  */
     727                 :          1 : static unsigned int tcp_established_options(struct sock *sk, struct sk_buff *skb,
     728                 :            :                                         struct tcp_out_options *opts,
     729                 :            :                                         struct tcp_md5sig_key **md5)
     730                 :            : {
     731                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     732                 :            :         unsigned int size = 0;
     733                 :            :         unsigned int eff_sacks;
     734                 :            : 
     735                 :          1 :         opts->options = 0;
     736                 :            : 
     737                 :          1 :         *md5 = NULL;
     738                 :            : #ifdef CONFIG_TCP_MD5SIG
     739                 :            :         if (static_branch_unlikely(&tcp_md5_needed) &&
     740                 :            :             rcu_access_pointer(tp->md5sig_info)) {
     741                 :            :                 *md5 = tp->af_specific->md5_lookup(sk, sk);
     742                 :            :                 if (*md5) {
     743                 :            :                         opts->options |= OPTION_MD5;
     744                 :            :                         size += TCPOLEN_MD5SIG_ALIGNED;
     745                 :            :                 }
     746                 :            :         }
     747                 :            : #endif
     748                 :            : 
     749                 :          1 :         if (likely(tp->rx_opt.tstamp_ok)) {
     750                 :          0 :                 opts->options |= OPTION_TS;
     751                 :          0 :                 opts->tsval = skb ? tcp_skb_timestamp(skb) + tp->tsoffset : 0;
     752                 :          0 :                 opts->tsecr = tp->rx_opt.ts_recent;
     753                 :            :                 size += TCPOLEN_TSTAMP_ALIGNED;
     754                 :            :         }
     755                 :            : 
     756                 :          1 :         eff_sacks = tp->rx_opt.num_sacks + tp->rx_opt.dsack;
     757                 :          1 :         if (unlikely(eff_sacks)) {
     758                 :            :                 const unsigned int remaining = MAX_TCP_OPTION_SPACE - size;
     759                 :          0 :                 opts->num_sack_blocks =
     760                 :          0 :                         min_t(unsigned int, eff_sacks,
     761                 :            :                               (remaining - TCPOLEN_SACK_BASE_ALIGNED) /
     762                 :            :                               TCPOLEN_SACK_PERBLOCK);
     763                 :          0 :                 if (likely(opts->num_sack_blocks))
     764                 :          0 :                         size += TCPOLEN_SACK_BASE_ALIGNED +
     765                 :          0 :                                 opts->num_sack_blocks * TCPOLEN_SACK_PERBLOCK;
     766                 :            :         }
     767                 :            : 
     768                 :          1 :         return size;
     769                 :            : }
     770                 :            : 
     771                 :            : 
     772                 :            : /* TCP SMALL QUEUES (TSQ)
     773                 :            :  *
     774                 :            :  * TSQ goal is to keep small amount of skbs per tcp flow in tx queues (qdisc+dev)
     775                 :            :  * to reduce RTT and bufferbloat.
     776                 :            :  * We do this using a special skb destructor (tcp_wfree).
     777                 :            :  *
     778                 :            :  * Its important tcp_wfree() can be replaced by sock_wfree() in the event skb
     779                 :            :  * needs to be reallocated in a driver.
     780                 :            :  * The invariant being skb->truesize subtracted from sk->sk_wmem_alloc
     781                 :            :  *
     782                 :            :  * Since transmit from skb destructor is forbidden, we use a tasklet
     783                 :            :  * to process all sockets that eventually need to send more skbs.
     784                 :            :  * We use one tasklet per cpu, with its own queue of sockets.
     785                 :            :  */
     786                 :            : struct tsq_tasklet {
     787                 :            :         struct tasklet_struct   tasklet;
     788                 :            :         struct list_head        head; /* queue of tcp sockets */
     789                 :            : };
     790                 :            : static DEFINE_PER_CPU(struct tsq_tasklet, tsq_tasklet);
     791                 :            : 
     792                 :          1 : static void tcp_tsq_write(struct sock *sk)
     793                 :            : {
     794                 :          1 :         if ((1 << sk->sk_state) &
     795                 :            :             (TCPF_ESTABLISHED | TCPF_FIN_WAIT1 | TCPF_CLOSING |
     796                 :            :              TCPF_CLOSE_WAIT  | TCPF_LAST_ACK)) {
     797                 :            :                 struct tcp_sock *tp = tcp_sk(sk);
     798                 :            : 
     799                 :          1 :                 if (tp->lost_out > tp->retrans_out &&
     800                 :          0 :                     tp->snd_cwnd > tcp_packets_in_flight(tp)) {
     801                 :          0 :                         tcp_mstamp_refresh(tp);
     802                 :          0 :                         tcp_xmit_retransmit_queue(sk);
     803                 :            :                 }
     804                 :            : 
     805                 :          1 :                 tcp_write_xmit(sk, tcp_current_mss(sk), tp->nonagle,
     806                 :            :                                0, GFP_ATOMIC);
     807                 :            :         }
     808                 :          1 : }
     809                 :            : 
     810                 :          1 : static void tcp_tsq_handler(struct sock *sk)
     811                 :            : {
     812                 :            :         bh_lock_sock(sk);
     813                 :          1 :         if (!sock_owned_by_user(sk))
     814                 :          1 :                 tcp_tsq_write(sk);
     815                 :          1 :         else if (!test_and_set_bit(TCP_TSQ_DEFERRED, &sk->sk_tsq_flags))
     816                 :            :                 sock_hold(sk);
     817                 :            :         bh_unlock_sock(sk);
     818                 :          1 : }
     819                 :            : /*
     820                 :            :  * One tasklet per cpu tries to send more skbs.
     821                 :            :  * We run in tasklet context but need to disable irqs when
     822                 :            :  * transferring tsq->head because tcp_wfree() might
     823                 :            :  * interrupt us (non NAPI drivers)
     824                 :            :  */
     825                 :          1 : static void tcp_tasklet_func(unsigned long data)
     826                 :            : {
     827                 :          1 :         struct tsq_tasklet *tsq = (struct tsq_tasklet *)data;
     828                 :          1 :         LIST_HEAD(list);
     829                 :            :         unsigned long flags;
     830                 :            :         struct list_head *q, *n;
     831                 :            :         struct tcp_sock *tp;
     832                 :            :         struct sock *sk;
     833                 :            : 
     834                 :          1 :         local_irq_save(flags);
     835                 :          1 :         list_splice_init(&tsq->head, &list);
     836                 :          1 :         local_irq_restore(flags);
     837                 :            : 
     838                 :          1 :         list_for_each_safe(q, n, &list) {
     839                 :          1 :                 tp = list_entry(q, struct tcp_sock, tsq_node);
     840                 :            :                 list_del(&tp->tsq_node);
     841                 :            : 
     842                 :            :                 sk = (struct sock *)tp;
     843                 :          1 :                 smp_mb__before_atomic();
     844                 :          1 :                 clear_bit(TSQ_QUEUED, &sk->sk_tsq_flags);
     845                 :            : 
     846                 :          1 :                 tcp_tsq_handler(sk);
     847                 :          1 :                 sk_free(sk);
     848                 :            :         }
     849                 :          1 : }
     850                 :            : 
     851                 :            : #define TCP_DEFERRED_ALL (TCPF_TSQ_DEFERRED |           \
     852                 :            :                           TCPF_WRITE_TIMER_DEFERRED |   \
     853                 :            :                           TCPF_DELACK_TIMER_DEFERRED |  \
     854                 :            :                           TCPF_MTU_REDUCED_DEFERRED)
     855                 :            : /**
     856                 :            :  * tcp_release_cb - tcp release_sock() callback
     857                 :            :  * @sk: socket
     858                 :            :  *
     859                 :            :  * called from release_sock() to perform protocol dependent
     860                 :            :  * actions before socket release.
     861                 :            :  */
     862                 :          1 : void tcp_release_cb(struct sock *sk)
     863                 :            : {
     864                 :            :         unsigned long flags, nflags;
     865                 :            : 
     866                 :            :         /* perform an atomic operation only if at least one flag is set */
     867                 :            :         do {
     868                 :          1 :                 flags = sk->sk_tsq_flags;
     869                 :          1 :                 if (!(flags & TCP_DEFERRED_ALL))
     870                 :          1 :                         return;
     871                 :          1 :                 nflags = flags & ~TCP_DEFERRED_ALL;
     872                 :          1 :         } while (cmpxchg(&sk->sk_tsq_flags, flags, nflags) != flags);
     873                 :            : 
     874                 :          1 :         if (flags & TCPF_TSQ_DEFERRED) {
     875                 :          1 :                 tcp_tsq_write(sk);
     876                 :            :                 __sock_put(sk);
     877                 :            :         }
     878                 :            :         /* Here begins the tricky part :
     879                 :            :          * We are called from release_sock() with :
     880                 :            :          * 1) BH disabled
     881                 :            :          * 2) sk_lock.slock spinlock held
     882                 :            :          * 3) socket owned by us (sk->sk_lock.owned == 1)
     883                 :            :          *
     884                 :            :          * But following code is meant to be called from BH handlers,
     885                 :            :          * so we should keep BH disabled, but early release socket ownership
     886                 :            :          */
     887                 :            :         sock_release_ownership(sk);
     888                 :            : 
     889                 :          1 :         if (flags & TCPF_WRITE_TIMER_DEFERRED) {
     890                 :          0 :                 tcp_write_timer_handler(sk);
     891                 :            :                 __sock_put(sk);
     892                 :            :         }
     893                 :          1 :         if (flags & TCPF_DELACK_TIMER_DEFERRED) {
     894                 :          0 :                 tcp_delack_timer_handler(sk);
     895                 :            :                 __sock_put(sk);
     896                 :            :         }
     897                 :          1 :         if (flags & TCPF_MTU_REDUCED_DEFERRED) {
     898                 :          0 :                 inet_csk(sk)->icsk_af_ops->mtu_reduced(sk);
     899                 :            :                 __sock_put(sk);
     900                 :            :         }
     901                 :            : }
     902                 :            : EXPORT_SYMBOL(tcp_release_cb);
     903                 :            : 
     904                 :          3 : void __init tcp_tasklet_init(void)
     905                 :            : {
     906                 :            :         int i;
     907                 :            : 
     908                 :          3 :         for_each_possible_cpu(i) {
     909                 :          3 :                 struct tsq_tasklet *tsq = &per_cpu(tsq_tasklet, i);
     910                 :            : 
     911                 :          3 :                 INIT_LIST_HEAD(&tsq->head);
     912                 :          3 :                 tasklet_init(&tsq->tasklet,
     913                 :            :                              tcp_tasklet_func,
     914                 :            :                              (unsigned long)tsq);
     915                 :            :         }
     916                 :          3 : }
     917                 :            : 
     918                 :            : /*
     919                 :            :  * Write buffer destructor automatically called from kfree_skb.
     920                 :            :  * We can't xmit new skbs from this context, as we might already
     921                 :            :  * hold qdisc lock.
     922                 :            :  */
     923                 :          1 : void tcp_wfree(struct sk_buff *skb)
     924                 :            : {
     925                 :          1 :         struct sock *sk = skb->sk;
     926                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     927                 :            :         unsigned long flags, nval, oval;
     928                 :            : 
     929                 :            :         /* Keep one reference on sk_wmem_alloc.
     930                 :            :          * Will be released by sk_free() from here or tcp_tasklet_func()
     931                 :            :          */
     932                 :          1 :         WARN_ON(refcount_sub_and_test(skb->truesize - 1, &sk->sk_wmem_alloc));
     933                 :            : 
     934                 :            :         /* If this softirq is serviced by ksoftirqd, we are likely under stress.
     935                 :            :          * Wait until our queues (qdisc + devices) are drained.
     936                 :            :          * This gives :
     937                 :            :          * - less callbacks to tcp_write_xmit(), reducing stress (batches)
     938                 :            :          * - chance for incoming ACK (processed by another cpu maybe)
     939                 :            :          *   to migrate this flow (skb->ooo_okay will be eventually set)
     940                 :            :          */
     941                 :          1 :         if (refcount_read(&sk->sk_wmem_alloc) >= SKB_TRUESIZE(1) && this_cpu_ksoftirqd() == current)
     942                 :            :                 goto out;
     943                 :            : 
     944                 :            :         for (oval = READ_ONCE(sk->sk_tsq_flags);; oval = nval) {
     945                 :            :                 struct tsq_tasklet *tsq;
     946                 :            :                 bool empty;
     947                 :            : 
     948                 :          1 :                 if (!(oval & TSQF_THROTTLED) || (oval & TSQF_QUEUED))
     949                 :            :                         goto out;
     950                 :            : 
     951                 :          1 :                 nval = (oval & ~TSQF_THROTTLED) | TSQF_QUEUED;
     952                 :          1 :                 nval = cmpxchg(&sk->sk_tsq_flags, oval, nval);
     953                 :          1 :                 if (nval != oval)
     954                 :          0 :                         continue;
     955                 :            : 
     956                 :            :                 /* queue this socket to tasklet queue */
     957                 :          1 :                 local_irq_save(flags);
     958                 :          1 :                 tsq = this_cpu_ptr(&tsq_tasklet);
     959                 :          1 :                 empty = list_empty(&tsq->head);
     960                 :          1 :                 list_add(&tp->tsq_node, &tsq->head);
     961                 :          1 :                 if (empty)
     962                 :          1 :                         tasklet_schedule(&tsq->tasklet);
     963                 :          1 :                 local_irq_restore(flags);
     964                 :          1 :                 return;
     965                 :          0 :         }
     966                 :            : out:
     967                 :          1 :         sk_free(sk);
     968                 :            : }
     969                 :            : 
     970                 :            : /* Note: Called under soft irq.
     971                 :            :  * We can call TCP stack right away, unless socket is owned by user.
     972                 :            :  */
     973                 :          0 : enum hrtimer_restart tcp_pace_kick(struct hrtimer *timer)
     974                 :            : {
     975                 :          0 :         struct tcp_sock *tp = container_of(timer, struct tcp_sock, pacing_timer);
     976                 :            :         struct sock *sk = (struct sock *)tp;
     977                 :            : 
     978                 :          0 :         tcp_tsq_handler(sk);
     979                 :          0 :         sock_put(sk);
     980                 :            : 
     981                 :          0 :         return HRTIMER_NORESTART;
     982                 :            : }
     983                 :            : 
     984                 :          1 : static void tcp_update_skb_after_send(struct sock *sk, struct sk_buff *skb,
     985                 :            :                                       u64 prior_wstamp)
     986                 :            : {
     987                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     988                 :            : 
     989                 :          1 :         if (sk->sk_pacing_status != SK_PACING_NONE) {
     990                 :          0 :                 unsigned long rate = sk->sk_pacing_rate;
     991                 :            : 
     992                 :            :                 /* Original sch_fq does not pace first 10 MSS
     993                 :            :                  * Note that tp->data_segs_out overflows after 2^32 packets,
     994                 :            :                  * this is a minor annoyance.
     995                 :            :                  */
     996                 :          0 :                 if (rate != ~0UL && rate && tp->data_segs_out >= 10) {
     997                 :          0 :                         u64 len_ns = div64_ul((u64)skb->len * NSEC_PER_SEC, rate);
     998                 :          0 :                         u64 credit = tp->tcp_wstamp_ns - prior_wstamp;
     999                 :            : 
    1000                 :            :                         /* take into account OS jitter */
    1001                 :          0 :                         len_ns -= min_t(u64, len_ns / 2, credit);
    1002                 :          0 :                         tp->tcp_wstamp_ns += len_ns;
    1003                 :            :                 }
    1004                 :            :         }
    1005                 :          1 :         list_move_tail(&skb->tcp_tsorted_anchor, &tp->tsorted_sent_queue);
    1006                 :          1 : }
    1007                 :            : 
    1008                 :            : /* This routine actually transmits TCP packets queued in by
    1009                 :            :  * tcp_do_sendmsg().  This is used by both the initial
    1010                 :            :  * transmission and possible later retransmissions.
    1011                 :            :  * All SKB's seen here are completely headerless.  It is our
    1012                 :            :  * job to build the TCP header, and pass the packet down to
    1013                 :            :  * IP so it can do the same plus pass the packet off to the
    1014                 :            :  * device.
    1015                 :            :  *
    1016                 :            :  * We are working here with either a clone of the original
    1017                 :            :  * SKB, or a fresh unique copy made by the retransmit engine.
    1018                 :            :  */
    1019                 :          1 : static int __tcp_transmit_skb(struct sock *sk, struct sk_buff *skb,
    1020                 :            :                               int clone_it, gfp_t gfp_mask, u32 rcv_nxt)
    1021                 :            : {
    1022                 :            :         const struct inet_connection_sock *icsk = inet_csk(sk);
    1023                 :            :         struct inet_sock *inet;
    1024                 :            :         struct tcp_sock *tp;
    1025                 :            :         struct tcp_skb_cb *tcb;
    1026                 :            :         struct tcp_out_options opts;
    1027                 :            :         unsigned int tcp_options_size, tcp_header_size;
    1028                 :            :         struct sk_buff *oskb = NULL;
    1029                 :            :         struct tcp_md5sig_key *md5;
    1030                 :            :         struct tcphdr *th;
    1031                 :            :         u64 prior_wstamp;
    1032                 :            :         int err;
    1033                 :            : 
    1034                 :          1 :         BUG_ON(!skb || !tcp_skb_pcount(skb));
    1035                 :            :         tp = tcp_sk(sk);
    1036                 :          1 :         prior_wstamp = tp->tcp_wstamp_ns;
    1037                 :          1 :         tp->tcp_wstamp_ns = max(tp->tcp_wstamp_ns, tp->tcp_clock_cache);
    1038                 :          1 :         skb->skb_mstamp_ns = tp->tcp_wstamp_ns;
    1039                 :          1 :         if (clone_it) {
    1040                 :          1 :                 TCP_SKB_CB(skb)->tx.in_flight = TCP_SKB_CB(skb)->end_seq
    1041                 :          1 :                         - tp->snd_una;
    1042                 :            :                 oskb = skb;
    1043                 :            : 
    1044                 :          1 :                 tcp_skb_tsorted_save(oskb) {
    1045                 :          1 :                         if (unlikely(skb_cloned(oskb)))
    1046                 :            :                                 skb = pskb_copy(oskb, gfp_mask);
    1047                 :            :                         else
    1048                 :          1 :                                 skb = skb_clone(oskb, gfp_mask);
    1049                 :          1 :                 } tcp_skb_tsorted_restore(oskb);
    1050                 :            : 
    1051                 :          1 :                 if (unlikely(!skb))
    1052                 :            :                         return -ENOBUFS;
    1053                 :            :                 /* retransmit skbs might have a non zero value in skb->dev
    1054                 :            :                  * because skb->dev is aliased with skb->rbnode.rb_left
    1055                 :            :                  */
    1056                 :          1 :                 skb->dev = NULL;
    1057                 :            :         }
    1058                 :            : 
    1059                 :            :         inet = inet_sk(sk);
    1060                 :            :         tcb = TCP_SKB_CB(skb);
    1061                 :          1 :         memset(&opts, 0, sizeof(opts));
    1062                 :            : 
    1063                 :          1 :         if (unlikely(tcb->tcp_flags & TCPHDR_SYN)) {
    1064                 :          1 :                 tcp_options_size = tcp_syn_options(sk, skb, &opts, &md5);
    1065                 :            :         } else {
    1066                 :          1 :                 tcp_options_size = tcp_established_options(sk, skb, &opts,
    1067                 :            :                                                            &md5);
    1068                 :            :                 /* Force a PSH flag on all (GSO) packets to expedite GRO flush
    1069                 :            :                  * at receiver : This slightly improve GRO performance.
    1070                 :            :                  * Note that we do not force the PSH flag for non GSO packets,
    1071                 :            :                  * because they might be sent under high congestion events,
    1072                 :            :                  * and in this case it is better to delay the delivery of 1-MSS
    1073                 :            :                  * packets and thus the corresponding ACK packet that would
    1074                 :            :                  * release the following packet.
    1075                 :            :                  */
    1076                 :          1 :                 if (tcp_skb_pcount(skb) > 1)
    1077                 :          0 :                         tcb->tcp_flags |= TCPHDR_PSH;
    1078                 :            :         }
    1079                 :          1 :         tcp_header_size = tcp_options_size + sizeof(struct tcphdr);
    1080                 :            : 
    1081                 :            :         /* if no packet is in qdisc/device queue, then allow XPS to select
    1082                 :            :          * another queue. We can be called from tcp_tsq_handler()
    1083                 :            :          * which holds one reference to sk.
    1084                 :            :          *
    1085                 :            :          * TODO: Ideally, in-flight pure ACK packets should not matter here.
    1086                 :            :          * One way to get this would be to set skb->truesize = 2 on them.
    1087                 :            :          */
    1088                 :          1 :         skb->ooo_okay = sk_wmem_alloc_get(sk) < SKB_TRUESIZE(1);
    1089                 :            : 
    1090                 :            :         /* If we had to use memory reserve to allocate this skb,
    1091                 :            :          * this might cause drops if packet is looped back :
    1092                 :            :          * Other socket might not have SOCK_MEMALLOC.
    1093                 :            :          * Packets not looped back do not care about pfmemalloc.
    1094                 :            :          */
    1095                 :          1 :         skb->pfmemalloc = 0;
    1096                 :            : 
    1097                 :          1 :         skb_push(skb, tcp_header_size);
    1098                 :            :         skb_reset_transport_header(skb);
    1099                 :            : 
    1100                 :          1 :         skb_orphan(skb);
    1101                 :          1 :         skb->sk = sk;
    1102                 :          1 :         skb->destructor = skb_is_tcp_pure_ack(skb) ? __sock_wfree : tcp_wfree;
    1103                 :            :         skb_set_hash_from_sk(skb, sk);
    1104                 :          1 :         refcount_add(skb->truesize, &sk->sk_wmem_alloc);
    1105                 :            : 
    1106                 :          1 :         skb_set_dst_pending_confirm(skb, sk->sk_dst_pending_confirm);
    1107                 :            : 
    1108                 :            :         /* Build TCP header and checksum it. */
    1109                 :          1 :         th = (struct tcphdr *)skb->data;
    1110                 :          1 :         th->source           = inet->inet_sport;
    1111                 :          1 :         th->dest             = inet->inet_dport;
    1112                 :          1 :         th->seq                      = htonl(tcb->seq);
    1113                 :          1 :         th->ack_seq          = htonl(rcv_nxt);
    1114                 :          1 :         *(((__be16 *)th) + 6)   = htons(((tcp_header_size >> 2) << 12) |
    1115                 :            :                                         tcb->tcp_flags);
    1116                 :            : 
    1117                 :          1 :         th->check            = 0;
    1118                 :          1 :         th->urg_ptr          = 0;
    1119                 :            : 
    1120                 :            :         /* The urg_mode check is necessary during a below snd_una win probe */
    1121                 :          1 :         if (unlikely(tcp_urg_mode(tp) && before(tcb->seq, tp->snd_up))) {
    1122                 :          0 :                 if (before(tp->snd_up, tcb->seq + 0x10000)) {
    1123                 :          0 :                         th->urg_ptr = htons(tp->snd_up - tcb->seq);
    1124                 :          0 :                         th->urg = 1;
    1125                 :          0 :                 } else if (after(tcb->seq + 0xFFFF, tp->snd_nxt)) {
    1126                 :          0 :                         th->urg_ptr = htons(0xFFFF);
    1127                 :          0 :                         th->urg = 1;
    1128                 :            :                 }
    1129                 :            :         }
    1130                 :            : 
    1131                 :          1 :         tcp_options_write((__be32 *)(th + 1), tp, &opts);
    1132                 :          1 :         skb_shinfo(skb)->gso_type = sk->sk_gso_type;
    1133                 :          1 :         if (likely(!(tcb->tcp_flags & TCPHDR_SYN))) {
    1134                 :          1 :                 th->window      = htons(tcp_select_window(sk));
    1135                 :          1 :                 tcp_ecn_send(sk, skb, th, tcp_header_size);
    1136                 :            :         } else {
    1137                 :            :                 /* RFC1323: The window in SYN & SYN/ACK segments
    1138                 :            :                  * is never scaled.
    1139                 :            :                  */
    1140                 :          1 :                 th->window   = htons(min(tp->rcv_wnd, 65535U));
    1141                 :            :         }
    1142                 :            : #ifdef CONFIG_TCP_MD5SIG
    1143                 :            :         /* Calculate the MD5 hash, as we have all we need now */
    1144                 :            :         if (md5) {
    1145                 :            :                 sk_nocaps_add(sk, NETIF_F_GSO_MASK);
    1146                 :            :                 tp->af_specific->calc_md5_hash(opts.hash_location,
    1147                 :            :                                                md5, sk, skb);
    1148                 :            :         }
    1149                 :            : #endif
    1150                 :            : 
    1151                 :          1 :         icsk->icsk_af_ops->send_check(sk, skb);
    1152                 :            : 
    1153                 :          1 :         if (likely(tcb->tcp_flags & TCPHDR_ACK))
    1154                 :          1 :                 tcp_event_ack_sent(sk, tcp_skb_pcount(skb), rcv_nxt);
    1155                 :            : 
    1156                 :          1 :         if (skb->len != tcp_header_size) {
    1157                 :          1 :                 tcp_event_data_sent(tp, sk);
    1158                 :          1 :                 tp->data_segs_out += tcp_skb_pcount(skb);
    1159                 :          1 :                 tp->bytes_sent += skb->len - tcp_header_size;
    1160                 :            :         }
    1161                 :            : 
    1162                 :          1 :         if (after(tcb->end_seq, tp->snd_nxt) || tcb->seq == tcb->end_seq)
    1163                 :          1 :                 TCP_ADD_STATS(sock_net(sk), TCP_MIB_OUTSEGS,
    1164                 :            :                               tcp_skb_pcount(skb));
    1165                 :            : 
    1166                 :          1 :         tp->segs_out += tcp_skb_pcount(skb);
    1167                 :            :         /* OK, its time to fill skb_shinfo(skb)->gso_{segs|size} */
    1168                 :          1 :         skb_shinfo(skb)->gso_segs = tcp_skb_pcount(skb);
    1169                 :          1 :         skb_shinfo(skb)->gso_size = tcp_skb_mss(skb);
    1170                 :            : 
    1171                 :            :         /* Leave earliest departure time in skb->tstamp (skb->skb_mstamp_ns) */
    1172                 :            : 
    1173                 :            :         /* Cleanup our debris for IP stacks */
    1174                 :          1 :         memset(skb->cb, 0, max(sizeof(struct inet_skb_parm),
    1175                 :            :                                sizeof(struct inet6_skb_parm)));
    1176                 :            : 
    1177                 :            :         tcp_add_tx_delay(skb, tp);
    1178                 :            : 
    1179                 :          1 :         err = icsk->icsk_af_ops->queue_xmit(sk, skb, &inet->cork.fl);
    1180                 :            : 
    1181                 :          1 :         if (unlikely(err > 0)) {
    1182                 :          0 :                 tcp_enter_cwr(sk);
    1183                 :          0 :                 err = net_xmit_eval(err);
    1184                 :            :         }
    1185                 :          1 :         if (!err && oskb) {
    1186                 :          1 :                 tcp_update_skb_after_send(sk, oskb, prior_wstamp);
    1187                 :          1 :                 tcp_rate_skb_sent(sk, oskb);
    1188                 :            :         }
    1189                 :          1 :         return err;
    1190                 :            : }
    1191                 :            : 
    1192                 :            : static int tcp_transmit_skb(struct sock *sk, struct sk_buff *skb, int clone_it,
    1193                 :            :                             gfp_t gfp_mask)
    1194                 :            : {
    1195                 :          1 :         return __tcp_transmit_skb(sk, skb, clone_it, gfp_mask,
    1196                 :            :                                   tcp_sk(sk)->rcv_nxt);
    1197                 :            : }
    1198                 :            : 
    1199                 :            : /* This routine just queues the buffer for sending.
    1200                 :            :  *
    1201                 :            :  * NOTE: probe0 timer is not checked, do not forget tcp_push_pending_frames,
    1202                 :            :  * otherwise socket can stall.
    1203                 :            :  */
    1204                 :          1 : static void tcp_queue_skb(struct sock *sk, struct sk_buff *skb)
    1205                 :            : {
    1206                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1207                 :            : 
    1208                 :            :         /* Advance write_seq and place onto the write_queue. */
    1209                 :          1 :         WRITE_ONCE(tp->write_seq, TCP_SKB_CB(skb)->end_seq);
    1210                 :            :         __skb_header_release(skb);
    1211                 :          1 :         tcp_add_write_queue_tail(sk, skb);
    1212                 :          1 :         sk_wmem_queued_add(sk, skb->truesize);
    1213                 :          1 :         sk_mem_charge(sk, skb->truesize);
    1214                 :          1 : }
    1215                 :            : 
    1216                 :            : /* Initialize TSO segments for a packet. */
    1217                 :            : static void tcp_set_skb_tso_segs(struct sk_buff *skb, unsigned int mss_now)
    1218                 :            : {
    1219                 :          1 :         if (skb->len <= mss_now) {
    1220                 :            :                 /* Avoid the costly divide in the normal
    1221                 :            :                  * non-TSO case.
    1222                 :            :                  */
    1223                 :            :                 tcp_skb_pcount_set(skb, 1);
    1224                 :          1 :                 TCP_SKB_CB(skb)->tcp_gso_size = 0;
    1225                 :            :         } else {
    1226                 :          0 :                 tcp_skb_pcount_set(skb, DIV_ROUND_UP(skb->len, mss_now));
    1227                 :          0 :                 TCP_SKB_CB(skb)->tcp_gso_size = mss_now;
    1228                 :            :         }
    1229                 :            : }
    1230                 :            : 
    1231                 :            : /* Pcount in the middle of the write queue got changed, we need to do various
    1232                 :            :  * tweaks to fix counters
    1233                 :            :  */
    1234                 :          1 : static void tcp_adjust_pcount(struct sock *sk, const struct sk_buff *skb, int decr)
    1235                 :            : {
    1236                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1237                 :            : 
    1238                 :          1 :         tp->packets_out -= decr;
    1239                 :            : 
    1240                 :          1 :         if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
    1241                 :          0 :                 tp->sacked_out -= decr;
    1242                 :          1 :         if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS)
    1243                 :          0 :                 tp->retrans_out -= decr;
    1244                 :          1 :         if (TCP_SKB_CB(skb)->sacked & TCPCB_LOST)
    1245                 :          1 :                 tp->lost_out -= decr;
    1246                 :            : 
    1247                 :            :         /* Reno case is special. Sigh... */
    1248                 :          1 :         if (tcp_is_reno(tp) && decr > 0)
    1249                 :          1 :                 tp->sacked_out -= min_t(u32, tp->sacked_out, decr);
    1250                 :            : 
    1251                 :          1 :         if (tp->lost_skb_hint &&
    1252                 :          0 :             before(TCP_SKB_CB(skb)->seq, TCP_SKB_CB(tp->lost_skb_hint)->seq) &&
    1253                 :          0 :             (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED))
    1254                 :          0 :                 tp->lost_cnt_hint -= decr;
    1255                 :            : 
    1256                 :          1 :         tcp_verify_left_out(tp);
    1257                 :          1 : }
    1258                 :            : 
    1259                 :            : static bool tcp_has_tx_tstamp(const struct sk_buff *skb)
    1260                 :            : {
    1261                 :          1 :         return TCP_SKB_CB(skb)->txstamp_ack ||
    1262                 :          1 :                 (skb_shinfo(skb)->tx_flags & SKBTX_ANY_TSTAMP);
    1263                 :            : }
    1264                 :            : 
    1265                 :          0 : static void tcp_fragment_tstamp(struct sk_buff *skb, struct sk_buff *skb2)
    1266                 :            : {
    1267                 :            :         struct skb_shared_info *shinfo = skb_shinfo(skb);
    1268                 :            : 
    1269                 :          0 :         if (unlikely(tcp_has_tx_tstamp(skb)) &&
    1270                 :          0 :             !before(shinfo->tskey, TCP_SKB_CB(skb2)->seq)) {
    1271                 :            :                 struct skb_shared_info *shinfo2 = skb_shinfo(skb2);
    1272                 :          0 :                 u8 tsflags = shinfo->tx_flags & SKBTX_ANY_TSTAMP;
    1273                 :            : 
    1274                 :          0 :                 shinfo->tx_flags &= ~tsflags;
    1275                 :          0 :                 shinfo2->tx_flags |= tsflags;
    1276                 :          0 :                 swap(shinfo->tskey, shinfo2->tskey);
    1277                 :          0 :                 TCP_SKB_CB(skb2)->txstamp_ack = TCP_SKB_CB(skb)->txstamp_ack;
    1278                 :          0 :                 TCP_SKB_CB(skb)->txstamp_ack = 0;
    1279                 :            :         }
    1280                 :          0 : }
    1281                 :            : 
    1282                 :            : static void tcp_skb_fragment_eor(struct sk_buff *skb, struct sk_buff *skb2)
    1283                 :            : {
    1284                 :          0 :         TCP_SKB_CB(skb2)->eor = TCP_SKB_CB(skb)->eor;
    1285                 :          0 :         TCP_SKB_CB(skb)->eor = 0;
    1286                 :            : }
    1287                 :            : 
    1288                 :            : /* Insert buff after skb on the write or rtx queue of sk.  */
    1289                 :            : static void tcp_insert_write_queue_after(struct sk_buff *skb,
    1290                 :            :                                          struct sk_buff *buff,
    1291                 :            :                                          struct sock *sk,
    1292                 :            :                                          enum tcp_queue tcp_queue)
    1293                 :            : {
    1294                 :          0 :         if (tcp_queue == TCP_FRAG_IN_WRITE_QUEUE)
    1295                 :            :                 __skb_queue_after(&sk->sk_write_queue, skb, buff);
    1296                 :            :         else
    1297                 :          0 :                 tcp_rbtree_insert(&sk->tcp_rtx_queue, buff);
    1298                 :            : }
    1299                 :            : 
    1300                 :            : /* Function to create two new TCP segments.  Shrinks the given segment
    1301                 :            :  * to the specified size and appends a new segment with the rest of the
    1302                 :            :  * packet to the list.  This won't be called frequently, I hope.
    1303                 :            :  * Remember, these are still headerless SKBs at this point.
    1304                 :            :  */
    1305                 :          0 : int tcp_fragment(struct sock *sk, enum tcp_queue tcp_queue,
    1306                 :            :                  struct sk_buff *skb, u32 len,
    1307                 :            :                  unsigned int mss_now, gfp_t gfp)
    1308                 :            : {
    1309                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1310                 :            :         struct sk_buff *buff;
    1311                 :            :         int nsize, old_factor;
    1312                 :            :         long limit;
    1313                 :            :         int nlen;
    1314                 :            :         u8 flags;
    1315                 :            : 
    1316                 :          0 :         if (WARN_ON(len > skb->len))
    1317                 :            :                 return -EINVAL;
    1318                 :            : 
    1319                 :          0 :         nsize = skb_headlen(skb) - len;
    1320                 :          0 :         if (nsize < 0)
    1321                 :            :                 nsize = 0;
    1322                 :            : 
    1323                 :            :         /* tcp_sendmsg() can overshoot sk_wmem_queued by one full size skb.
    1324                 :            :          * We need some allowance to not penalize applications setting small
    1325                 :            :          * SO_SNDBUF values.
    1326                 :            :          * Also allow first and last skb in retransmit queue to be split.
    1327                 :            :          */
    1328                 :          0 :         limit = sk->sk_sndbuf + 2 * SKB_TRUESIZE(GSO_MAX_SIZE);
    1329                 :          0 :         if (unlikely((sk->sk_wmem_queued >> 1) > limit &&
    1330                 :            :                      tcp_queue != TCP_FRAG_IN_WRITE_QUEUE &&
    1331                 :            :                      skb != tcp_rtx_queue_head(sk) &&
    1332                 :            :                      skb != tcp_rtx_queue_tail(sk))) {
    1333                 :          0 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPWQUEUETOOBIG);
    1334                 :          0 :                 return -ENOMEM;
    1335                 :            :         }
    1336                 :            : 
    1337                 :          0 :         if (skb_unclone(skb, gfp))
    1338                 :            :                 return -ENOMEM;
    1339                 :            : 
    1340                 :            :         /* Get a new skb... force flag on. */
    1341                 :          0 :         buff = sk_stream_alloc_skb(sk, nsize, gfp, true);
    1342                 :          0 :         if (!buff)
    1343                 :            :                 return -ENOMEM; /* We'll just try again later. */
    1344                 :            :         skb_copy_decrypted(buff, skb);
    1345                 :            : 
    1346                 :          0 :         sk_wmem_queued_add(sk, buff->truesize);
    1347                 :          0 :         sk_mem_charge(sk, buff->truesize);
    1348                 :          0 :         nlen = skb->len - len - nsize;
    1349                 :          0 :         buff->truesize += nlen;
    1350                 :          0 :         skb->truesize -= nlen;
    1351                 :            : 
    1352                 :            :         /* Correct the sequence numbers. */
    1353                 :          0 :         TCP_SKB_CB(buff)->seq = TCP_SKB_CB(skb)->seq + len;
    1354                 :          0 :         TCP_SKB_CB(buff)->end_seq = TCP_SKB_CB(skb)->end_seq;
    1355                 :          0 :         TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(buff)->seq;
    1356                 :            : 
    1357                 :            :         /* PSH and FIN should only be set in the second packet. */
    1358                 :          0 :         flags = TCP_SKB_CB(skb)->tcp_flags;
    1359                 :          0 :         TCP_SKB_CB(skb)->tcp_flags = flags & ~(TCPHDR_FIN | TCPHDR_PSH);
    1360                 :          0 :         TCP_SKB_CB(buff)->tcp_flags = flags;
    1361                 :          0 :         TCP_SKB_CB(buff)->sacked = TCP_SKB_CB(skb)->sacked;
    1362                 :            :         tcp_skb_fragment_eor(skb, buff);
    1363                 :            : 
    1364                 :          0 :         skb_split(skb, buff, len);
    1365                 :            : 
    1366                 :          0 :         buff->ip_summed = CHECKSUM_PARTIAL;
    1367                 :            : 
    1368                 :          0 :         buff->tstamp = skb->tstamp;
    1369                 :          0 :         tcp_fragment_tstamp(skb, buff);
    1370                 :            : 
    1371                 :            :         old_factor = tcp_skb_pcount(skb);
    1372                 :            : 
    1373                 :            :         /* Fix up tso_factor for both original and new SKB.  */
    1374                 :            :         tcp_set_skb_tso_segs(skb, mss_now);
    1375                 :            :         tcp_set_skb_tso_segs(buff, mss_now);
    1376                 :            : 
    1377                 :            :         /* Update delivered info for the new segment */
    1378                 :          0 :         TCP_SKB_CB(buff)->tx = TCP_SKB_CB(skb)->tx;
    1379                 :            : 
    1380                 :            :         /* If this packet has been sent out already, we must
    1381                 :            :          * adjust the various packet counters.
    1382                 :            :          */
    1383                 :          0 :         if (!before(tp->snd_nxt, TCP_SKB_CB(buff)->end_seq)) {
    1384                 :          0 :                 int diff = old_factor - tcp_skb_pcount(skb) -
    1385                 :            :                         tcp_skb_pcount(buff);
    1386                 :            : 
    1387                 :          0 :                 if (diff)
    1388                 :          0 :                         tcp_adjust_pcount(sk, skb, diff);
    1389                 :            :         }
    1390                 :            : 
    1391                 :            :         /* Link BUFF into the send queue. */
    1392                 :            :         __skb_header_release(buff);
    1393                 :            :         tcp_insert_write_queue_after(skb, buff, sk, tcp_queue);
    1394                 :          0 :         if (tcp_queue == TCP_FRAG_IN_RTX_QUEUE)
    1395                 :          0 :                 list_add(&buff->tcp_tsorted_anchor, &skb->tcp_tsorted_anchor);
    1396                 :            : 
    1397                 :            :         return 0;
    1398                 :            : }
    1399                 :            : 
    1400                 :            : /* This is similar to __pskb_pull_tail(). The difference is that pulled
    1401                 :            :  * data is not copied, but immediately discarded.
    1402                 :            :  */
    1403                 :          0 : static int __pskb_trim_head(struct sk_buff *skb, int len)
    1404                 :            : {
    1405                 :            :         struct skb_shared_info *shinfo;
    1406                 :            :         int i, k, eat;
    1407                 :            : 
    1408                 :          0 :         eat = min_t(int, len, skb_headlen(skb));
    1409                 :          0 :         if (eat) {
    1410                 :          0 :                 __skb_pull(skb, eat);
    1411                 :          0 :                 len -= eat;
    1412                 :          0 :                 if (!len)
    1413                 :            :                         return 0;
    1414                 :            :         }
    1415                 :            :         eat = len;
    1416                 :            :         k = 0;
    1417                 :            :         shinfo = skb_shinfo(skb);
    1418                 :          0 :         for (i = 0; i < shinfo->nr_frags; i++) {
    1419                 :          0 :                 int size = skb_frag_size(&shinfo->frags[i]);
    1420                 :            : 
    1421                 :          0 :                 if (size <= eat) {
    1422                 :            :                         skb_frag_unref(skb, i);
    1423                 :          0 :                         eat -= size;
    1424                 :            :                 } else {
    1425                 :          0 :                         shinfo->frags[k] = shinfo->frags[i];
    1426                 :          0 :                         if (eat) {
    1427                 :            :                                 skb_frag_off_add(&shinfo->frags[k], eat);
    1428                 :            :                                 skb_frag_size_sub(&shinfo->frags[k], eat);
    1429                 :            :                                 eat = 0;
    1430                 :            :                         }
    1431                 :          0 :                         k++;
    1432                 :            :                 }
    1433                 :            :         }
    1434                 :          0 :         shinfo->nr_frags = k;
    1435                 :            : 
    1436                 :          0 :         skb->data_len -= len;
    1437                 :          0 :         skb->len = skb->data_len;
    1438                 :          0 :         return len;
    1439                 :            : }
    1440                 :            : 
    1441                 :            : /* Remove acked data from a packet in the transmit queue. */
    1442                 :          0 : int tcp_trim_head(struct sock *sk, struct sk_buff *skb, u32 len)
    1443                 :            : {
    1444                 :            :         u32 delta_truesize;
    1445                 :            : 
    1446                 :          0 :         if (skb_unclone(skb, GFP_ATOMIC))
    1447                 :            :                 return -ENOMEM;
    1448                 :            : 
    1449                 :          0 :         delta_truesize = __pskb_trim_head(skb, len);
    1450                 :            : 
    1451                 :          0 :         TCP_SKB_CB(skb)->seq += len;
    1452                 :          0 :         skb->ip_summed = CHECKSUM_PARTIAL;
    1453                 :            : 
    1454                 :          0 :         if (delta_truesize) {
    1455                 :          0 :                 skb->truesize           -= delta_truesize;
    1456                 :          0 :                 sk_wmem_queued_add(sk, -delta_truesize);
    1457                 :          0 :                 sk_mem_uncharge(sk, delta_truesize);
    1458                 :            :                 sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
    1459                 :            :         }
    1460                 :            : 
    1461                 :            :         /* Any change of skb->len requires recalculation of tso factor. */
    1462                 :          0 :         if (tcp_skb_pcount(skb) > 1)
    1463                 :          0 :                 tcp_set_skb_tso_segs(skb, tcp_skb_mss(skb));
    1464                 :            : 
    1465                 :            :         return 0;
    1466                 :            : }
    1467                 :            : 
    1468                 :            : /* Calculate MSS not accounting any TCP options.  */
    1469                 :          1 : static inline int __tcp_mtu_to_mss(struct sock *sk, int pmtu)
    1470                 :            : {
    1471                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
    1472                 :            :         const struct inet_connection_sock *icsk = inet_csk(sk);
    1473                 :            :         int mss_now;
    1474                 :            : 
    1475                 :            :         /* Calculate base mss without TCP options:
    1476                 :            :            It is MMS_S - sizeof(tcphdr) of rfc1122
    1477                 :            :          */
    1478                 :          1 :         mss_now = pmtu - icsk->icsk_af_ops->net_header_len - sizeof(struct tcphdr);
    1479                 :            : 
    1480                 :            :         /* IPv6 adds a frag_hdr in case RTAX_FEATURE_ALLFRAG is set */
    1481                 :          1 :         if (icsk->icsk_af_ops->net_frag_header_len) {
    1482                 :            :                 const struct dst_entry *dst = __sk_dst_get(sk);
    1483                 :            : 
    1484                 :          0 :                 if (dst && dst_allfrag(dst))
    1485                 :          0 :                         mss_now -= icsk->icsk_af_ops->net_frag_header_len;
    1486                 :            :         }
    1487                 :            : 
    1488                 :            :         /* Clamp it (mss_clamp does not include tcp options) */
    1489                 :          1 :         if (mss_now > tp->rx_opt.mss_clamp)
    1490                 :            :                 mss_now = tp->rx_opt.mss_clamp;
    1491                 :            : 
    1492                 :            :         /* Now subtract optional transport overhead */
    1493                 :          1 :         mss_now -= icsk->icsk_ext_hdr_len;
    1494                 :            : 
    1495                 :            :         /* Then reserve room for full set of TCP options and 8 bytes of data */
    1496                 :          1 :         mss_now = max(mss_now, sock_net(sk)->ipv4.sysctl_tcp_min_snd_mss);
    1497                 :          1 :         return mss_now;
    1498                 :            : }
    1499                 :            : 
    1500                 :            : /* Calculate MSS. Not accounting for SACKs here.  */
    1501                 :          0 : int tcp_mtu_to_mss(struct sock *sk, int pmtu)
    1502                 :            : {
    1503                 :            :         /* Subtract TCP options size, not including SACKs */
    1504                 :          1 :         return __tcp_mtu_to_mss(sk, pmtu) -
    1505                 :          1 :                (tcp_sk(sk)->tcp_header_len - sizeof(struct tcphdr));
    1506                 :            : }
    1507                 :            : 
    1508                 :            : /* Inverse of above */
    1509                 :          1 : int tcp_mss_to_mtu(struct sock *sk, int mss)
    1510                 :            : {
    1511                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
    1512                 :            :         const struct inet_connection_sock *icsk = inet_csk(sk);
    1513                 :            :         int mtu;
    1514                 :            : 
    1515                 :          1 :         mtu = mss +
    1516                 :          1 :               tp->tcp_header_len +
    1517                 :          1 :               icsk->icsk_ext_hdr_len +
    1518                 :          1 :               icsk->icsk_af_ops->net_header_len;
    1519                 :            : 
    1520                 :            :         /* IPv6 adds a frag_hdr in case RTAX_FEATURE_ALLFRAG is set */
    1521                 :          1 :         if (icsk->icsk_af_ops->net_frag_header_len) {
    1522                 :            :                 const struct dst_entry *dst = __sk_dst_get(sk);
    1523                 :            : 
    1524                 :          0 :                 if (dst && dst_allfrag(dst))
    1525                 :          0 :                         mtu += icsk->icsk_af_ops->net_frag_header_len;
    1526                 :            :         }
    1527                 :          1 :         return mtu;
    1528                 :            : }
    1529                 :            : EXPORT_SYMBOL(tcp_mss_to_mtu);
    1530                 :            : 
    1531                 :            : /* MTU probing init per socket */
    1532                 :          1 : void tcp_mtup_init(struct sock *sk)
    1533                 :            : {
    1534                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1535                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    1536                 :            :         struct net *net = sock_net(sk);
    1537                 :            : 
    1538                 :          1 :         icsk->icsk_mtup.enabled = net->ipv4.sysctl_tcp_mtu_probing > 1;
    1539                 :          1 :         icsk->icsk_mtup.search_high = tp->rx_opt.mss_clamp + sizeof(struct tcphdr) +
    1540                 :          1 :                                icsk->icsk_af_ops->net_header_len;
    1541                 :          1 :         icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, net->ipv4.sysctl_tcp_base_mss);
    1542                 :          1 :         icsk->icsk_mtup.probe_size = 0;
    1543                 :          1 :         if (icsk->icsk_mtup.enabled)
    1544                 :          0 :                 icsk->icsk_mtup.probe_timestamp = tcp_jiffies32;
    1545                 :          1 : }
    1546                 :            : EXPORT_SYMBOL(tcp_mtup_init);
    1547                 :            : 
    1548                 :            : /* This function synchronize snd mss to current pmtu/exthdr set.
    1549                 :            : 
    1550                 :            :    tp->rx_opt.user_mss is mss set by user by TCP_MAXSEG. It does NOT counts
    1551                 :            :    for TCP options, but includes only bare TCP header.
    1552                 :            : 
    1553                 :            :    tp->rx_opt.mss_clamp is mss negotiated at connection setup.
    1554                 :            :    It is minimum of user_mss and mss received with SYN.
    1555                 :            :    It also does not include TCP options.
    1556                 :            : 
    1557                 :            :    inet_csk(sk)->icsk_pmtu_cookie is last pmtu, seen by this function.
    1558                 :            : 
    1559                 :            :    tp->mss_cache is current effective sending mss, including
    1560                 :            :    all tcp options except for SACKs. It is evaluated,
    1561                 :            :    taking into account current pmtu, but never exceeds
    1562                 :            :    tp->rx_opt.mss_clamp.
    1563                 :            : 
    1564                 :            :    NOTE1. rfc1122 clearly states that advertised MSS
    1565                 :            :    DOES NOT include either tcp or ip options.
    1566                 :            : 
    1567                 :            :    NOTE2. inet_csk(sk)->icsk_pmtu_cookie and tp->mss_cache
    1568                 :            :    are READ ONLY outside this function.         --ANK (980731)
    1569                 :            :  */
    1570                 :          1 : unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu)
    1571                 :            : {
    1572                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1573                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    1574                 :            :         int mss_now;
    1575                 :            : 
    1576                 :          1 :         if (icsk->icsk_mtup.search_high > pmtu)
    1577                 :          0 :                 icsk->icsk_mtup.search_high = pmtu;
    1578                 :            : 
    1579                 :          1 :         mss_now = tcp_mtu_to_mss(sk, pmtu);
    1580                 :            :         mss_now = tcp_bound_to_half_wnd(tp, mss_now);
    1581                 :            : 
    1582                 :            :         /* And store cached results */
    1583                 :          1 :         icsk->icsk_pmtu_cookie = pmtu;
    1584                 :          1 :         if (icsk->icsk_mtup.enabled)
    1585                 :          0 :                 mss_now = min(mss_now, tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_low));
    1586                 :          1 :         tp->mss_cache = mss_now;
    1587                 :            : 
    1588                 :          1 :         return mss_now;
    1589                 :            : }
    1590                 :            : EXPORT_SYMBOL(tcp_sync_mss);
    1591                 :            : 
    1592                 :            : /* Compute the current effective MSS, taking SACKs and IP options,
    1593                 :            :  * and even PMTU discovery events into account.
    1594                 :            :  */
    1595                 :          1 : unsigned int tcp_current_mss(struct sock *sk)
    1596                 :            : {
    1597                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
    1598                 :            :         const struct dst_entry *dst = __sk_dst_get(sk);
    1599                 :            :         u32 mss_now;
    1600                 :            :         unsigned int header_len;
    1601                 :            :         struct tcp_out_options opts;
    1602                 :            :         struct tcp_md5sig_key *md5;
    1603                 :            : 
    1604                 :          1 :         mss_now = tp->mss_cache;
    1605                 :            : 
    1606                 :          1 :         if (dst) {
    1607                 :            :                 u32 mtu = dst_mtu(dst);
    1608                 :          1 :                 if (mtu != inet_csk(sk)->icsk_pmtu_cookie)
    1609                 :          0 :                         mss_now = tcp_sync_mss(sk, mtu);
    1610                 :            :         }
    1611                 :            : 
    1612                 :          1 :         header_len = tcp_established_options(sk, NULL, &opts, &md5) +
    1613                 :            :                      sizeof(struct tcphdr);
    1614                 :            :         /* The mss_cache is sized based on tp->tcp_header_len, which assumes
    1615                 :            :          * some common options. If this is an odd packet (because we have SACK
    1616                 :            :          * blocks etc) then our calculated header_len will be different, and
    1617                 :            :          * we have to adjust mss_now correspondingly */
    1618                 :          1 :         if (header_len != tp->tcp_header_len) {
    1619                 :          0 :                 int delta = (int) header_len - tp->tcp_header_len;
    1620                 :          0 :                 mss_now -= delta;
    1621                 :            :         }
    1622                 :            : 
    1623                 :          1 :         return mss_now;
    1624                 :            : }
    1625                 :            : 
    1626                 :            : /* RFC2861, slow part. Adjust cwnd, after it was not full during one rto.
    1627                 :            :  * As additional protections, we do not touch cwnd in retransmission phases,
    1628                 :            :  * and if application hit its sndbuf limit recently.
    1629                 :            :  */
    1630                 :          1 : static void tcp_cwnd_application_limited(struct sock *sk)
    1631                 :            : {
    1632                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1633                 :            : 
    1634                 :          1 :         if (inet_csk(sk)->icsk_ca_state == TCP_CA_Open &&
    1635                 :          1 :             sk->sk_socket && !test_bit(SOCK_NOSPACE, &sk->sk_socket->flags)) {
    1636                 :            :                 /* Limited by application or receiver window. */
    1637                 :          1 :                 u32 init_win = tcp_init_cwnd(tp, __sk_dst_get(sk));
    1638                 :          1 :                 u32 win_used = max(tp->snd_cwnd_used, init_win);
    1639                 :          1 :                 if (win_used < tp->snd_cwnd) {
    1640                 :          0 :                         tp->snd_ssthresh = tcp_current_ssthresh(sk);
    1641                 :          0 :                         tp->snd_cwnd = (tp->snd_cwnd + win_used) >> 1;
    1642                 :            :                 }
    1643                 :          1 :                 tp->snd_cwnd_used = 0;
    1644                 :            :         }
    1645                 :          1 :         tp->snd_cwnd_stamp = tcp_jiffies32;
    1646                 :          1 : }
    1647                 :            : 
    1648                 :          1 : static void tcp_cwnd_validate(struct sock *sk, bool is_cwnd_limited)
    1649                 :            : {
    1650                 :          1 :         const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
    1651                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1652                 :            : 
    1653                 :            :         /* Track the maximum number of outstanding packets in each
    1654                 :            :          * window, and remember whether we were cwnd-limited then.
    1655                 :            :          */
    1656                 :          1 :         if (!before(tp->snd_una, tp->max_packets_seq) ||
    1657                 :          1 :             tp->packets_out > tp->max_packets_out) {
    1658                 :          1 :                 tp->max_packets_out = tp->packets_out;
    1659                 :          1 :                 tp->max_packets_seq = tp->snd_nxt;
    1660                 :          1 :                 tp->is_cwnd_limited = is_cwnd_limited;
    1661                 :            :         }
    1662                 :            : 
    1663                 :          1 :         if (tcp_is_cwnd_limited(sk)) {
    1664                 :            :                 /* Network is feed fully. */
    1665                 :          1 :                 tp->snd_cwnd_used = 0;
    1666                 :          1 :                 tp->snd_cwnd_stamp = tcp_jiffies32;
    1667                 :            :         } else {
    1668                 :            :                 /* Network starves. */
    1669                 :          1 :                 if (tp->packets_out > tp->snd_cwnd_used)
    1670                 :          1 :                         tp->snd_cwnd_used = tp->packets_out;
    1671                 :            : 
    1672                 :          1 :                 if (sock_net(sk)->ipv4.sysctl_tcp_slow_start_after_idle &&
    1673                 :          1 :                     (s32)(tcp_jiffies32 - tp->snd_cwnd_stamp) >= inet_csk(sk)->icsk_rto &&
    1674                 :          1 :                     !ca_ops->cong_control)
    1675                 :          1 :                         tcp_cwnd_application_limited(sk);
    1676                 :            : 
    1677                 :            :                 /* The following conditions together indicate the starvation
    1678                 :            :                  * is caused by insufficient sender buffer:
    1679                 :            :                  * 1) just sent some data (see tcp_write_xmit)
    1680                 :            :                  * 2) not cwnd limited (this else condition)
    1681                 :            :                  * 3) no more data to send (tcp_write_queue_empty())
    1682                 :            :                  * 4) application is hitting buffer limit (SOCK_NOSPACE)
    1683                 :            :                  */
    1684                 :          1 :                 if (tcp_write_queue_empty(sk) && sk->sk_socket &&
    1685                 :          0 :                     test_bit(SOCK_NOSPACE, &sk->sk_socket->flags) &&
    1686                 :          0 :                     (1 << sk->sk_state) & (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT))
    1687                 :            :                         tcp_chrono_start(sk, TCP_CHRONO_SNDBUF_LIMITED);
    1688                 :            :         }
    1689                 :          1 : }
    1690                 :            : 
    1691                 :            : /* Minshall's variant of the Nagle send check. */
    1692                 :            : static bool tcp_minshall_check(const struct tcp_sock *tp)
    1693                 :            : {
    1694                 :          0 :         return after(tp->snd_sml, tp->snd_una) &&
    1695                 :          0 :                 !after(tp->snd_sml, tp->snd_nxt);
    1696                 :            : }
    1697                 :            : 
    1698                 :            : /* Update snd_sml if this skb is under mss
    1699                 :            :  * Note that a TSO packet might end with a sub-mss segment
    1700                 :            :  * The test is really :
    1701                 :            :  * if ((skb->len % mss) != 0)
    1702                 :            :  *        tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
    1703                 :            :  * But we can avoid doing the divide again given we already have
    1704                 :            :  *  skb_pcount = skb->len / mss_now
    1705                 :            :  */
    1706                 :            : static void tcp_minshall_update(struct tcp_sock *tp, unsigned int mss_now,
    1707                 :            :                                 const struct sk_buff *skb)
    1708                 :            : {
    1709                 :          1 :         if (skb->len < tcp_skb_pcount(skb) * mss_now)
    1710                 :          1 :                 tp->snd_sml = TCP_SKB_CB(skb)->end_seq;
    1711                 :            : }
    1712                 :            : 
    1713                 :            : /* Return false, if packet can be sent now without violation Nagle's rules:
    1714                 :            :  * 1. It is full sized. (provided by caller in %partial bool)
    1715                 :            :  * 2. Or it contains FIN. (already checked by caller)
    1716                 :            :  * 3. Or TCP_CORK is not set, and TCP_NODELAY is set.
    1717                 :            :  * 4. Or TCP_CORK is not set, and all sent packets are ACKed.
    1718                 :            :  *    With Minshall's modification: all sent small packets are ACKed.
    1719                 :            :  */
    1720                 :          1 : static bool tcp_nagle_check(bool partial, const struct tcp_sock *tp,
    1721                 :            :                             int nonagle)
    1722                 :            : {
    1723                 :          1 :         return partial &&
    1724                 :          1 :                 ((nonagle & TCP_NAGLE_CORK) ||
    1725                 :          0 :                  (!nonagle && tp->packets_out && tcp_minshall_check(tp)));
    1726                 :            : }
    1727                 :            : 
    1728                 :            : /* Return how many segs we'd like on a TSO packet,
    1729                 :            :  * to send one TSO packet per ms
    1730                 :            :  */
    1731                 :            : static u32 tcp_tso_autosize(const struct sock *sk, unsigned int mss_now,
    1732                 :            :                             int min_tso_segs)
    1733                 :            : {
    1734                 :            :         u32 bytes, segs;
    1735                 :            : 
    1736                 :          1 :         bytes = min_t(unsigned long,
    1737                 :            :                       sk->sk_pacing_rate >> READ_ONCE(sk->sk_pacing_shift),
    1738                 :            :                       sk->sk_gso_max_size - 1 - MAX_TCP_HEADER);
    1739                 :            : 
    1740                 :            :         /* Goal is to send at least one packet per ms,
    1741                 :            :          * not one big TSO packet every 100 ms.
    1742                 :            :          * This preserves ACK clocking and is consistent
    1743                 :            :          * with tcp_tso_should_defer() heuristic.
    1744                 :            :          */
    1745                 :          1 :         segs = max_t(u32, bytes / mss_now, min_tso_segs);
    1746                 :            : 
    1747                 :            :         return segs;
    1748                 :            : }
    1749                 :            : 
    1750                 :            : /* Return the number of segments we want in the skb we are transmitting.
    1751                 :            :  * See if congestion control module wants to decide; otherwise, autosize.
    1752                 :            :  */
    1753                 :          1 : static u32 tcp_tso_segs(struct sock *sk, unsigned int mss_now)
    1754                 :            : {
    1755                 :          1 :         const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
    1756                 :            :         u32 min_tso, tso_segs;
    1757                 :            : 
    1758                 :          1 :         min_tso = ca_ops->min_tso_segs ?
    1759                 :          1 :                         ca_ops->min_tso_segs(sk) :
    1760                 :          1 :                         sock_net(sk)->ipv4.sysctl_tcp_min_tso_segs;
    1761                 :            : 
    1762                 :            :         tso_segs = tcp_tso_autosize(sk, mss_now, min_tso);
    1763                 :          1 :         return min_t(u32, tso_segs, sk->sk_gso_max_segs);
    1764                 :            : }
    1765                 :            : 
    1766                 :            : /* Returns the portion of skb which can be sent right away */
    1767                 :          0 : static unsigned int tcp_mss_split_point(const struct sock *sk,
    1768                 :            :                                         const struct sk_buff *skb,
    1769                 :            :                                         unsigned int mss_now,
    1770                 :            :                                         unsigned int max_segs,
    1771                 :            :                                         int nonagle)
    1772                 :            : {
    1773                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
    1774                 :            :         u32 partial, needed, window, max_len;
    1775                 :            : 
    1776                 :          0 :         window = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
    1777                 :          0 :         max_len = mss_now * max_segs;
    1778                 :            : 
    1779                 :          0 :         if (likely(max_len <= window && skb != tcp_write_queue_tail(sk)))
    1780                 :            :                 return max_len;
    1781                 :            : 
    1782                 :          0 :         needed = min(skb->len, window);
    1783                 :            : 
    1784                 :          0 :         if (max_len <= needed)
    1785                 :            :                 return max_len;
    1786                 :            : 
    1787                 :          0 :         partial = needed % mss_now;
    1788                 :            :         /* If last segment is not a full MSS, check if Nagle rules allow us
    1789                 :            :          * to include this last segment in this skb.
    1790                 :            :          * Otherwise, we'll split the skb at last MSS boundary
    1791                 :            :          */
    1792                 :          0 :         if (tcp_nagle_check(partial != 0, tp, nonagle))
    1793                 :          0 :                 return needed - partial;
    1794                 :            : 
    1795                 :            :         return needed;
    1796                 :            : }
    1797                 :            : 
    1798                 :            : /* Can at least one segment of SKB be sent right now, according to the
    1799                 :            :  * congestion window rules?  If so, return how many segments are allowed.
    1800                 :            :  */
    1801                 :          1 : static inline unsigned int tcp_cwnd_test(const struct tcp_sock *tp,
    1802                 :            :                                          const struct sk_buff *skb)
    1803                 :            : {
    1804                 :            :         u32 in_flight, cwnd, halfcwnd;
    1805                 :            : 
    1806                 :            :         /* Don't be strict about the congestion window for the final FIN.  */
    1807                 :          1 :         if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) &&
    1808                 :            :             tcp_skb_pcount(skb) == 1)
    1809                 :            :                 return 1;
    1810                 :            : 
    1811                 :            :         in_flight = tcp_packets_in_flight(tp);
    1812                 :          1 :         cwnd = tp->snd_cwnd;
    1813                 :          1 :         if (in_flight >= cwnd)
    1814                 :            :                 return 0;
    1815                 :            : 
    1816                 :            :         /* For better scheduling, ensure we have at least
    1817                 :            :          * 2 GSO packets in flight.
    1818                 :            :          */
    1819                 :          1 :         halfcwnd = max(cwnd >> 1, 1U);
    1820                 :          1 :         return min(halfcwnd, cwnd - in_flight);
    1821                 :            : }
    1822                 :            : 
    1823                 :            : /* Initialize TSO state of a skb.
    1824                 :            :  * This must be invoked the first time we consider transmitting
    1825                 :            :  * SKB onto the wire.
    1826                 :            :  */
    1827                 :          0 : static int tcp_init_tso_segs(struct sk_buff *skb, unsigned int mss_now)
    1828                 :            : {
    1829                 :            :         int tso_segs = tcp_skb_pcount(skb);
    1830                 :            : 
    1831                 :          1 :         if (!tso_segs || (tso_segs > 1 && tcp_skb_mss(skb) != mss_now)) {
    1832                 :            :                 tcp_set_skb_tso_segs(skb, mss_now);
    1833                 :            :                 tso_segs = tcp_skb_pcount(skb);
    1834                 :            :         }
    1835                 :          0 :         return tso_segs;
    1836                 :            : }
    1837                 :            : 
    1838                 :            : 
    1839                 :            : /* Return true if the Nagle test allows this packet to be
    1840                 :            :  * sent now.
    1841                 :            :  */
    1842                 :          1 : static inline bool tcp_nagle_test(const struct tcp_sock *tp, const struct sk_buff *skb,
    1843                 :            :                                   unsigned int cur_mss, int nonagle)
    1844                 :            : {
    1845                 :            :         /* Nagle rule does not apply to frames, which sit in the middle of the
    1846                 :            :          * write_queue (they have no chances to get new data).
    1847                 :            :          *
    1848                 :            :          * This is implemented in the callers, where they modify the 'nonagle'
    1849                 :            :          * argument based upon the location of SKB in the send queue.
    1850                 :            :          */
    1851                 :          1 :         if (nonagle & TCP_NAGLE_PUSH)
    1852                 :            :                 return true;
    1853                 :            : 
    1854                 :            :         /* Don't use the nagle rule for urgent data (or for the final FIN). */
    1855                 :          1 :         if (tcp_urg_mode(tp) || (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN))
    1856                 :            :                 return true;
    1857                 :            : 
    1858                 :          1 :         if (!tcp_nagle_check(skb->len < cur_mss, tp, nonagle))
    1859                 :            :                 return true;
    1860                 :            : 
    1861                 :          0 :         return false;
    1862                 :            : }
    1863                 :            : 
    1864                 :            : /* Does at least the first segment of SKB fit into the send window? */
    1865                 :            : static bool tcp_snd_wnd_test(const struct tcp_sock *tp,
    1866                 :            :                              const struct sk_buff *skb,
    1867                 :            :                              unsigned int cur_mss)
    1868                 :            : {
    1869                 :          1 :         u32 end_seq = TCP_SKB_CB(skb)->end_seq;
    1870                 :            : 
    1871                 :          1 :         if (skb->len > cur_mss)
    1872                 :          0 :                 end_seq = TCP_SKB_CB(skb)->seq + cur_mss;
    1873                 :            : 
    1874                 :            :         return !after(end_seq, tcp_wnd_end(tp));
    1875                 :            : }
    1876                 :            : 
    1877                 :            : /* Trim TSO SKB to LEN bytes, put the remaining data into a new packet
    1878                 :            :  * which is put after SKB on the list.  It is very much like
    1879                 :            :  * tcp_fragment() except that it may make several kinds of assumptions
    1880                 :            :  * in order to speed up the splitting operation.  In particular, we
    1881                 :            :  * know that all the data is in scatter-gather pages, and that the
    1882                 :            :  * packet has never been sent out before (and thus is not cloned).
    1883                 :            :  */
    1884                 :          0 : static int tso_fragment(struct sock *sk, struct sk_buff *skb, unsigned int len,
    1885                 :            :                         unsigned int mss_now, gfp_t gfp)
    1886                 :            : {
    1887                 :          0 :         int nlen = skb->len - len;
    1888                 :            :         struct sk_buff *buff;
    1889                 :            :         u8 flags;
    1890                 :            : 
    1891                 :            :         /* All of a TSO frame must be composed of paged data.  */
    1892                 :          0 :         if (skb->len != skb->data_len)
    1893                 :          0 :                 return tcp_fragment(sk, TCP_FRAG_IN_WRITE_QUEUE,
    1894                 :            :                                     skb, len, mss_now, gfp);
    1895                 :            : 
    1896                 :          0 :         buff = sk_stream_alloc_skb(sk, 0, gfp, true);
    1897                 :          0 :         if (unlikely(!buff))
    1898                 :            :                 return -ENOMEM;
    1899                 :            :         skb_copy_decrypted(buff, skb);
    1900                 :            : 
    1901                 :          0 :         sk_wmem_queued_add(sk, buff->truesize);
    1902                 :          0 :         sk_mem_charge(sk, buff->truesize);
    1903                 :          0 :         buff->truesize += nlen;
    1904                 :          0 :         skb->truesize -= nlen;
    1905                 :            : 
    1906                 :            :         /* Correct the sequence numbers. */
    1907                 :          0 :         TCP_SKB_CB(buff)->seq = TCP_SKB_CB(skb)->seq + len;
    1908                 :          0 :         TCP_SKB_CB(buff)->end_seq = TCP_SKB_CB(skb)->end_seq;
    1909                 :          0 :         TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(buff)->seq;
    1910                 :            : 
    1911                 :            :         /* PSH and FIN should only be set in the second packet. */
    1912                 :          0 :         flags = TCP_SKB_CB(skb)->tcp_flags;
    1913                 :          0 :         TCP_SKB_CB(skb)->tcp_flags = flags & ~(TCPHDR_FIN | TCPHDR_PSH);
    1914                 :          0 :         TCP_SKB_CB(buff)->tcp_flags = flags;
    1915                 :            : 
    1916                 :            :         /* This packet was never sent out yet, so no SACK bits. */
    1917                 :          0 :         TCP_SKB_CB(buff)->sacked = 0;
    1918                 :            : 
    1919                 :            :         tcp_skb_fragment_eor(skb, buff);
    1920                 :            : 
    1921                 :          0 :         buff->ip_summed = CHECKSUM_PARTIAL;
    1922                 :          0 :         skb_split(skb, buff, len);
    1923                 :          0 :         tcp_fragment_tstamp(skb, buff);
    1924                 :            : 
    1925                 :            :         /* Fix up tso_factor for both original and new SKB.  */
    1926                 :            :         tcp_set_skb_tso_segs(skb, mss_now);
    1927                 :            :         tcp_set_skb_tso_segs(buff, mss_now);
    1928                 :            : 
    1929                 :            :         /* Link BUFF into the send queue. */
    1930                 :            :         __skb_header_release(buff);
    1931                 :            :         tcp_insert_write_queue_after(skb, buff, sk, TCP_FRAG_IN_WRITE_QUEUE);
    1932                 :            : 
    1933                 :          0 :         return 0;
    1934                 :            : }
    1935                 :            : 
    1936                 :            : /* Try to defer sending, if possible, in order to minimize the amount
    1937                 :            :  * of TSO splitting we do.  View it as a kind of TSO Nagle test.
    1938                 :            :  *
    1939                 :            :  * This algorithm is from John Heffner.
    1940                 :            :  */
    1941                 :          0 : static bool tcp_tso_should_defer(struct sock *sk, struct sk_buff *skb,
    1942                 :            :                                  bool *is_cwnd_limited,
    1943                 :            :                                  bool *is_rwnd_limited,
    1944                 :            :                                  u32 max_segs)
    1945                 :            : {
    1946                 :            :         const struct inet_connection_sock *icsk = inet_csk(sk);
    1947                 :            :         u32 send_win, cong_win, limit, in_flight;
    1948                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1949                 :            :         struct sk_buff *head;
    1950                 :            :         int win_divisor;
    1951                 :            :         s64 delta;
    1952                 :            : 
    1953                 :          0 :         if (icsk->icsk_ca_state >= TCP_CA_Recovery)
    1954                 :            :                 goto send_now;
    1955                 :            : 
    1956                 :            :         /* Avoid bursty behavior by allowing defer
    1957                 :            :          * only if the last write was recent (1 ms).
    1958                 :            :          * Note that tp->tcp_wstamp_ns can be in the future if we have
    1959                 :            :          * packets waiting in a qdisc or device for EDT delivery.
    1960                 :            :          */
    1961                 :          0 :         delta = tp->tcp_clock_cache - tp->tcp_wstamp_ns - NSEC_PER_MSEC;
    1962                 :          0 :         if (delta > 0)
    1963                 :            :                 goto send_now;
    1964                 :            : 
    1965                 :            :         in_flight = tcp_packets_in_flight(tp);
    1966                 :            : 
    1967                 :          0 :         BUG_ON(tcp_skb_pcount(skb) <= 1);
    1968                 :          0 :         BUG_ON(tp->snd_cwnd <= in_flight);
    1969                 :            : 
    1970                 :          0 :         send_win = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
    1971                 :            : 
    1972                 :            :         /* From in_flight test above, we know that cwnd > in_flight.  */
    1973                 :          0 :         cong_win = (tp->snd_cwnd - in_flight) * tp->mss_cache;
    1974                 :            : 
    1975                 :          0 :         limit = min(send_win, cong_win);
    1976                 :            : 
    1977                 :            :         /* If a full-sized TSO skb can be sent, do it. */
    1978                 :          0 :         if (limit >= max_segs * tp->mss_cache)
    1979                 :            :                 goto send_now;
    1980                 :            : 
    1981                 :            :         /* Middle in queue won't get any more data, full sendable already? */
    1982                 :          0 :         if ((skb != tcp_write_queue_tail(sk)) && (limit >= skb->len))
    1983                 :            :                 goto send_now;
    1984                 :            : 
    1985                 :          0 :         win_divisor = READ_ONCE(sock_net(sk)->ipv4.sysctl_tcp_tso_win_divisor);
    1986                 :          0 :         if (win_divisor) {
    1987                 :          0 :                 u32 chunk = min(tp->snd_wnd, tp->snd_cwnd * tp->mss_cache);
    1988                 :            : 
    1989                 :            :                 /* If at least some fraction of a window is available,
    1990                 :            :                  * just use it.
    1991                 :            :                  */
    1992                 :          0 :                 chunk /= win_divisor;
    1993                 :          0 :                 if (limit >= chunk)
    1994                 :            :                         goto send_now;
    1995                 :            :         } else {
    1996                 :            :                 /* Different approach, try not to defer past a single
    1997                 :            :                  * ACK.  Receiver should ACK every other full sized
    1998                 :            :                  * frame, so if we have space for more than 3 frames
    1999                 :            :                  * then send now.
    2000                 :            :                  */
    2001                 :          0 :                 if (limit > tcp_max_tso_deferred_mss(tp) * tp->mss_cache)
    2002                 :            :                         goto send_now;
    2003                 :            :         }
    2004                 :            : 
    2005                 :            :         /* TODO : use tsorted_sent_queue ? */
    2006                 :            :         head = tcp_rtx_queue_head(sk);
    2007                 :          0 :         if (!head)
    2008                 :            :                 goto send_now;
    2009                 :          0 :         delta = tp->tcp_clock_cache - head->tstamp;
    2010                 :            :         /* If next ACK is likely to come too late (half srtt), do not defer */
    2011                 :          0 :         if ((s64)(delta - (u64)NSEC_PER_USEC * (tp->srtt_us >> 4)) < 0)
    2012                 :            :                 goto send_now;
    2013                 :            : 
    2014                 :            :         /* Ok, it looks like it is advisable to defer.
    2015                 :            :          * Three cases are tracked :
    2016                 :            :          * 1) We are cwnd-limited
    2017                 :            :          * 2) We are rwnd-limited
    2018                 :            :          * 3) We are application limited.
    2019                 :            :          */
    2020                 :          0 :         if (cong_win < send_win) {
    2021                 :          0 :                 if (cong_win <= skb->len) {
    2022                 :          0 :                         *is_cwnd_limited = true;
    2023                 :          0 :                         return true;
    2024                 :            :                 }
    2025                 :            :         } else {
    2026                 :          0 :                 if (send_win <= skb->len) {
    2027                 :          0 :                         *is_rwnd_limited = true;
    2028                 :          0 :                         return true;
    2029                 :            :                 }
    2030                 :            :         }
    2031                 :            : 
    2032                 :            :         /* If this packet won't get more data, do not wait. */
    2033                 :          0 :         if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) ||
    2034                 :            :             TCP_SKB_CB(skb)->eor)
    2035                 :            :                 goto send_now;
    2036                 :            : 
    2037                 :            :         return true;
    2038                 :            : 
    2039                 :            : send_now:
    2040                 :            :         return false;
    2041                 :            : }
    2042                 :            : 
    2043                 :          0 : static inline void tcp_mtu_check_reprobe(struct sock *sk)
    2044                 :            : {
    2045                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    2046                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2047                 :            :         struct net *net = sock_net(sk);
    2048                 :            :         u32 interval;
    2049                 :            :         s32 delta;
    2050                 :            : 
    2051                 :          0 :         interval = net->ipv4.sysctl_tcp_probe_interval;
    2052                 :          0 :         delta = tcp_jiffies32 - icsk->icsk_mtup.probe_timestamp;
    2053                 :          0 :         if (unlikely(delta >= interval * HZ)) {
    2054                 :          0 :                 int mss = tcp_current_mss(sk);
    2055                 :            : 
    2056                 :            :                 /* Update current search range */
    2057                 :          0 :                 icsk->icsk_mtup.probe_size = 0;
    2058                 :          0 :                 icsk->icsk_mtup.search_high = tp->rx_opt.mss_clamp +
    2059                 :          0 :                         sizeof(struct tcphdr) +
    2060                 :          0 :                         icsk->icsk_af_ops->net_header_len;
    2061                 :          0 :                 icsk->icsk_mtup.search_low = tcp_mss_to_mtu(sk, mss);
    2062                 :            : 
    2063                 :            :                 /* Update probe time stamp */
    2064                 :          0 :                 icsk->icsk_mtup.probe_timestamp = tcp_jiffies32;
    2065                 :            :         }
    2066                 :          0 : }
    2067                 :            : 
    2068                 :          0 : static bool tcp_can_coalesce_send_queue_head(struct sock *sk, int len)
    2069                 :            : {
    2070                 :            :         struct sk_buff *skb, *next;
    2071                 :            : 
    2072                 :            :         skb = tcp_send_head(sk);
    2073                 :          0 :         tcp_for_write_queue_from_safe(skb, next, sk) {
    2074                 :          0 :                 if (len <= skb->len)
    2075                 :            :                         break;
    2076                 :            : 
    2077                 :          0 :                 if (unlikely(TCP_SKB_CB(skb)->eor) || tcp_has_tx_tstamp(skb))
    2078                 :            :                         return false;
    2079                 :            : 
    2080                 :          0 :                 len -= skb->len;
    2081                 :            :         }
    2082                 :            : 
    2083                 :            :         return true;
    2084                 :            : }
    2085                 :            : 
    2086                 :            : /* Create a new MTU probe if we are ready.
    2087                 :            :  * MTU probe is regularly attempting to increase the path MTU by
    2088                 :            :  * deliberately sending larger packets.  This discovers routing
    2089                 :            :  * changes resulting in larger path MTUs.
    2090                 :            :  *
    2091                 :            :  * Returns 0 if we should wait to probe (no cwnd available),
    2092                 :            :  *         1 if a probe was sent,
    2093                 :            :  *         -1 otherwise
    2094                 :            :  */
    2095                 :          1 : static int tcp_mtu_probe(struct sock *sk)
    2096                 :            : {
    2097                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    2098                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2099                 :            :         struct sk_buff *skb, *nskb, *next;
    2100                 :            :         struct net *net = sock_net(sk);
    2101                 :            :         int probe_size;
    2102                 :            :         int size_needed;
    2103                 :            :         int copy, len;
    2104                 :            :         int mss_now;
    2105                 :            :         int interval;
    2106                 :            : 
    2107                 :            :         /* Not currently probing/verifying,
    2108                 :            :          * not in recovery,
    2109                 :            :          * have enough cwnd, and
    2110                 :            :          * not SACKing (the variable headers throw things off)
    2111                 :            :          */
    2112                 :          1 :         if (likely(!icsk->icsk_mtup.enabled ||
    2113                 :            :                    icsk->icsk_mtup.probe_size ||
    2114                 :            :                    inet_csk(sk)->icsk_ca_state != TCP_CA_Open ||
    2115                 :            :                    tp->snd_cwnd < 11 ||
    2116                 :            :                    tp->rx_opt.num_sacks || tp->rx_opt.dsack))
    2117                 :            :                 return -1;
    2118                 :            : 
    2119                 :            :         /* Use binary search for probe_size between tcp_mss_base,
    2120                 :            :          * and current mss_clamp. if (search_high - search_low)
    2121                 :            :          * smaller than a threshold, backoff from probing.
    2122                 :            :          */
    2123                 :          0 :         mss_now = tcp_current_mss(sk);
    2124                 :          0 :         probe_size = tcp_mtu_to_mss(sk, (icsk->icsk_mtup.search_high +
    2125                 :          0 :                                     icsk->icsk_mtup.search_low) >> 1);
    2126                 :          0 :         size_needed = probe_size + (tp->reordering + 1) * tp->mss_cache;
    2127                 :          0 :         interval = icsk->icsk_mtup.search_high - icsk->icsk_mtup.search_low;
    2128                 :            :         /* When misfortune happens, we are reprobing actively,
    2129                 :            :          * and then reprobe timer has expired. We stick with current
    2130                 :            :          * probing process by not resetting search range to its orignal.
    2131                 :            :          */
    2132                 :          0 :         if (probe_size > tcp_mtu_to_mss(sk, icsk->icsk_mtup.search_high) ||
    2133                 :          0 :                 interval < net->ipv4.sysctl_tcp_probe_threshold) {
    2134                 :            :                 /* Check whether enough time has elaplased for
    2135                 :            :                  * another round of probing.
    2136                 :            :                  */
    2137                 :          0 :                 tcp_mtu_check_reprobe(sk);
    2138                 :          0 :                 return -1;
    2139                 :            :         }
    2140                 :            : 
    2141                 :            :         /* Have enough data in the send queue to probe? */
    2142                 :          0 :         if (tp->write_seq - tp->snd_nxt < size_needed)
    2143                 :            :                 return -1;
    2144                 :            : 
    2145                 :          0 :         if (tp->snd_wnd < size_needed)
    2146                 :            :                 return -1;
    2147                 :          0 :         if (after(tp->snd_nxt + size_needed, tcp_wnd_end(tp)))
    2148                 :            :                 return 0;
    2149                 :            : 
    2150                 :            :         /* Do we need to wait to drain cwnd? With none in flight, don't stall */
    2151                 :          0 :         if (tcp_packets_in_flight(tp) + 2 > tp->snd_cwnd) {
    2152                 :          0 :                 if (!tcp_packets_in_flight(tp))
    2153                 :            :                         return -1;
    2154                 :            :                 else
    2155                 :          0 :                         return 0;
    2156                 :            :         }
    2157                 :            : 
    2158                 :          0 :         if (!tcp_can_coalesce_send_queue_head(sk, probe_size))
    2159                 :            :                 return -1;
    2160                 :            : 
    2161                 :            :         /* We're allowed to probe.  Build it now. */
    2162                 :          0 :         nskb = sk_stream_alloc_skb(sk, probe_size, GFP_ATOMIC, false);
    2163                 :          0 :         if (!nskb)
    2164                 :            :                 return -1;
    2165                 :          0 :         sk_wmem_queued_add(sk, nskb->truesize);
    2166                 :          0 :         sk_mem_charge(sk, nskb->truesize);
    2167                 :            : 
    2168                 :            :         skb = tcp_send_head(sk);
    2169                 :            :         skb_copy_decrypted(nskb, skb);
    2170                 :            : 
    2171                 :          0 :         TCP_SKB_CB(nskb)->seq = TCP_SKB_CB(skb)->seq;
    2172                 :          0 :         TCP_SKB_CB(nskb)->end_seq = TCP_SKB_CB(skb)->seq + probe_size;
    2173                 :          0 :         TCP_SKB_CB(nskb)->tcp_flags = TCPHDR_ACK;
    2174                 :          0 :         TCP_SKB_CB(nskb)->sacked = 0;
    2175                 :          0 :         nskb->csum = 0;
    2176                 :          0 :         nskb->ip_summed = CHECKSUM_PARTIAL;
    2177                 :            : 
    2178                 :            :         tcp_insert_write_queue_before(nskb, skb, sk);
    2179                 :            :         tcp_highest_sack_replace(sk, skb, nskb);
    2180                 :            : 
    2181                 :            :         len = 0;
    2182                 :          0 :         tcp_for_write_queue_from_safe(skb, next, sk) {
    2183                 :          0 :                 copy = min_t(int, skb->len, probe_size - len);
    2184                 :          0 :                 skb_copy_bits(skb, 0, skb_put(nskb, copy), copy);
    2185                 :            : 
    2186                 :          0 :                 if (skb->len <= copy) {
    2187                 :            :                         /* We've eaten all the data from this skb.
    2188                 :            :                          * Throw it away. */
    2189                 :          0 :                         TCP_SKB_CB(nskb)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags;
    2190                 :            :                         /* If this is the last SKB we copy and eor is set
    2191                 :            :                          * we need to propagate it to the new skb.
    2192                 :            :                          */
    2193                 :          0 :                         TCP_SKB_CB(nskb)->eor = TCP_SKB_CB(skb)->eor;
    2194                 :          0 :                         tcp_skb_collapse_tstamp(nskb, skb);
    2195                 :            :                         tcp_unlink_write_queue(skb, sk);
    2196                 :          0 :                         sk_wmem_free_skb(sk, skb);
    2197                 :            :                 } else {
    2198                 :          0 :                         TCP_SKB_CB(nskb)->tcp_flags |= TCP_SKB_CB(skb)->tcp_flags &
    2199                 :            :                                                    ~(TCPHDR_FIN|TCPHDR_PSH);
    2200                 :          0 :                         if (!skb_shinfo(skb)->nr_frags) {
    2201                 :          0 :                                 skb_pull(skb, copy);
    2202                 :            :                         } else {
    2203                 :          0 :                                 __pskb_trim_head(skb, copy);
    2204                 :            :                                 tcp_set_skb_tso_segs(skb, mss_now);
    2205                 :            :                         }
    2206                 :          0 :                         TCP_SKB_CB(skb)->seq += copy;
    2207                 :            :                 }
    2208                 :            : 
    2209                 :          0 :                 len += copy;
    2210                 :            : 
    2211                 :          0 :                 if (len >= probe_size)
    2212                 :            :                         break;
    2213                 :            :         }
    2214                 :          0 :         tcp_init_tso_segs(nskb, nskb->len);
    2215                 :            : 
    2216                 :            :         /* We're ready to send.  If this fails, the probe will
    2217                 :            :          * be resegmented into mss-sized pieces by tcp_write_xmit().
    2218                 :            :          */
    2219                 :          0 :         if (!tcp_transmit_skb(sk, nskb, 1, GFP_ATOMIC)) {
    2220                 :            :                 /* Decrement cwnd here because we are sending
    2221                 :            :                  * effectively two packets. */
    2222                 :          0 :                 tp->snd_cwnd--;
    2223                 :          0 :                 tcp_event_new_data_sent(sk, nskb);
    2224                 :            : 
    2225                 :          0 :                 icsk->icsk_mtup.probe_size = tcp_mss_to_mtu(sk, nskb->len);
    2226                 :          0 :                 tp->mtu_probe.probe_seq_start = TCP_SKB_CB(nskb)->seq;
    2227                 :          0 :                 tp->mtu_probe.probe_seq_end = TCP_SKB_CB(nskb)->end_seq;
    2228                 :            : 
    2229                 :          0 :                 return 1;
    2230                 :            :         }
    2231                 :            : 
    2232                 :            :         return -1;
    2233                 :            : }
    2234                 :            : 
    2235                 :          1 : static bool tcp_pacing_check(struct sock *sk)
    2236                 :            : {
    2237                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2238                 :            : 
    2239                 :          1 :         if (!tcp_needs_internal_pacing(sk))
    2240                 :            :                 return false;
    2241                 :            : 
    2242                 :          0 :         if (tp->tcp_wstamp_ns <= tp->tcp_clock_cache)
    2243                 :            :                 return false;
    2244                 :            : 
    2245                 :          0 :         if (!hrtimer_is_queued(&tp->pacing_timer)) {
    2246                 :          0 :                 hrtimer_start(&tp->pacing_timer,
    2247                 :            :                               ns_to_ktime(tp->tcp_wstamp_ns),
    2248                 :            :                               HRTIMER_MODE_ABS_PINNED_SOFT);
    2249                 :            :                 sock_hold(sk);
    2250                 :            :         }
    2251                 :            :         return true;
    2252                 :            : }
    2253                 :            : 
    2254                 :            : /* TCP Small Queues :
    2255                 :            :  * Control number of packets in qdisc/devices to two packets / or ~1 ms.
    2256                 :            :  * (These limits are doubled for retransmits)
    2257                 :            :  * This allows for :
    2258                 :            :  *  - better RTT estimation and ACK scheduling
    2259                 :            :  *  - faster recovery
    2260                 :            :  *  - high rates
    2261                 :            :  * Alas, some drivers / subsystems require a fair amount
    2262                 :            :  * of queued bytes to ensure line rate.
    2263                 :            :  * One example is wifi aggregation (802.11 AMPDU)
    2264                 :            :  */
    2265                 :          1 : static bool tcp_small_queue_check(struct sock *sk, const struct sk_buff *skb,
    2266                 :            :                                   unsigned int factor)
    2267                 :            : {
    2268                 :            :         unsigned long limit;
    2269                 :            : 
    2270                 :          1 :         limit = max_t(unsigned long,
    2271                 :            :                       2 * skb->truesize,
    2272                 :            :                       sk->sk_pacing_rate >> READ_ONCE(sk->sk_pacing_shift));
    2273                 :          1 :         if (sk->sk_pacing_status == SK_PACING_NONE)
    2274                 :          1 :                 limit = min_t(unsigned long, limit,
    2275                 :            :                               sock_net(sk)->ipv4.sysctl_tcp_limit_output_bytes);
    2276                 :          1 :         limit <<= factor;
    2277                 :            : 
    2278                 :          1 :         if (static_branch_unlikely(&tcp_tx_delay_enabled) &&
    2279                 :          0 :             tcp_sk(sk)->tcp_tx_delay) {
    2280                 :          0 :                 u64 extra_bytes = (u64)sk->sk_pacing_rate * tcp_sk(sk)->tcp_tx_delay;
    2281                 :            : 
    2282                 :            :                 /* TSQ is based on skb truesize sum (sk_wmem_alloc), so we
    2283                 :            :                  * approximate our needs assuming an ~100% skb->truesize overhead.
    2284                 :            :                  * USEC_PER_SEC is approximated by 2^20.
    2285                 :            :                  * do_div(extra_bytes, USEC_PER_SEC/2) is replaced by a right shift.
    2286                 :            :                  */
    2287                 :          0 :                 extra_bytes >>= (20 - 1);
    2288                 :          0 :                 limit += extra_bytes;
    2289                 :            :         }
    2290                 :          1 :         if (refcount_read(&sk->sk_wmem_alloc) > limit) {
    2291                 :            :                 /* Always send skb if rtx queue is empty.
    2292                 :            :                  * No need to wait for TX completion to call us back,
    2293                 :            :                  * after softirq/tasklet schedule.
    2294                 :            :                  * This helps when TX completions are delayed too much.
    2295                 :            :                  */
    2296                 :          0 :                 if (tcp_rtx_queue_empty(sk))
    2297                 :            :                         return false;
    2298                 :            : 
    2299                 :          0 :                 set_bit(TSQ_THROTTLED, &sk->sk_tsq_flags);
    2300                 :            :                 /* It is possible TX completion already happened
    2301                 :            :                  * before we set TSQ_THROTTLED, so we must
    2302                 :            :                  * test again the condition.
    2303                 :            :                  */
    2304                 :          0 :                 smp_mb__after_atomic();
    2305                 :          0 :                 if (refcount_read(&sk->sk_wmem_alloc) > limit)
    2306                 :            :                         return true;
    2307                 :            :         }
    2308                 :            :         return false;
    2309                 :            : }
    2310                 :            : 
    2311                 :            : static void tcp_chrono_set(struct tcp_sock *tp, const enum tcp_chrono new)
    2312                 :            : {
    2313                 :          1 :         const u32 now = tcp_jiffies32;
    2314                 :          1 :         enum tcp_chrono old = tp->chrono_type;
    2315                 :            : 
    2316                 :          1 :         if (old > TCP_CHRONO_UNSPEC)
    2317                 :          1 :                 tp->chrono_stat[old - 1] += now - tp->chrono_start;
    2318                 :          1 :         tp->chrono_start = now;
    2319                 :          1 :         tp->chrono_type = new;
    2320                 :            : }
    2321                 :            : 
    2322                 :          1 : void tcp_chrono_start(struct sock *sk, const enum tcp_chrono type)
    2323                 :            : {
    2324                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2325                 :            : 
    2326                 :            :         /* If there are multiple conditions worthy of tracking in a
    2327                 :            :          * chronograph then the highest priority enum takes precedence
    2328                 :            :          * over the other conditions. So that if something "more interesting"
    2329                 :            :          * starts happening, stop the previous chrono and start a new one.
    2330                 :            :          */
    2331                 :          1 :         if (type > tp->chrono_type)
    2332                 :            :                 tcp_chrono_set(tp, type);
    2333                 :          1 : }
    2334                 :            : 
    2335                 :          1 : void tcp_chrono_stop(struct sock *sk, const enum tcp_chrono type)
    2336                 :            : {
    2337                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2338                 :            : 
    2339                 :            : 
    2340                 :            :         /* There are multiple conditions worthy of tracking in a
    2341                 :            :          * chronograph, so that the highest priority enum takes
    2342                 :            :          * precedence over the other conditions (see tcp_chrono_start).
    2343                 :            :          * If a condition stops, we only stop chrono tracking if
    2344                 :            :          * it's the "most interesting" or current chrono we are
    2345                 :            :          * tracking and starts busy chrono if we have pending data.
    2346                 :            :          */
    2347                 :          1 :         if (tcp_rtx_and_write_queues_empty(sk))
    2348                 :            :                 tcp_chrono_set(tp, TCP_CHRONO_UNSPEC);
    2349                 :          1 :         else if (type == tp->chrono_type)
    2350                 :            :                 tcp_chrono_set(tp, TCP_CHRONO_BUSY);
    2351                 :          1 : }
    2352                 :            : 
    2353                 :            : /* This routine writes packets to the network.  It advances the
    2354                 :            :  * send_head.  This happens as incoming acks open up the remote
    2355                 :            :  * window for us.
    2356                 :            :  *
    2357                 :            :  * LARGESEND note: !tcp_urg_mode is overkill, only frames between
    2358                 :            :  * snd_up-64k-mss .. snd_up cannot be large. However, taking into
    2359                 :            :  * account rare use of URG, this is not a big flaw.
    2360                 :            :  *
    2361                 :            :  * Send at most one packet when push_one > 0. Temporarily ignore
    2362                 :            :  * cwnd limit to force at most one packet out when push_one == 2.
    2363                 :            : 
    2364                 :            :  * Returns true, if no segments are in flight and we have queued segments,
    2365                 :            :  * but cannot send anything now because of SWS or another problem.
    2366                 :            :  */
    2367                 :          1 : static bool tcp_write_xmit(struct sock *sk, unsigned int mss_now, int nonagle,
    2368                 :            :                            int push_one, gfp_t gfp)
    2369                 :            : {
    2370                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2371                 :            :         struct sk_buff *skb;
    2372                 :            :         unsigned int tso_segs, sent_pkts;
    2373                 :            :         int cwnd_quota;
    2374                 :            :         int result;
    2375                 :          1 :         bool is_cwnd_limited = false, is_rwnd_limited = false;
    2376                 :            :         u32 max_segs;
    2377                 :            : 
    2378                 :            :         sent_pkts = 0;
    2379                 :            : 
    2380                 :          1 :         tcp_mstamp_refresh(tp);
    2381                 :          1 :         if (!push_one) {
    2382                 :            :                 /* Do MTU probing. */
    2383                 :          1 :                 result = tcp_mtu_probe(sk);
    2384                 :          1 :                 if (!result) {
    2385                 :            :                         return false;
    2386                 :          1 :                 } else if (result > 0) {
    2387                 :            :                         sent_pkts = 1;
    2388                 :            :                 }
    2389                 :            :         }
    2390                 :            : 
    2391                 :          1 :         max_segs = tcp_tso_segs(sk, mss_now);
    2392                 :          1 :         while ((skb = tcp_send_head(sk))) {
    2393                 :            :                 unsigned int limit;
    2394                 :            : 
    2395                 :          1 :                 if (unlikely(tp->repair) && tp->repair_queue == TCP_SEND_QUEUE) {
    2396                 :            :                         /* "skb_mstamp_ns" is used as a start point for the retransmit timer */
    2397                 :          0 :                         skb->skb_mstamp_ns = tp->tcp_wstamp_ns = tp->tcp_clock_cache;
    2398                 :          0 :                         list_move_tail(&skb->tcp_tsorted_anchor, &tp->tsorted_sent_queue);
    2399                 :          0 :                         tcp_init_tso_segs(skb, mss_now);
    2400                 :          0 :                         goto repair; /* Skip network transmission */
    2401                 :            :                 }
    2402                 :            : 
    2403                 :          1 :                 if (tcp_pacing_check(sk))
    2404                 :            :                         break;
    2405                 :            : 
    2406                 :          1 :                 tso_segs = tcp_init_tso_segs(skb, mss_now);
    2407                 :          1 :                 BUG_ON(!tso_segs);
    2408                 :            : 
    2409                 :          1 :                 cwnd_quota = tcp_cwnd_test(tp, skb);
    2410                 :          1 :                 if (!cwnd_quota) {
    2411                 :          0 :                         if (push_one == 2)
    2412                 :            :                                 /* Force out a loss probe pkt. */
    2413                 :            :                                 cwnd_quota = 1;
    2414                 :            :                         else
    2415                 :            :                                 break;
    2416                 :            :                 }
    2417                 :            : 
    2418                 :          1 :                 if (unlikely(!tcp_snd_wnd_test(tp, skb, mss_now))) {
    2419                 :          0 :                         is_rwnd_limited = true;
    2420                 :          0 :                         break;
    2421                 :            :                 }
    2422                 :            : 
    2423                 :          1 :                 if (tso_segs == 1) {
    2424                 :          1 :                         if (unlikely(!tcp_nagle_test(tp, skb, mss_now,
    2425                 :            :                                                      (tcp_skb_is_last(sk, skb) ?
    2426                 :            :                                                       nonagle : TCP_NAGLE_PUSH))))
    2427                 :            :                                 break;
    2428                 :            :                 } else {
    2429                 :          0 :                         if (!push_one &&
    2430                 :          0 :                             tcp_tso_should_defer(sk, skb, &is_cwnd_limited,
    2431                 :            :                                                  &is_rwnd_limited, max_segs))
    2432                 :            :                                 break;
    2433                 :            :                 }
    2434                 :            : 
    2435                 :            :                 limit = mss_now;
    2436                 :          1 :                 if (tso_segs > 1 && !tcp_urg_mode(tp))
    2437                 :          0 :                         limit = tcp_mss_split_point(sk, skb, mss_now,
    2438                 :          0 :                                                     min_t(unsigned int,
    2439                 :            :                                                           cwnd_quota,
    2440                 :            :                                                           max_segs),
    2441                 :            :                                                     nonagle);
    2442                 :            : 
    2443                 :          1 :                 if (skb->len > limit &&
    2444                 :          0 :                     unlikely(tso_fragment(sk, skb, limit, mss_now, gfp)))
    2445                 :            :                         break;
    2446                 :            : 
    2447                 :          1 :                 if (tcp_small_queue_check(sk, skb, 0))
    2448                 :            :                         break;
    2449                 :            : 
    2450                 :            :                 /* Argh, we hit an empty skb(), presumably a thread
    2451                 :            :                  * is sleeping in sendmsg()/sk_stream_wait_memory().
    2452                 :            :                  * We do not want to send a pure-ack packet and have
    2453                 :            :                  * a strange looking rtx queue with empty packet(s).
    2454                 :            :                  */
    2455                 :          1 :                 if (TCP_SKB_CB(skb)->end_seq == TCP_SKB_CB(skb)->seq)
    2456                 :            :                         break;
    2457                 :            : 
    2458                 :          1 :                 if (unlikely(tcp_transmit_skb(sk, skb, 1, gfp)))
    2459                 :            :                         break;
    2460                 :            : 
    2461                 :            : repair:
    2462                 :            :                 /* Advance the send_head.  This one is sent out.
    2463                 :            :                  * This call will increment packets_out.
    2464                 :            :                  */
    2465                 :          1 :                 tcp_event_new_data_sent(sk, skb);
    2466                 :            : 
    2467                 :            :                 tcp_minshall_update(tp, mss_now, skb);
    2468                 :          1 :                 sent_pkts += tcp_skb_pcount(skb);
    2469                 :            : 
    2470                 :          1 :                 if (push_one)
    2471                 :            :                         break;
    2472                 :            :         }
    2473                 :            : 
    2474                 :          1 :         if (is_rwnd_limited)
    2475                 :            :                 tcp_chrono_start(sk, TCP_CHRONO_RWND_LIMITED);
    2476                 :            :         else
    2477                 :          1 :                 tcp_chrono_stop(sk, TCP_CHRONO_RWND_LIMITED);
    2478                 :            : 
    2479                 :          1 :         if (likely(sent_pkts)) {
    2480                 :          1 :                 if (tcp_in_cwnd_reduction(sk))
    2481                 :          0 :                         tp->prr_out += sent_pkts;
    2482                 :            : 
    2483                 :            :                 /* Send one loss probe per tail loss episode. */
    2484                 :          1 :                 if (push_one != 2)
    2485                 :          1 :                         tcp_schedule_loss_probe(sk, false);
    2486                 :          1 :                 is_cwnd_limited |= (tcp_packets_in_flight(tp) >= tp->snd_cwnd);
    2487                 :          1 :                 tcp_cwnd_validate(sk, is_cwnd_limited);
    2488                 :          1 :                 return false;
    2489                 :            :         }
    2490                 :          1 :         return !tp->packets_out && !tcp_write_queue_empty(sk);
    2491                 :            : }
    2492                 :            : 
    2493                 :          1 : bool tcp_schedule_loss_probe(struct sock *sk, bool advancing_rto)
    2494                 :            : {
    2495                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    2496                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2497                 :            :         u32 timeout, rto_delta_us;
    2498                 :            :         int early_retrans;
    2499                 :            : 
    2500                 :            :         /* Don't do any loss probe on a Fast Open connection before 3WHS
    2501                 :            :          * finishes.
    2502                 :            :          */
    2503                 :          1 :         if (rcu_access_pointer(tp->fastopen_rsk))
    2504                 :            :                 return false;
    2505                 :            : 
    2506                 :          1 :         early_retrans = sock_net(sk)->ipv4.sysctl_tcp_early_retrans;
    2507                 :            :         /* Schedule a loss probe in 2*RTT for SACK capable connections
    2508                 :            :          * not in loss recovery, that are either limited by cwnd or application.
    2509                 :            :          */
    2510                 :          1 :         if ((early_retrans != 3 && early_retrans != 4) ||
    2511                 :          1 :             !tp->packets_out || !tcp_is_sack(tp) ||
    2512                 :          0 :             (icsk->icsk_ca_state != TCP_CA_Open &&
    2513                 :            :              icsk->icsk_ca_state != TCP_CA_CWR))
    2514                 :            :                 return false;
    2515                 :            : 
    2516                 :            :         /* Probe timeout is 2*rtt. Add minimum RTO to account
    2517                 :            :          * for delayed ack when there's one outstanding packet. If no RTT
    2518                 :            :          * sample is available then probe after TCP_TIMEOUT_INIT.
    2519                 :            :          */
    2520                 :          0 :         if (tp->srtt_us) {
    2521                 :          0 :                 timeout = usecs_to_jiffies(tp->srtt_us >> 2);
    2522                 :          0 :                 if (tp->packets_out == 1)
    2523                 :          0 :                         timeout += TCP_RTO_MIN;
    2524                 :            :                 else
    2525                 :          0 :                         timeout += TCP_TIMEOUT_MIN;
    2526                 :            :         } else {
    2527                 :            :                 timeout = TCP_TIMEOUT_INIT;
    2528                 :            :         }
    2529                 :            : 
    2530                 :            :         /* If the RTO formula yields an earlier time, then use that time. */
    2531                 :          0 :         rto_delta_us = advancing_rto ?
    2532                 :          0 :                         jiffies_to_usecs(inet_csk(sk)->icsk_rto) :
    2533                 :          0 :                         tcp_rto_delta_us(sk);  /* How far in future is RTO? */
    2534                 :          0 :         if (rto_delta_us > 0)
    2535                 :          0 :                 timeout = min_t(u32, timeout, usecs_to_jiffies(rto_delta_us));
    2536                 :            : 
    2537                 :          0 :         tcp_reset_xmit_timer(sk, ICSK_TIME_LOSS_PROBE, timeout,
    2538                 :            :                              TCP_RTO_MAX, NULL);
    2539                 :          0 :         return true;
    2540                 :            : }
    2541                 :            : 
    2542                 :            : /* Thanks to skb fast clones, we can detect if a prior transmit of
    2543                 :            :  * a packet is still in a qdisc or driver queue.
    2544                 :            :  * In this case, there is very little point doing a retransmit !
    2545                 :            :  */
    2546                 :          1 : static bool skb_still_in_host_queue(const struct sock *sk,
    2547                 :            :                                     const struct sk_buff *skb)
    2548                 :            : {
    2549                 :          1 :         if (unlikely(skb_fclone_busy(sk, skb))) {
    2550                 :          1 :                 NET_INC_STATS(sock_net(sk),
    2551                 :            :                               LINUX_MIB_TCPSPURIOUS_RTX_HOSTQUEUES);
    2552                 :          1 :                 return true;
    2553                 :            :         }
    2554                 :            :         return false;
    2555                 :            : }
    2556                 :            : 
    2557                 :            : /* When probe timeout (PTO) fires, try send a new segment if possible, else
    2558                 :            :  * retransmit the last segment.
    2559                 :            :  */
    2560                 :          0 : void tcp_send_loss_probe(struct sock *sk)
    2561                 :            : {
    2562                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2563                 :            :         struct sk_buff *skb;
    2564                 :            :         int pcount;
    2565                 :          0 :         int mss = tcp_current_mss(sk);
    2566                 :            : 
    2567                 :            :         /* At most one outstanding TLP */
    2568                 :          0 :         if (tp->tlp_high_seq)
    2569                 :            :                 goto rearm_timer;
    2570                 :            : 
    2571                 :          0 :         tp->tlp_retrans = 0;
    2572                 :            :         skb = tcp_send_head(sk);
    2573                 :          0 :         if (skb && tcp_snd_wnd_test(tp, skb, mss)) {
    2574                 :          0 :                 pcount = tp->packets_out;
    2575                 :          0 :                 tcp_write_xmit(sk, mss, TCP_NAGLE_OFF, 2, GFP_ATOMIC);
    2576                 :          0 :                 if (tp->packets_out > pcount)
    2577                 :            :                         goto probe_sent;
    2578                 :            :                 goto rearm_timer;
    2579                 :            :         }
    2580                 :          0 :         skb = skb_rb_last(&sk->tcp_rtx_queue);
    2581                 :          0 :         if (unlikely(!skb)) {
    2582                 :          0 :                 WARN_ONCE(tp->packets_out,
    2583                 :            :                           "invalid inflight: %u state %u cwnd %u mss %d\n",
    2584                 :            :                           tp->packets_out, sk->sk_state, tp->snd_cwnd, mss);
    2585                 :          0 :                 inet_csk(sk)->icsk_pending = 0;
    2586                 :          0 :                 return;
    2587                 :            :         }
    2588                 :            : 
    2589                 :          0 :         if (skb_still_in_host_queue(sk, skb))
    2590                 :            :                 goto rearm_timer;
    2591                 :            : 
    2592                 :            :         pcount = tcp_skb_pcount(skb);
    2593                 :          0 :         if (WARN_ON(!pcount))
    2594                 :            :                 goto rearm_timer;
    2595                 :            : 
    2596                 :          0 :         if ((pcount > 1) && (skb->len > (pcount - 1) * mss)) {
    2597                 :          0 :                 if (unlikely(tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb,
    2598                 :            :                                           (pcount - 1) * mss, mss,
    2599                 :            :                                           GFP_ATOMIC)))
    2600                 :            :                         goto rearm_timer;
    2601                 :          0 :                 skb = skb_rb_next(skb);
    2602                 :            :         }
    2603                 :            : 
    2604                 :          0 :         if (WARN_ON(!skb || !tcp_skb_pcount(skb)))
    2605                 :            :                 goto rearm_timer;
    2606                 :            : 
    2607                 :          0 :         if (__tcp_retransmit_skb(sk, skb, 1))
    2608                 :            :                 goto rearm_timer;
    2609                 :            : 
    2610                 :          0 :         tp->tlp_retrans = 1;
    2611                 :            : 
    2612                 :            : probe_sent:
    2613                 :            :         /* Record snd_nxt for loss detection. */
    2614                 :          0 :         tp->tlp_high_seq = tp->snd_nxt;
    2615                 :            : 
    2616                 :          0 :         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPLOSSPROBES);
    2617                 :            :         /* Reset s.t. tcp_rearm_rto will restart timer from now */
    2618                 :          0 :         inet_csk(sk)->icsk_pending = 0;
    2619                 :            : rearm_timer:
    2620                 :          0 :         tcp_rearm_rto(sk);
    2621                 :            : }
    2622                 :            : 
    2623                 :            : /* Push out any pending frames which were held back due to
    2624                 :            :  * TCP_CORK or attempt at coalescing tiny packets.
    2625                 :            :  * The socket must be locked by the caller.
    2626                 :            :  */
    2627                 :          1 : void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
    2628                 :            :                                int nonagle)
    2629                 :            : {
    2630                 :            :         /* If we are closed, the bytes will have to remain here.
    2631                 :            :          * In time closedown will finish, we empty the write queue and
    2632                 :            :          * all will be happy.
    2633                 :            :          */
    2634                 :          1 :         if (unlikely(sk->sk_state == TCP_CLOSE))
    2635                 :          1 :                 return;
    2636                 :            : 
    2637                 :          1 :         if (tcp_write_xmit(sk, cur_mss, nonagle, 0,
    2638                 :            :                            sk_gfp_mask(sk, GFP_ATOMIC)))
    2639                 :          0 :                 tcp_check_probe_timer(sk);
    2640                 :            : }
    2641                 :            : 
    2642                 :            : /* Send _single_ skb sitting at the send head. This function requires
    2643                 :            :  * true push pending frames to setup probe timer etc.
    2644                 :            :  */
    2645                 :          0 : void tcp_push_one(struct sock *sk, unsigned int mss_now)
    2646                 :            : {
    2647                 :            :         struct sk_buff *skb = tcp_send_head(sk);
    2648                 :            : 
    2649                 :          0 :         BUG_ON(!skb || skb->len < mss_now);
    2650                 :            : 
    2651                 :          0 :         tcp_write_xmit(sk, mss_now, TCP_NAGLE_PUSH, 1, sk->sk_allocation);
    2652                 :          0 : }
    2653                 :            : 
    2654                 :            : /* This function returns the amount that we can raise the
    2655                 :            :  * usable window based on the following constraints
    2656                 :            :  *
    2657                 :            :  * 1. The window can never be shrunk once it is offered (RFC 793)
    2658                 :            :  * 2. We limit memory per socket
    2659                 :            :  *
    2660                 :            :  * RFC 1122:
    2661                 :            :  * "the suggested [SWS] avoidance algorithm for the receiver is to keep
    2662                 :            :  *  RECV.NEXT + RCV.WIN fixed until:
    2663                 :            :  *  RCV.BUFF - RCV.USER - RCV.WINDOW >= min(1/2 RCV.BUFF, MSS)"
    2664                 :            :  *
    2665                 :            :  * i.e. don't raise the right edge of the window until you can raise
    2666                 :            :  * it at least MSS bytes.
    2667                 :            :  *
    2668                 :            :  * Unfortunately, the recommended algorithm breaks header prediction,
    2669                 :            :  * since header prediction assumes th->window stays fixed.
    2670                 :            :  *
    2671                 :            :  * Strictly speaking, keeping th->window fixed violates the receiver
    2672                 :            :  * side SWS prevention criteria. The problem is that under this rule
    2673                 :            :  * a stream of single byte packets will cause the right side of the
    2674                 :            :  * window to always advance by a single byte.
    2675                 :            :  *
    2676                 :            :  * Of course, if the sender implements sender side SWS prevention
    2677                 :            :  * then this will not be a problem.
    2678                 :            :  *
    2679                 :            :  * BSD seems to make the following compromise:
    2680                 :            :  *
    2681                 :            :  *      If the free space is less than the 1/4 of the maximum
    2682                 :            :  *      space available and the free space is less than 1/2 mss,
    2683                 :            :  *      then set the window to 0.
    2684                 :            :  *      [ Actually, bsd uses MSS and 1/4 of maximal _window_ ]
    2685                 :            :  *      Otherwise, just prevent the window from shrinking
    2686                 :            :  *      and from being larger than the largest representable value.
    2687                 :            :  *
    2688                 :            :  * This prevents incremental opening of the window in the regime
    2689                 :            :  * where TCP is limited by the speed of the reader side taking
    2690                 :            :  * data out of the TCP receive queue. It does nothing about
    2691                 :            :  * those cases where the window is constrained on the sender side
    2692                 :            :  * because the pipeline is full.
    2693                 :            :  *
    2694                 :            :  * BSD also seems to "accidentally" limit itself to windows that are a
    2695                 :            :  * multiple of MSS, at least until the free space gets quite small.
    2696                 :            :  * This would appear to be a side effect of the mbuf implementation.
    2697                 :            :  * Combining these two algorithms results in the observed behavior
    2698                 :            :  * of having a fixed window size at almost all times.
    2699                 :            :  *
    2700                 :            :  * Below we obtain similar behavior by forcing the offered window to
    2701                 :            :  * a multiple of the mss when it is feasible to do so.
    2702                 :            :  *
    2703                 :            :  * Note, we don't "adjust" for TIMESTAMP or SACK option bytes.
    2704                 :            :  * Regular options like TIMESTAMP are taken into account.
    2705                 :            :  */
    2706                 :          1 : u32 __tcp_select_window(struct sock *sk)
    2707                 :            : {
    2708                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    2709                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2710                 :            :         /* MSS for the peer's data.  Previous versions used mss_clamp
    2711                 :            :          * here.  I don't know if the value based on our guesses
    2712                 :            :          * of peer's MSS is better for the performance.  It's more correct
    2713                 :            :          * but may be worse for the performance because of rcv_mss
    2714                 :            :          * fluctuations.  --SAW  1998/11/1
    2715                 :            :          */
    2716                 :          1 :         int mss = icsk->icsk_ack.rcv_mss;
    2717                 :            :         int free_space = tcp_space(sk);
    2718                 :            :         int allowed_space = tcp_full_space(sk);
    2719                 :          1 :         int full_space = min_t(int, tp->window_clamp, allowed_space);
    2720                 :            :         int window;
    2721                 :            : 
    2722                 :          1 :         if (unlikely(mss > full_space)) {
    2723                 :            :                 mss = full_space;
    2724                 :          0 :                 if (mss <= 0)
    2725                 :            :                         return 0;
    2726                 :            :         }
    2727                 :          1 :         if (free_space < (full_space >> 1)) {
    2728                 :          0 :                 icsk->icsk_ack.quick = 0;
    2729                 :            : 
    2730                 :          0 :                 if (tcp_under_memory_pressure(sk))
    2731                 :          0 :                         tp->rcv_ssthresh = min(tp->rcv_ssthresh,
    2732                 :            :                                                4U * tp->advmss);
    2733                 :            : 
    2734                 :            :                 /* free_space might become our new window, make sure we don't
    2735                 :            :                  * increase it due to wscale.
    2736                 :            :                  */
    2737                 :          0 :                 free_space = round_down(free_space, 1 << tp->rx_opt.rcv_wscale);
    2738                 :            : 
    2739                 :            :                 /* if free space is less than mss estimate, or is below 1/16th
    2740                 :            :                  * of the maximum allowed, try to move to zero-window, else
    2741                 :            :                  * tcp_clamp_window() will grow rcv buf up to tcp_rmem[2], and
    2742                 :            :                  * new incoming data is dropped due to memory limits.
    2743                 :            :                  * With large window, mss test triggers way too late in order
    2744                 :            :                  * to announce zero window in time before rmem limit kicks in.
    2745                 :            :                  */
    2746                 :          0 :                 if (free_space < (allowed_space >> 4) || free_space < mss)
    2747                 :            :                         return 0;
    2748                 :            :         }
    2749                 :            : 
    2750                 :          1 :         if (free_space > tp->rcv_ssthresh)
    2751                 :          1 :                 free_space = tp->rcv_ssthresh;
    2752                 :            : 
    2753                 :            :         /* Don't do rounding if we are using window scaling, since the
    2754                 :            :          * scaled window will not line up with the MSS boundary anyway.
    2755                 :            :          */
    2756                 :          1 :         if (tp->rx_opt.rcv_wscale) {
    2757                 :            :                 window = free_space;
    2758                 :            : 
    2759                 :            :                 /* Advertise enough space so that it won't get scaled away.
    2760                 :            :                  * Import case: prevent zero window announcement if
    2761                 :            :                  * 1<<rcv_wscale > mss.
    2762                 :            :                  */
    2763                 :          0 :                 window = ALIGN(window, (1 << tp->rx_opt.rcv_wscale));
    2764                 :            :         } else {
    2765                 :          1 :                 window = tp->rcv_wnd;
    2766                 :            :                 /* Get the largest window that is a nice multiple of mss.
    2767                 :            :                  * Window clamp already applied above.
    2768                 :            :                  * If our current window offering is within 1 mss of the
    2769                 :            :                  * free space we just keep it. This prevents the divide
    2770                 :            :                  * and multiply from happening most of the time.
    2771                 :            :                  * We also don't do any window rounding when the free space
    2772                 :            :                  * is too small.
    2773                 :            :                  */
    2774                 :          1 :                 if (window <= free_space - mss || window > free_space)
    2775                 :          1 :                         window = rounddown(free_space, mss);
    2776                 :          1 :                 else if (mss == full_space &&
    2777                 :          0 :                          free_space > window + (full_space >> 1))
    2778                 :            :                         window = free_space;
    2779                 :            :         }
    2780                 :            : 
    2781                 :          1 :         return window;
    2782                 :            : }
    2783                 :            : 
    2784                 :          1 : void tcp_skb_collapse_tstamp(struct sk_buff *skb,
    2785                 :            :                              const struct sk_buff *next_skb)
    2786                 :            : {
    2787                 :          1 :         if (unlikely(tcp_has_tx_tstamp(next_skb))) {
    2788                 :            :                 const struct skb_shared_info *next_shinfo =
    2789                 :            :                         skb_shinfo(next_skb);
    2790                 :            :                 struct skb_shared_info *shinfo = skb_shinfo(skb);
    2791                 :            : 
    2792                 :          0 :                 shinfo->tx_flags |= next_shinfo->tx_flags & SKBTX_ANY_TSTAMP;
    2793                 :          0 :                 shinfo->tskey = next_shinfo->tskey;
    2794                 :          0 :                 TCP_SKB_CB(skb)->txstamp_ack |=
    2795                 :          0 :                         TCP_SKB_CB(next_skb)->txstamp_ack;
    2796                 :            :         }
    2797                 :          1 : }
    2798                 :            : 
    2799                 :            : /* Collapses two adjacent SKB's during retransmission. */
    2800                 :          1 : static bool tcp_collapse_retrans(struct sock *sk, struct sk_buff *skb)
    2801                 :            : {
    2802                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2803                 :          1 :         struct sk_buff *next_skb = skb_rb_next(skb);
    2804                 :            :         int next_skb_size;
    2805                 :            : 
    2806                 :          1 :         next_skb_size = next_skb->len;
    2807                 :            : 
    2808                 :          1 :         BUG_ON(tcp_skb_pcount(skb) != 1 || tcp_skb_pcount(next_skb) != 1);
    2809                 :            : 
    2810                 :          1 :         if (next_skb_size) {
    2811                 :          1 :                 if (next_skb_size <= skb_availroom(skb))
    2812                 :          0 :                         skb_copy_bits(next_skb, 0, skb_put(skb, next_skb_size),
    2813                 :            :                                       next_skb_size);
    2814                 :          1 :                 else if (!tcp_skb_shift(skb, next_skb, 1, next_skb_size))
    2815                 :            :                         return false;
    2816                 :            :         }
    2817                 :            :         tcp_highest_sack_replace(sk, next_skb, skb);
    2818                 :            : 
    2819                 :            :         /* Update sequence range on original skb. */
    2820                 :          1 :         TCP_SKB_CB(skb)->end_seq = TCP_SKB_CB(next_skb)->end_seq;
    2821                 :            : 
    2822                 :            :         /* Merge over control information. This moves PSH/FIN etc. over */
    2823                 :          1 :         TCP_SKB_CB(skb)->tcp_flags |= TCP_SKB_CB(next_skb)->tcp_flags;
    2824                 :            : 
    2825                 :            :         /* All done, get rid of second SKB and account for it so
    2826                 :            :          * packet counting does not break.
    2827                 :            :          */
    2828                 :          1 :         TCP_SKB_CB(skb)->sacked |= TCP_SKB_CB(next_skb)->sacked & TCPCB_EVER_RETRANS;
    2829                 :          1 :         TCP_SKB_CB(skb)->eor = TCP_SKB_CB(next_skb)->eor;
    2830                 :            : 
    2831                 :            :         /* changed transmit queue under us so clear hints */
    2832                 :            :         tcp_clear_retrans_hints_partial(tp);
    2833                 :          1 :         if (next_skb == tp->retransmit_skb_hint)
    2834                 :          0 :                 tp->retransmit_skb_hint = skb;
    2835                 :            : 
    2836                 :          1 :         tcp_adjust_pcount(sk, next_skb, tcp_skb_pcount(next_skb));
    2837                 :            : 
    2838                 :          1 :         tcp_skb_collapse_tstamp(skb, next_skb);
    2839                 :            : 
    2840                 :          1 :         tcp_rtx_queue_unlink_and_free(next_skb, sk);
    2841                 :          1 :         return true;
    2842                 :            : }
    2843                 :            : 
    2844                 :            : /* Check if coalescing SKBs is legal. */
    2845                 :          1 : static bool tcp_can_collapse(const struct sock *sk, const struct sk_buff *skb)
    2846                 :            : {
    2847                 :          1 :         if (tcp_skb_pcount(skb) > 1)
    2848                 :            :                 return false;
    2849                 :          1 :         if (skb_cloned(skb))
    2850                 :            :                 return false;
    2851                 :            :         /* Some heuristics for collapsing over SACK'd could be invented */
    2852                 :          1 :         if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_ACKED)
    2853                 :            :                 return false;
    2854                 :            : 
    2855                 :          1 :         return true;
    2856                 :            : }
    2857                 :            : 
    2858                 :            : /* Collapse packets in the retransmit queue to make to create
    2859                 :            :  * less packets on the wire. This is only done on retransmission.
    2860                 :            :  */
    2861                 :          1 : static void tcp_retrans_try_collapse(struct sock *sk, struct sk_buff *to,
    2862                 :            :                                      int space)
    2863                 :            : {
    2864                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2865                 :            :         struct sk_buff *skb = to, *tmp;
    2866                 :            :         bool first = true;
    2867                 :            : 
    2868                 :          1 :         if (!sock_net(sk)->ipv4.sysctl_tcp_retrans_collapse)
    2869                 :            :                 return;
    2870                 :          1 :         if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)
    2871                 :            :                 return;
    2872                 :            : 
    2873                 :          1 :         skb_rbtree_walk_from_safe(skb, tmp) {
    2874                 :          1 :                 if (!tcp_can_collapse(sk, skb))
    2875                 :            :                         break;
    2876                 :            : 
    2877                 :          1 :                 if (!tcp_skb_can_collapse_to(to))
    2878                 :            :                         break;
    2879                 :            : 
    2880                 :          1 :                 space -= skb->len;
    2881                 :            : 
    2882                 :          1 :                 if (first) {
    2883                 :            :                         first = false;
    2884                 :          1 :                         continue;
    2885                 :            :                 }
    2886                 :            : 
    2887                 :          1 :                 if (space < 0)
    2888                 :            :                         break;
    2889                 :            : 
    2890                 :          1 :                 if (after(TCP_SKB_CB(skb)->end_seq, tcp_wnd_end(tp)))
    2891                 :            :                         break;
    2892                 :            : 
    2893                 :          1 :                 if (!tcp_collapse_retrans(sk, to))
    2894                 :            :                         break;
    2895                 :            :         }
    2896                 :            : }
    2897                 :            : 
    2898                 :            : /* This retransmits one SKB.  Policy decisions and retransmit queue
    2899                 :            :  * state updates are done by the caller.  Returns non-zero if an
    2900                 :            :  * error occurred which prevented the send.
    2901                 :            :  */
    2902                 :          1 : int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
    2903                 :            : {
    2904                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    2905                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2906                 :            :         unsigned int cur_mss;
    2907                 :            :         int diff, len, err;
    2908                 :            : 
    2909                 :            : 
    2910                 :            :         /* Inconclusive MTU probe */
    2911                 :          1 :         if (icsk->icsk_mtup.probe_size)
    2912                 :          0 :                 icsk->icsk_mtup.probe_size = 0;
    2913                 :            : 
    2914                 :            :         /* Do not sent more than we queued. 1/4 is reserved for possible
    2915                 :            :          * copying overhead: fragmentation, tunneling, mangling etc.
    2916                 :            :          */
    2917                 :          1 :         if (refcount_read(&sk->sk_wmem_alloc) >
    2918                 :          1 :             min_t(u32, sk->sk_wmem_queued + (sk->sk_wmem_queued >> 2),
    2919                 :            :                   sk->sk_sndbuf))
    2920                 :            :                 return -EAGAIN;
    2921                 :            : 
    2922                 :          1 :         if (skb_still_in_host_queue(sk, skb))
    2923                 :            :                 return -EBUSY;
    2924                 :            : 
    2925                 :          1 :         if (before(TCP_SKB_CB(skb)->seq, tp->snd_una)) {
    2926                 :          0 :                 if (unlikely(before(TCP_SKB_CB(skb)->end_seq, tp->snd_una))) {
    2927                 :          0 :                         WARN_ON_ONCE(1);
    2928                 :            :                         return -EINVAL;
    2929                 :            :                 }
    2930                 :          0 :                 if (tcp_trim_head(sk, skb, tp->snd_una - TCP_SKB_CB(skb)->seq))
    2931                 :            :                         return -ENOMEM;
    2932                 :            :         }
    2933                 :            : 
    2934                 :          1 :         if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
    2935                 :            :                 return -EHOSTUNREACH; /* Routing failure or similar. */
    2936                 :            : 
    2937                 :          1 :         cur_mss = tcp_current_mss(sk);
    2938                 :            : 
    2939                 :            :         /* If receiver has shrunk his window, and skb is out of
    2940                 :            :          * new window, do not retransmit it. The exception is the
    2941                 :            :          * case, when window is shrunk to zero. In this case
    2942                 :            :          * our retransmit serves as a zero window probe.
    2943                 :            :          */
    2944                 :          1 :         if (!before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp)) &&
    2945                 :            :             TCP_SKB_CB(skb)->seq != tp->snd_una)
    2946                 :            :                 return -EAGAIN;
    2947                 :            : 
    2948                 :          1 :         len = cur_mss * segs;
    2949                 :          1 :         if (skb->len > len) {
    2950                 :          0 :                 if (tcp_fragment(sk, TCP_FRAG_IN_RTX_QUEUE, skb, len,
    2951                 :            :                                  cur_mss, GFP_ATOMIC))
    2952                 :            :                         return -ENOMEM; /* We'll try again later. */
    2953                 :            :         } else {
    2954                 :          1 :                 if (skb_unclone(skb, GFP_ATOMIC))
    2955                 :            :                         return -ENOMEM;
    2956                 :            : 
    2957                 :            :                 diff = tcp_skb_pcount(skb);
    2958                 :            :                 tcp_set_skb_tso_segs(skb, cur_mss);
    2959                 :          1 :                 diff -= tcp_skb_pcount(skb);
    2960                 :          1 :                 if (diff)
    2961                 :          0 :                         tcp_adjust_pcount(sk, skb, diff);
    2962                 :          1 :                 if (skb->len < cur_mss)
    2963                 :          1 :                         tcp_retrans_try_collapse(sk, skb, cur_mss);
    2964                 :            :         }
    2965                 :            : 
    2966                 :            :         /* RFC3168, section 6.1.1.1. ECN fallback */
    2967                 :          1 :         if ((TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN_ECN) == TCPHDR_SYN_ECN)
    2968                 :            :                 tcp_ecn_clear_syn(sk, skb);
    2969                 :            : 
    2970                 :            :         /* Update global and local TCP statistics. */
    2971                 :            :         segs = tcp_skb_pcount(skb);
    2972                 :          1 :         TCP_ADD_STATS(sock_net(sk), TCP_MIB_RETRANSSEGS, segs);
    2973                 :          1 :         if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)
    2974                 :          0 :                 __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
    2975                 :          1 :         tp->total_retrans += segs;
    2976                 :          1 :         tp->bytes_retrans += skb->len;
    2977                 :            : 
    2978                 :            :         /* make sure skb->data is aligned on arches that require it
    2979                 :            :          * and check if ack-trimming & collapsing extended the headroom
    2980                 :            :          * beyond what csum_start can cover.
    2981                 :            :          */
    2982                 :          1 :         if (unlikely((NET_IP_ALIGN && ((unsigned long)skb->data & 3)) ||
    2983                 :            :                      skb_headroom(skb) >= 0xFFFF)) {
    2984                 :            :                 struct sk_buff *nskb;
    2985                 :            : 
    2986                 :          0 :                 tcp_skb_tsorted_save(skb) {
    2987                 :            :                         nskb = __pskb_copy(skb, MAX_TCP_HEADER, GFP_ATOMIC);
    2988                 :          0 :                         if (nskb) {
    2989                 :          0 :                                 nskb->dev = NULL;
    2990                 :            :                                 err = tcp_transmit_skb(sk, nskb, 0, GFP_ATOMIC);
    2991                 :            :                         } else {
    2992                 :            :                                 err = -ENOBUFS;
    2993                 :            :                         }
    2994                 :          0 :                 } tcp_skb_tsorted_restore(skb);
    2995                 :            : 
    2996                 :          0 :                 if (!err) {
    2997                 :          0 :                         tcp_update_skb_after_send(sk, skb, tp->tcp_wstamp_ns);
    2998                 :          0 :                         tcp_rate_skb_sent(sk, skb);
    2999                 :            :                 }
    3000                 :            :         } else {
    3001                 :            :                 err = tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
    3002                 :            :         }
    3003                 :            : 
    3004                 :            :         /* To avoid taking spuriously low RTT samples based on a timestamp
    3005                 :            :          * for a transmit that never happened, always mark EVER_RETRANS
    3006                 :            :          */
    3007                 :          1 :         TCP_SKB_CB(skb)->sacked |= TCPCB_EVER_RETRANS;
    3008                 :            : 
    3009                 :          1 :         if (BPF_SOCK_OPS_TEST_FLAG(tp, BPF_SOCK_OPS_RETRANS_CB_FLAG))
    3010                 :          0 :                 tcp_call_bpf_3arg(sk, BPF_SOCK_OPS_RETRANS_CB,
    3011                 :            :                                   TCP_SKB_CB(skb)->seq, segs, err);
    3012                 :            : 
    3013                 :          1 :         if (likely(!err)) {
    3014                 :          1 :                 trace_tcp_retransmit_skb(sk, skb);
    3015                 :          0 :         } else if (err != -EBUSY) {
    3016                 :          0 :                 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPRETRANSFAIL, segs);
    3017                 :            :         }
    3018                 :          1 :         return err;
    3019                 :            : }
    3020                 :            : 
    3021                 :          1 : int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs)
    3022                 :            : {
    3023                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3024                 :          1 :         int err = __tcp_retransmit_skb(sk, skb, segs);
    3025                 :            : 
    3026                 :          1 :         if (err == 0) {
    3027                 :            : #if FASTRETRANS_DEBUG > 0
    3028                 :            :                 if (TCP_SKB_CB(skb)->sacked & TCPCB_SACKED_RETRANS) {
    3029                 :            :                         net_dbg_ratelimited("retrans_out leaked\n");
    3030                 :            :                 }
    3031                 :            : #endif
    3032                 :          1 :                 TCP_SKB_CB(skb)->sacked |= TCPCB_RETRANS;
    3033                 :          1 :                 tp->retrans_out += tcp_skb_pcount(skb);
    3034                 :            :         }
    3035                 :            : 
    3036                 :            :         /* Save stamp of the first (attempted) retransmit. */
    3037                 :          1 :         if (!tp->retrans_stamp)
    3038                 :          1 :                 tp->retrans_stamp = tcp_skb_timestamp(skb);
    3039                 :            : 
    3040                 :          1 :         if (tp->undo_retrans < 0)
    3041                 :          1 :                 tp->undo_retrans = 0;
    3042                 :          1 :         tp->undo_retrans += tcp_skb_pcount(skb);
    3043                 :          1 :         return err;
    3044                 :            : }
    3045                 :            : 
    3046                 :            : /* This gets called after a retransmit timeout, and the initially
    3047                 :            :  * retransmitted data is acknowledged.  It tries to continue
    3048                 :            :  * resending the rest of the retransmit queue, until either
    3049                 :            :  * we've sent it all or the congestion window limit is reached.
    3050                 :            :  */
    3051                 :          1 : void tcp_xmit_retransmit_queue(struct sock *sk)
    3052                 :            : {
    3053                 :            :         const struct inet_connection_sock *icsk = inet_csk(sk);
    3054                 :            :         struct sk_buff *skb, *rtx_head, *hole = NULL;
    3055                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3056                 :            :         u32 max_segs;
    3057                 :            :         int mib_idx;
    3058                 :            : 
    3059                 :          1 :         if (!tp->packets_out)
    3060                 :            :                 return;
    3061                 :            : 
    3062                 :            :         rtx_head = tcp_rtx_queue_head(sk);
    3063                 :          1 :         skb = tp->retransmit_skb_hint ?: rtx_head;
    3064                 :          1 :         max_segs = tcp_tso_segs(sk, tcp_current_mss(sk));
    3065                 :          1 :         skb_rbtree_walk_from(skb) {
    3066                 :            :                 __u8 sacked;
    3067                 :            :                 int segs;
    3068                 :            : 
    3069                 :          1 :                 if (tcp_pacing_check(sk))
    3070                 :            :                         break;
    3071                 :            : 
    3072                 :            :                 /* we could do better than to assign each time */
    3073                 :          1 :                 if (!hole)
    3074                 :          1 :                         tp->retransmit_skb_hint = skb;
    3075                 :            : 
    3076                 :          1 :                 segs = tp->snd_cwnd - tcp_packets_in_flight(tp);
    3077                 :          1 :                 if (segs <= 0)
    3078                 :            :                         return;
    3079                 :          0 :                 sacked = TCP_SKB_CB(skb)->sacked;
    3080                 :            :                 /* In case tcp_shift_skb_data() have aggregated large skbs,
    3081                 :            :                  * we need to make sure not sending too bigs TSO packets
    3082                 :            :                  */
    3083                 :          0 :                 segs = min_t(int, segs, max_segs);
    3084                 :            : 
    3085                 :          0 :                 if (tp->retrans_out >= tp->lost_out) {
    3086                 :            :                         break;
    3087                 :          0 :                 } else if (!(sacked & TCPCB_LOST)) {
    3088                 :          0 :                         if (!hole && !(sacked & (TCPCB_SACKED_RETRANS|TCPCB_SACKED_ACKED)))
    3089                 :            :                                 hole = skb;
    3090                 :          0 :                         continue;
    3091                 :            : 
    3092                 :            :                 } else {
    3093                 :          0 :                         if (icsk->icsk_ca_state != TCP_CA_Loss)
    3094                 :            :                                 mib_idx = LINUX_MIB_TCPFASTRETRANS;
    3095                 :            :                         else
    3096                 :            :                                 mib_idx = LINUX_MIB_TCPSLOWSTARTRETRANS;
    3097                 :            :                 }
    3098                 :            : 
    3099                 :          0 :                 if (sacked & (TCPCB_SACKED_ACKED|TCPCB_SACKED_RETRANS))
    3100                 :          0 :                         continue;
    3101                 :            : 
    3102                 :          0 :                 if (tcp_small_queue_check(sk, skb, 1))
    3103                 :            :                         return;
    3104                 :            : 
    3105                 :          0 :                 if (tcp_retransmit_skb(sk, skb, segs))
    3106                 :            :                         return;
    3107                 :            : 
    3108                 :          0 :                 NET_ADD_STATS(sock_net(sk), mib_idx, tcp_skb_pcount(skb));
    3109                 :            : 
    3110                 :          0 :                 if (tcp_in_cwnd_reduction(sk))
    3111                 :          0 :                         tp->prr_out += tcp_skb_pcount(skb);
    3112                 :            : 
    3113                 :          0 :                 if (skb == rtx_head &&
    3114                 :          0 :                     icsk->icsk_pending != ICSK_TIME_REO_TIMEOUT)
    3115                 :          0 :                         tcp_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
    3116                 :          0 :                                              inet_csk(sk)->icsk_rto,
    3117                 :            :                                              TCP_RTO_MAX,
    3118                 :            :                                              skb);
    3119                 :            :         }
    3120                 :            : }
    3121                 :            : 
    3122                 :            : /* We allow to exceed memory limits for FIN packets to expedite
    3123                 :            :  * connection tear down and (memory) recovery.
    3124                 :            :  * Otherwise tcp_send_fin() could be tempted to either delay FIN
    3125                 :            :  * or even be forced to close flow without any FIN.
    3126                 :            :  * In general, we want to allow one skb per socket to avoid hangs
    3127                 :            :  * with edge trigger epoll()
    3128                 :            :  */
    3129                 :          1 : void sk_forced_mem_schedule(struct sock *sk, int size)
    3130                 :            : {
    3131                 :            :         int amt;
    3132                 :            : 
    3133                 :          1 :         if (size <= sk->sk_forward_alloc)
    3134                 :          1 :                 return;
    3135                 :            :         amt = sk_mem_pages(size);
    3136                 :          1 :         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
    3137                 :          1 :         sk_memory_allocated_add(sk, amt);
    3138                 :            : 
    3139                 :          1 :         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
    3140                 :          0 :                 mem_cgroup_charge_skmem(sk->sk_memcg, amt);
    3141                 :            : }
    3142                 :            : 
    3143                 :            : /* Send a FIN. The caller locks the socket for us.
    3144                 :            :  * We should try to send a FIN packet really hard, but eventually give up.
    3145                 :            :  */
    3146                 :          1 : void tcp_send_fin(struct sock *sk)
    3147                 :            : {
    3148                 :            :         struct sk_buff *skb, *tskb = tcp_write_queue_tail(sk);
    3149                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3150                 :            : 
    3151                 :            :         /* Optimization, tack on the FIN if we have one skb in write queue and
    3152                 :            :          * this skb was not yet sent, or we are under memory pressure.
    3153                 :            :          * Note: in the latter case, FIN packet will be sent after a timeout,
    3154                 :            :          * as TCP stack thinks it has already been transmitted.
    3155                 :            :          */
    3156                 :          1 :         if (!tskb && tcp_under_memory_pressure(sk))
    3157                 :          0 :                 tskb = skb_rb_last(&sk->tcp_rtx_queue);
    3158                 :            : 
    3159                 :          1 :         if (tskb) {
    3160                 :          0 :                 TCP_SKB_CB(tskb)->tcp_flags |= TCPHDR_FIN;
    3161                 :          0 :                 TCP_SKB_CB(tskb)->end_seq++;
    3162                 :          0 :                 tp->write_seq++;
    3163                 :          0 :                 if (tcp_write_queue_empty(sk)) {
    3164                 :            :                         /* This means tskb was already sent.
    3165                 :            :                          * Pretend we included the FIN on previous transmit.
    3166                 :            :                          * We need to set tp->snd_nxt to the value it would have
    3167                 :            :                          * if FIN had been sent. This is because retransmit path
    3168                 :            :                          * does not change tp->snd_nxt.
    3169                 :            :                          */
    3170                 :          0 :                         WRITE_ONCE(tp->snd_nxt, tp->snd_nxt + 1);
    3171                 :          0 :                         return;
    3172                 :            :                 }
    3173                 :            :         } else {
    3174                 :          1 :                 skb = alloc_skb_fclone(MAX_TCP_HEADER, sk->sk_allocation);
    3175                 :          1 :                 if (unlikely(!skb))
    3176                 :            :                         return;
    3177                 :            : 
    3178                 :          1 :                 INIT_LIST_HEAD(&skb->tcp_tsorted_anchor);
    3179                 :            :                 skb_reserve(skb, MAX_TCP_HEADER);
    3180                 :          1 :                 sk_forced_mem_schedule(sk, skb->truesize);
    3181                 :            :                 /* FIN eats a sequence byte, write_seq advanced by tcp_queue_skb(). */
    3182                 :          1 :                 tcp_init_nondata_skb(skb, tp->write_seq,
    3183                 :            :                                      TCPHDR_ACK | TCPHDR_FIN);
    3184                 :          1 :                 tcp_queue_skb(sk, skb);
    3185                 :            :         }
    3186                 :          1 :         __tcp_push_pending_frames(sk, tcp_current_mss(sk), TCP_NAGLE_OFF);
    3187                 :            : }
    3188                 :            : 
    3189                 :            : /* We get here when a process closes a file descriptor (either due to
    3190                 :            :  * an explicit close() or as a byproduct of exit()'ing) and there
    3191                 :            :  * was unread data in the receive queue.  This behavior is recommended
    3192                 :            :  * by RFC 2525, section 2.17.  -DaveM
    3193                 :            :  */
    3194                 :          1 : void tcp_send_active_reset(struct sock *sk, gfp_t priority)
    3195                 :            : {
    3196                 :            :         struct sk_buff *skb;
    3197                 :            : 
    3198                 :          1 :         TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTRSTS);
    3199                 :            : 
    3200                 :            :         /* NOTE: No TCP options attached and we never retransmit this. */
    3201                 :            :         skb = alloc_skb(MAX_TCP_HEADER, priority);
    3202                 :          1 :         if (!skb) {
    3203                 :          0 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED);
    3204                 :          1 :                 return;
    3205                 :            :         }
    3206                 :            : 
    3207                 :            :         /* Reserve space for headers and prepare control bits. */
    3208                 :            :         skb_reserve(skb, MAX_TCP_HEADER);
    3209                 :            :         tcp_init_nondata_skb(skb, tcp_acceptable_seq(sk),
    3210                 :            :                              TCPHDR_ACK | TCPHDR_RST);
    3211                 :          1 :         tcp_mstamp_refresh(tcp_sk(sk));
    3212                 :            :         /* Send it off. */
    3213                 :          1 :         if (tcp_transmit_skb(sk, skb, 0, priority))
    3214                 :          0 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTFAILED);
    3215                 :            : 
    3216                 :            :         /* skb of trace_tcp_send_reset() keeps the skb that caused RST,
    3217                 :            :          * skb here is different to the troublesome skb, so use NULL
    3218                 :            :          */
    3219                 :          1 :         trace_tcp_send_reset(sk, NULL);
    3220                 :            : }
    3221                 :            : 
    3222                 :            : /* Send a crossed SYN-ACK during socket establishment.
    3223                 :            :  * WARNING: This routine must only be called when we have already sent
    3224                 :            :  * a SYN packet that crossed the incoming SYN that caused this routine
    3225                 :            :  * to get called. If this assumption fails then the initial rcv_wnd
    3226                 :            :  * and rcv_wscale values will not be correct.
    3227                 :            :  */
    3228                 :          0 : int tcp_send_synack(struct sock *sk)
    3229                 :            : {
    3230                 :            :         struct sk_buff *skb;
    3231                 :            : 
    3232                 :            :         skb = tcp_rtx_queue_head(sk);
    3233                 :          0 :         if (!skb || !(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
    3234                 :          0 :                 pr_err("%s: wrong queue state\n", __func__);
    3235                 :          0 :                 return -EFAULT;
    3236                 :            :         }
    3237                 :          0 :         if (!(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_ACK)) {
    3238                 :          0 :                 if (skb_cloned(skb)) {
    3239                 :            :                         struct sk_buff *nskb;
    3240                 :            : 
    3241                 :          0 :                         tcp_skb_tsorted_save(skb) {
    3242                 :          0 :                                 nskb = skb_copy(skb, GFP_ATOMIC);
    3243                 :          0 :                         } tcp_skb_tsorted_restore(skb);
    3244                 :          0 :                         if (!nskb)
    3245                 :            :                                 return -ENOMEM;
    3246                 :          0 :                         INIT_LIST_HEAD(&nskb->tcp_tsorted_anchor);
    3247                 :            :                         tcp_highest_sack_replace(sk, skb, nskb);
    3248                 :          0 :                         tcp_rtx_queue_unlink_and_free(skb, sk);
    3249                 :            :                         __skb_header_release(nskb);
    3250                 :          0 :                         tcp_rbtree_insert(&sk->tcp_rtx_queue, nskb);
    3251                 :          0 :                         sk_wmem_queued_add(sk, nskb->truesize);
    3252                 :          0 :                         sk_mem_charge(sk, nskb->truesize);
    3253                 :            :                         skb = nskb;
    3254                 :            :                 }
    3255                 :            : 
    3256                 :          0 :                 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_ACK;
    3257                 :          0 :                 tcp_ecn_send_synack(sk, skb);
    3258                 :            :         }
    3259                 :          0 :         return tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
    3260                 :            : }
    3261                 :            : 
    3262                 :            : /**
    3263                 :            :  * tcp_make_synack - Prepare a SYN-ACK.
    3264                 :            :  * sk: listener socket
    3265                 :            :  * dst: dst entry attached to the SYNACK
    3266                 :            :  * req: request_sock pointer
    3267                 :            :  *
    3268                 :            :  * Allocate one skb and build a SYNACK packet.
    3269                 :            :  * @dst is consumed : Caller should not use it again.
    3270                 :            :  */
    3271                 :          0 : struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,
    3272                 :            :                                 struct request_sock *req,
    3273                 :            :                                 struct tcp_fastopen_cookie *foc,
    3274                 :            :                                 enum tcp_synack_type synack_type)
    3275                 :            : {
    3276                 :            :         struct inet_request_sock *ireq = inet_rsk(req);
    3277                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
    3278                 :            :         struct tcp_md5sig_key *md5 = NULL;
    3279                 :            :         struct tcp_out_options opts;
    3280                 :            :         struct sk_buff *skb;
    3281                 :            :         int tcp_header_size;
    3282                 :            :         struct tcphdr *th;
    3283                 :            :         int mss;
    3284                 :            :         u64 now;
    3285                 :            : 
    3286                 :            :         skb = alloc_skb(MAX_TCP_HEADER, GFP_ATOMIC);
    3287                 :          0 :         if (unlikely(!skb)) {
    3288                 :          0 :                 dst_release(dst);
    3289                 :          0 :                 return NULL;
    3290                 :            :         }
    3291                 :            :         /* Reserve space for headers. */
    3292                 :            :         skb_reserve(skb, MAX_TCP_HEADER);
    3293                 :            : 
    3294                 :          0 :         switch (synack_type) {
    3295                 :            :         case TCP_SYNACK_NORMAL:
    3296                 :          0 :                 skb_set_owner_w(skb, req_to_sk(req));
    3297                 :          0 :                 break;
    3298                 :            :         case TCP_SYNACK_COOKIE:
    3299                 :            :                 /* Under synflood, we do not attach skb to a socket,
    3300                 :            :                  * to avoid false sharing.
    3301                 :            :                  */
    3302                 :            :                 break;
    3303                 :            :         case TCP_SYNACK_FASTOPEN:
    3304                 :            :                 /* sk is a const pointer, because we want to express multiple
    3305                 :            :                  * cpu might call us concurrently.
    3306                 :            :                  * sk->sk_wmem_alloc in an atomic, we can promote to rw.
    3307                 :            :                  */
    3308                 :          0 :                 skb_set_owner_w(skb, (struct sock *)sk);
    3309                 :          0 :                 break;
    3310                 :            :         }
    3311                 :            :         skb_dst_set(skb, dst);
    3312                 :            : 
    3313                 :          0 :         mss = tcp_mss_clamp(tp, dst_metric_advmss(dst));
    3314                 :            : 
    3315                 :          0 :         memset(&opts, 0, sizeof(opts));
    3316                 :            :         now = tcp_clock_ns();
    3317                 :            : #ifdef CONFIG_SYN_COOKIES
    3318                 :          0 :         if (unlikely(req->cookie_ts))
    3319                 :          0 :                 skb->skb_mstamp_ns = cookie_init_timestamp(req);
    3320                 :            :         else
    3321                 :            : #endif
    3322                 :            :         {
    3323                 :          0 :                 skb->skb_mstamp_ns = now;
    3324                 :          0 :                 if (!tcp_rsk(req)->snt_synack) /* Timestamp first SYNACK */
    3325                 :          0 :                         tcp_rsk(req)->snt_synack = tcp_skb_timestamp_us(skb);
    3326                 :            :         }
    3327                 :            : 
    3328                 :            : #ifdef CONFIG_TCP_MD5SIG
    3329                 :            :         rcu_read_lock();
    3330                 :            :         md5 = tcp_rsk(req)->af_specific->req_md5_lookup(sk, req_to_sk(req));
    3331                 :            : #endif
    3332                 :          0 :         skb_set_hash(skb, tcp_rsk(req)->txhash, PKT_HASH_TYPE_L4);
    3333                 :          0 :         tcp_header_size = tcp_synack_options(sk, req, mss, skb, &opts, md5,
    3334                 :          0 :                                              foc, synack_type) + sizeof(*th);
    3335                 :            : 
    3336                 :          0 :         skb_push(skb, tcp_header_size);
    3337                 :            :         skb_reset_transport_header(skb);
    3338                 :            : 
    3339                 :            :         th = (struct tcphdr *)skb->data;
    3340                 :          0 :         memset(th, 0, sizeof(struct tcphdr));
    3341                 :          0 :         th->syn = 1;
    3342                 :          0 :         th->ack = 1;
    3343                 :            :         tcp_ecn_make_synack(req, th);
    3344                 :          0 :         th->source = htons(ireq->ir_num);
    3345                 :          0 :         th->dest = ireq->ir_rmt_port;
    3346                 :          0 :         skb->mark = ireq->ir_mark;
    3347                 :          0 :         skb->ip_summed = CHECKSUM_PARTIAL;
    3348                 :          0 :         th->seq = htonl(tcp_rsk(req)->snt_isn);
    3349                 :            :         /* XXX data is queued and acked as is. No buffer/window check */
    3350                 :          0 :         th->ack_seq = htonl(tcp_rsk(req)->rcv_nxt);
    3351                 :            : 
    3352                 :            :         /* RFC1323: The window in SYN & SYN/ACK segments is never scaled. */
    3353                 :          0 :         th->window = htons(min(req->rsk_rcv_wnd, 65535U));
    3354                 :          0 :         tcp_options_write((__be32 *)(th + 1), NULL, &opts);
    3355                 :          0 :         th->doff = (tcp_header_size >> 2);
    3356                 :          0 :         __TCP_INC_STATS(sock_net(sk), TCP_MIB_OUTSEGS);
    3357                 :            : 
    3358                 :            : #ifdef CONFIG_TCP_MD5SIG
    3359                 :            :         /* Okay, we have all we need - do the md5 hash if needed */
    3360                 :            :         if (md5)
    3361                 :            :                 tcp_rsk(req)->af_specific->calc_md5_hash(opts.hash_location,
    3362                 :            :                                                md5, req_to_sk(req), skb);
    3363                 :            :         rcu_read_unlock();
    3364                 :            : #endif
    3365                 :            : 
    3366                 :          0 :         skb->skb_mstamp_ns = now;
    3367                 :            :         tcp_add_tx_delay(skb, tp);
    3368                 :            : 
    3369                 :          0 :         return skb;
    3370                 :            : }
    3371                 :            : EXPORT_SYMBOL(tcp_make_synack);
    3372                 :            : 
    3373                 :          1 : static void tcp_ca_dst_init(struct sock *sk, const struct dst_entry *dst)
    3374                 :            : {
    3375                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    3376                 :            :         const struct tcp_congestion_ops *ca;
    3377                 :          1 :         u32 ca_key = dst_metric(dst, RTAX_CC_ALGO);
    3378                 :            : 
    3379                 :          1 :         if (ca_key == TCP_CA_UNSPEC)
    3380                 :          1 :                 return;
    3381                 :            : 
    3382                 :            :         rcu_read_lock();
    3383                 :          0 :         ca = tcp_ca_find_key(ca_key);
    3384                 :          0 :         if (likely(ca && try_module_get(ca->owner))) {
    3385                 :          0 :                 module_put(icsk->icsk_ca_ops->owner);
    3386                 :          0 :                 icsk->icsk_ca_dst_locked = tcp_ca_dst_locked(dst);
    3387                 :          0 :                 icsk->icsk_ca_ops = ca;
    3388                 :            :         }
    3389                 :            :         rcu_read_unlock();
    3390                 :            : }
    3391                 :            : 
    3392                 :            : /* Do all connect socket setups that can be done AF independent. */
    3393                 :          1 : static void tcp_connect_init(struct sock *sk)
    3394                 :            : {
    3395                 :            :         const struct dst_entry *dst = __sk_dst_get(sk);
    3396                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3397                 :            :         __u8 rcv_wscale;
    3398                 :            :         u32 rcv_wnd;
    3399                 :            : 
    3400                 :            :         /* We'll fix this up when we get a response from the other end.
    3401                 :            :          * See tcp_input.c:tcp_rcv_state_process case TCP_SYN_SENT.
    3402                 :            :          */
    3403                 :          1 :         tp->tcp_header_len = sizeof(struct tcphdr);
    3404                 :          1 :         if (sock_net(sk)->ipv4.sysctl_tcp_timestamps)
    3405                 :          1 :                 tp->tcp_header_len += TCPOLEN_TSTAMP_ALIGNED;
    3406                 :            : 
    3407                 :            : #ifdef CONFIG_TCP_MD5SIG
    3408                 :            :         if (tp->af_specific->md5_lookup(sk, sk))
    3409                 :            :                 tp->tcp_header_len += TCPOLEN_MD5SIG_ALIGNED;
    3410                 :            : #endif
    3411                 :            : 
    3412                 :            :         /* If user gave his TCP_MAXSEG, record it to clamp */
    3413                 :          1 :         if (tp->rx_opt.user_mss)
    3414                 :          0 :                 tp->rx_opt.mss_clamp = tp->rx_opt.user_mss;
    3415                 :          1 :         tp->max_window = 0;
    3416                 :          1 :         tcp_mtup_init(sk);
    3417                 :          1 :         tcp_sync_mss(sk, dst_mtu(dst));
    3418                 :            : 
    3419                 :          1 :         tcp_ca_dst_init(sk, dst);
    3420                 :            : 
    3421                 :          1 :         if (!tp->window_clamp)
    3422                 :          1 :                 tp->window_clamp = dst_metric(dst, RTAX_WINDOW);
    3423                 :          1 :         tp->advmss = tcp_mss_clamp(tp, dst_metric_advmss(dst));
    3424                 :            : 
    3425                 :          1 :         tcp_initialize_rcv_mss(sk);
    3426                 :            : 
    3427                 :            :         /* limit the window selection if the user enforce a smaller rx buffer */
    3428                 :          1 :         if (sk->sk_userlocks & SOCK_RCVBUF_LOCK &&
    3429                 :          0 :             (tp->window_clamp > tcp_full_space(sk) || tp->window_clamp == 0))
    3430                 :          0 :                 tp->window_clamp = tcp_full_space(sk);
    3431                 :            : 
    3432                 :            :         rcv_wnd = tcp_rwnd_init_bpf(sk);
    3433                 :          1 :         if (rcv_wnd == 0)
    3434                 :          1 :                 rcv_wnd = dst_metric(dst, RTAX_INITRWND);
    3435                 :            : 
    3436                 :          1 :         tcp_select_initial_window(sk, tcp_full_space(sk),
    3437                 :          1 :                                   tp->advmss - (tp->rx_opt.ts_recent_stamp ? tp->tcp_header_len - sizeof(struct tcphdr) : 0),
    3438                 :          1 :                                   &tp->rcv_wnd,
    3439                 :          1 :                                   &tp->window_clamp,
    3440                 :            :                                   sock_net(sk)->ipv4.sysctl_tcp_window_scaling,
    3441                 :            :                                   &rcv_wscale,
    3442                 :            :                                   rcv_wnd);
    3443                 :            : 
    3444                 :          1 :         tp->rx_opt.rcv_wscale = rcv_wscale;
    3445                 :          1 :         tp->rcv_ssthresh = tp->rcv_wnd;
    3446                 :            : 
    3447                 :          1 :         sk->sk_err = 0;
    3448                 :            :         sock_reset_flag(sk, SOCK_DONE);
    3449                 :          1 :         tp->snd_wnd = 0;
    3450                 :            :         tcp_init_wl(tp, 0);
    3451                 :          1 :         tcp_write_queue_purge(sk);
    3452                 :          1 :         tp->snd_una = tp->write_seq;
    3453                 :          1 :         tp->snd_sml = tp->write_seq;
    3454                 :          1 :         tp->snd_up = tp->write_seq;
    3455                 :            :         WRITE_ONCE(tp->snd_nxt, tp->write_seq);
    3456                 :            : 
    3457                 :          1 :         if (likely(!tp->repair))
    3458                 :          1 :                 tp->rcv_nxt = 0;
    3459                 :            :         else
    3460                 :          0 :                 tp->rcv_tstamp = tcp_jiffies32;
    3461                 :          1 :         tp->rcv_wup = tp->rcv_nxt;
    3462                 :            :         WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
    3463                 :            : 
    3464                 :          1 :         inet_csk(sk)->icsk_rto = tcp_timeout_init(sk);
    3465                 :          1 :         inet_csk(sk)->icsk_retransmits = 0;
    3466                 :          1 :         tcp_clear_retrans(tp);
    3467                 :          1 : }
    3468                 :            : 
    3469                 :          1 : static void tcp_connect_queue_skb(struct sock *sk, struct sk_buff *skb)
    3470                 :            : {
    3471                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3472                 :            :         struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
    3473                 :            : 
    3474                 :          1 :         tcb->end_seq += skb->len;
    3475                 :            :         __skb_header_release(skb);
    3476                 :          1 :         sk_wmem_queued_add(sk, skb->truesize);
    3477                 :          1 :         sk_mem_charge(sk, skb->truesize);
    3478                 :          1 :         WRITE_ONCE(tp->write_seq, tcb->end_seq);
    3479                 :          1 :         tp->packets_out += tcp_skb_pcount(skb);
    3480                 :          1 : }
    3481                 :            : 
    3482                 :            : /* Build and send a SYN with data and (cached) Fast Open cookie. However,
    3483                 :            :  * queue a data-only packet after the regular SYN, such that regular SYNs
    3484                 :            :  * are retransmitted on timeouts. Also if the remote SYN-ACK acknowledges
    3485                 :            :  * only the SYN sequence, the data are retransmitted in the first ACK.
    3486                 :            :  * If cookie is not cached or other error occurs, falls back to send a
    3487                 :            :  * regular SYN with Fast Open cookie request option.
    3488                 :            :  */
    3489                 :          0 : static int tcp_send_syn_data(struct sock *sk, struct sk_buff *syn)
    3490                 :            : {
    3491                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3492                 :          0 :         struct tcp_fastopen_request *fo = tp->fastopen_req;
    3493                 :            :         int space, err = 0;
    3494                 :            :         struct sk_buff *syn_data;
    3495                 :            : 
    3496                 :          0 :         tp->rx_opt.mss_clamp = tp->advmss;  /* If MSS is not cached */
    3497                 :          0 :         if (!tcp_fastopen_cookie_check(sk, &tp->rx_opt.mss_clamp, &fo->cookie))
    3498                 :            :                 goto fallback;
    3499                 :            : 
    3500                 :            :         /* MSS for SYN-data is based on cached MSS and bounded by PMTU and
    3501                 :            :          * user-MSS. Reserve maximum option space for middleboxes that add
    3502                 :            :          * private TCP options. The cost is reduced data space in SYN :(
    3503                 :            :          */
    3504                 :          0 :         tp->rx_opt.mss_clamp = tcp_mss_clamp(tp, tp->rx_opt.mss_clamp);
    3505                 :            : 
    3506                 :          0 :         space = __tcp_mtu_to_mss(sk, inet_csk(sk)->icsk_pmtu_cookie) -
    3507                 :            :                 MAX_TCP_OPTION_SPACE;
    3508                 :            : 
    3509                 :          0 :         space = min_t(size_t, space, fo->size);
    3510                 :            : 
    3511                 :            :         /* limit to order-0 allocations */
    3512                 :          0 :         space = min_t(size_t, space, SKB_MAX_HEAD(MAX_TCP_HEADER));
    3513                 :            : 
    3514                 :          0 :         syn_data = sk_stream_alloc_skb(sk, space, sk->sk_allocation, false);
    3515                 :          0 :         if (!syn_data)
    3516                 :            :                 goto fallback;
    3517                 :          0 :         syn_data->ip_summed = CHECKSUM_PARTIAL;
    3518                 :          0 :         memcpy(syn_data->cb, syn->cb, sizeof(syn->cb));
    3519                 :          0 :         if (space) {
    3520                 :          0 :                 int copied = copy_from_iter(skb_put(syn_data, space), space,
    3521                 :          0 :                                             &fo->data->msg_iter);
    3522                 :          0 :                 if (unlikely(!copied)) {
    3523                 :            :                         tcp_skb_tsorted_anchor_cleanup(syn_data);
    3524                 :          0 :                         kfree_skb(syn_data);
    3525                 :          0 :                         goto fallback;
    3526                 :            :                 }
    3527                 :          0 :                 if (copied != space) {
    3528                 :          0 :                         skb_trim(syn_data, copied);
    3529                 :            :                         space = copied;
    3530                 :            :                 }
    3531                 :          0 :                 skb_zcopy_set(syn_data, fo->uarg, NULL);
    3532                 :            :         }
    3533                 :            :         /* No more data pending in inet_wait_for_connect() */
    3534                 :          0 :         if (space == fo->size)
    3535                 :          0 :                 fo->data = NULL;
    3536                 :          0 :         fo->copied = space;
    3537                 :            : 
    3538                 :          0 :         tcp_connect_queue_skb(sk, syn_data);
    3539                 :          0 :         if (syn_data->len)
    3540                 :            :                 tcp_chrono_start(sk, TCP_CHRONO_BUSY);
    3541                 :            : 
    3542                 :          0 :         err = tcp_transmit_skb(sk, syn_data, 1, sk->sk_allocation);
    3543                 :            : 
    3544                 :          0 :         syn->skb_mstamp_ns = syn_data->skb_mstamp_ns;
    3545                 :            : 
    3546                 :            :         /* Now full SYN+DATA was cloned and sent (or not),
    3547                 :            :          * remove the SYN from the original skb (syn_data)
    3548                 :            :          * we keep in write queue in case of a retransmit, as we
    3549                 :            :          * also have the SYN packet (with no data) in the same queue.
    3550                 :            :          */
    3551                 :          0 :         TCP_SKB_CB(syn_data)->seq++;
    3552                 :          0 :         TCP_SKB_CB(syn_data)->tcp_flags = TCPHDR_ACK | TCPHDR_PSH;
    3553                 :          0 :         if (!err) {
    3554                 :          0 :                 tp->syn_data = (fo->copied > 0);
    3555                 :          0 :                 tcp_rbtree_insert(&sk->tcp_rtx_queue, syn_data);
    3556                 :          0 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPORIGDATASENT);
    3557                 :            :                 goto done;
    3558                 :            :         }
    3559                 :            : 
    3560                 :            :         /* data was not sent, put it in write_queue */
    3561                 :          0 :         __skb_queue_tail(&sk->sk_write_queue, syn_data);
    3562                 :          0 :         tp->packets_out -= tcp_skb_pcount(syn_data);
    3563                 :            : 
    3564                 :            : fallback:
    3565                 :            :         /* Send a regular SYN with Fast Open cookie request option */
    3566                 :          0 :         if (fo->cookie.len > 0)
    3567                 :          0 :                 fo->cookie.len = 0;
    3568                 :          0 :         err = tcp_transmit_skb(sk, syn, 1, sk->sk_allocation);
    3569                 :          0 :         if (err)
    3570                 :          0 :                 tp->syn_fastopen = 0;
    3571                 :            : done:
    3572                 :          0 :         fo->cookie.len = -1;  /* Exclude Fast Open option for SYN retries */
    3573                 :          0 :         return err;
    3574                 :            : }
    3575                 :            : 
    3576                 :            : /* Build a SYN and send it off. */
    3577                 :          1 : int tcp_connect(struct sock *sk)
    3578                 :            : {
    3579                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3580                 :            :         struct sk_buff *buff;
    3581                 :            :         int err;
    3582                 :            : 
    3583                 :          1 :         tcp_call_bpf(sk, BPF_SOCK_OPS_TCP_CONNECT_CB, 0, NULL);
    3584                 :            : 
    3585                 :          1 :         if (inet_csk(sk)->icsk_af_ops->rebuild_header(sk))
    3586                 :            :                 return -EHOSTUNREACH; /* Routing failure or similar. */
    3587                 :            : 
    3588                 :          1 :         tcp_connect_init(sk);
    3589                 :            : 
    3590                 :          1 :         if (unlikely(tp->repair)) {
    3591                 :          0 :                 tcp_finish_connect(sk, NULL);
    3592                 :          0 :                 return 0;
    3593                 :            :         }
    3594                 :            : 
    3595                 :          1 :         buff = sk_stream_alloc_skb(sk, 0, sk->sk_allocation, true);
    3596                 :          1 :         if (unlikely(!buff))
    3597                 :            :                 return -ENOBUFS;
    3598                 :            : 
    3599                 :          1 :         tcp_init_nondata_skb(buff, tp->write_seq++, TCPHDR_SYN);
    3600                 :          1 :         tcp_mstamp_refresh(tp);
    3601                 :          1 :         tp->retrans_stamp = tcp_time_stamp(tp);
    3602                 :          1 :         tcp_connect_queue_skb(sk, buff);
    3603                 :          1 :         tcp_ecn_send_syn(sk, buff);
    3604                 :          1 :         tcp_rbtree_insert(&sk->tcp_rtx_queue, buff);
    3605                 :            : 
    3606                 :            :         /* Send off SYN; include data in Fast Open. */
    3607                 :          1 :         err = tp->fastopen_req ? tcp_send_syn_data(sk, buff) :
    3608                 :          1 :               tcp_transmit_skb(sk, buff, 1, sk->sk_allocation);
    3609                 :          1 :         if (err == -ECONNREFUSED)
    3610                 :            :                 return err;
    3611                 :            : 
    3612                 :            :         /* We change tp->snd_nxt after the tcp_transmit_skb() call
    3613                 :            :          * in order to make this packet get counted in tcpOutSegs.
    3614                 :            :          */
    3615                 :          1 :         WRITE_ONCE(tp->snd_nxt, tp->write_seq);
    3616                 :          1 :         tp->pushed_seq = tp->write_seq;
    3617                 :            :         buff = tcp_send_head(sk);
    3618                 :          1 :         if (unlikely(buff)) {
    3619                 :          0 :                 WRITE_ONCE(tp->snd_nxt, TCP_SKB_CB(buff)->seq);
    3620                 :          0 :                 tp->pushed_seq       = TCP_SKB_CB(buff)->seq;
    3621                 :            :         }
    3622                 :          1 :         TCP_INC_STATS(sock_net(sk), TCP_MIB_ACTIVEOPENS);
    3623                 :            : 
    3624                 :            :         /* Timer for repeating the SYN until an answer. */
    3625                 :          1 :         inet_csk_reset_xmit_timer(sk, ICSK_TIME_RETRANS,
    3626                 :          1 :                                   inet_csk(sk)->icsk_rto, TCP_RTO_MAX);
    3627                 :          1 :         return 0;
    3628                 :            : }
    3629                 :            : EXPORT_SYMBOL(tcp_connect);
    3630                 :            : 
    3631                 :            : /* Send out a delayed ack, the caller does the policy checking
    3632                 :            :  * to see if we should even be here.  See tcp_input.c:tcp_ack_snd_check()
    3633                 :            :  * for details.
    3634                 :            :  */
    3635                 :          1 : void tcp_send_delayed_ack(struct sock *sk)
    3636                 :            : {
    3637                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    3638                 :          1 :         int ato = icsk->icsk_ack.ato;
    3639                 :            :         unsigned long timeout;
    3640                 :            : 
    3641                 :          1 :         if (ato > TCP_DELACK_MIN) {
    3642                 :            :                 const struct tcp_sock *tp = tcp_sk(sk);
    3643                 :            :                 int max_ato = HZ / 2;
    3644                 :            : 
    3645                 :          1 :                 if (inet_csk_in_pingpong_mode(sk) ||
    3646                 :          1 :                     (icsk->icsk_ack.pending & ICSK_ACK_PUSHED))
    3647                 :            :                         max_ato = TCP_DELACK_MAX;
    3648                 :            : 
    3649                 :            :                 /* Slow path, intersegment interval is "high". */
    3650                 :            : 
    3651                 :            :                 /* If some rtt estimate is known, use it to bound delayed ack.
    3652                 :            :                  * Do not use inet_csk(sk)->icsk_rto here, use results of rtt measurements
    3653                 :            :                  * directly.
    3654                 :            :                  */
    3655                 :          1 :                 if (tp->srtt_us) {
    3656                 :          1 :                         int rtt = max_t(int, usecs_to_jiffies(tp->srtt_us >> 3),
    3657                 :            :                                         TCP_DELACK_MIN);
    3658                 :            : 
    3659                 :          1 :                         if (rtt < max_ato)
    3660                 :            :                                 max_ato = rtt;
    3661                 :            :                 }
    3662                 :            : 
    3663                 :          1 :                 ato = min(ato, max_ato);
    3664                 :            :         }
    3665                 :            : 
    3666                 :            :         /* Stay within the limit we were given */
    3667                 :          1 :         timeout = jiffies + ato;
    3668                 :            : 
    3669                 :            :         /* Use new timeout only if there wasn't a older one earlier. */
    3670                 :          1 :         if (icsk->icsk_ack.pending & ICSK_ACK_TIMER) {
    3671                 :            :                 /* If delack timer was blocked or is about to expire,
    3672                 :            :                  * send ACK now.
    3673                 :            :                  */
    3674                 :          1 :                 if (icsk->icsk_ack.blocked ||
    3675                 :          1 :                     time_before_eq(icsk->icsk_ack.timeout, jiffies + (ato >> 2))) {
    3676                 :            :                         tcp_send_ack(sk);
    3677                 :          1 :                         return;
    3678                 :            :                 }
    3679                 :            : 
    3680                 :          1 :                 if (!time_before(timeout, icsk->icsk_ack.timeout))
    3681                 :            :                         timeout = icsk->icsk_ack.timeout;
    3682                 :            :         }
    3683                 :          1 :         icsk->icsk_ack.pending |= ICSK_ACK_SCHED | ICSK_ACK_TIMER;
    3684                 :          1 :         icsk->icsk_ack.timeout = timeout;
    3685                 :          1 :         sk_reset_timer(sk, &icsk->icsk_delack_timer, timeout);
    3686                 :            : }
    3687                 :            : 
    3688                 :            : /* This routine sends an ack and also updates the window. */
    3689                 :          1 : void __tcp_send_ack(struct sock *sk, u32 rcv_nxt)
    3690                 :            : {
    3691                 :            :         struct sk_buff *buff;
    3692                 :            : 
    3693                 :            :         /* If we have been reset, we may not send again. */
    3694                 :          1 :         if (sk->sk_state == TCP_CLOSE)
    3695                 :            :                 return;
    3696                 :            : 
    3697                 :            :         /* We are not putting this on the write queue, so
    3698                 :            :          * tcp_transmit_skb() will set the ownership to this
    3699                 :            :          * sock.
    3700                 :            :          */
    3701                 :            :         buff = alloc_skb(MAX_TCP_HEADER,
    3702                 :            :                          sk_gfp_mask(sk, GFP_ATOMIC | __GFP_NOWARN));
    3703                 :          1 :         if (unlikely(!buff)) {
    3704                 :            :                 inet_csk_schedule_ack(sk);
    3705                 :          0 :                 inet_csk(sk)->icsk_ack.ato = TCP_ATO_MIN;
    3706                 :          0 :                 inet_csk_reset_xmit_timer(sk, ICSK_TIME_DACK,
    3707                 :            :                                           TCP_DELACK_MAX, TCP_RTO_MAX);
    3708                 :          0 :                 return;
    3709                 :            :         }
    3710                 :            : 
    3711                 :            :         /* Reserve space for headers and prepare control bits. */
    3712                 :            :         skb_reserve(buff, MAX_TCP_HEADER);
    3713                 :            :         tcp_init_nondata_skb(buff, tcp_acceptable_seq(sk), TCPHDR_ACK);
    3714                 :            : 
    3715                 :            :         /* We do not want pure acks influencing TCP Small Queues or fq/pacing
    3716                 :            :          * too much.
    3717                 :            :          * SKB_TRUESIZE(max(1 .. 66, MAX_TCP_HEADER)) is unfortunately ~784
    3718                 :            :          */
    3719                 :            :         skb_set_tcp_pure_ack(buff);
    3720                 :            : 
    3721                 :            :         /* Send it off, this clears delayed acks for us. */
    3722                 :          1 :         __tcp_transmit_skb(sk, buff, 0, (__force gfp_t)0, rcv_nxt);
    3723                 :            : }
    3724                 :            : EXPORT_SYMBOL_GPL(__tcp_send_ack);
    3725                 :            : 
    3726                 :          1 : void tcp_send_ack(struct sock *sk)
    3727                 :            : {
    3728                 :          1 :         __tcp_send_ack(sk, tcp_sk(sk)->rcv_nxt);
    3729                 :          1 : }
    3730                 :            : 
    3731                 :            : /* This routine sends a packet with an out of date sequence
    3732                 :            :  * number. It assumes the other end will try to ack it.
    3733                 :            :  *
    3734                 :            :  * Question: what should we make while urgent mode?
    3735                 :            :  * 4.4BSD forces sending single byte of data. We cannot send
    3736                 :            :  * out of window data, because we have SND.NXT==SND.MAX...
    3737                 :            :  *
    3738                 :            :  * Current solution: to send TWO zero-length segments in urgent mode:
    3739                 :            :  * one is with SEG.SEQ=SND.UNA to deliver urgent pointer, another is
    3740                 :            :  * out-of-date with SND.UNA-1 to probe window.
    3741                 :            :  */
    3742                 :          0 : static int tcp_xmit_probe_skb(struct sock *sk, int urgent, int mib)
    3743                 :            : {
    3744                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3745                 :            :         struct sk_buff *skb;
    3746                 :            : 
    3747                 :            :         /* We don't queue it, tcp_transmit_skb() sets ownership. */
    3748                 :            :         skb = alloc_skb(MAX_TCP_HEADER,
    3749                 :            :                         sk_gfp_mask(sk, GFP_ATOMIC | __GFP_NOWARN));
    3750                 :          0 :         if (!skb)
    3751                 :            :                 return -1;
    3752                 :            : 
    3753                 :            :         /* Reserve space for headers and set control bits. */
    3754                 :            :         skb_reserve(skb, MAX_TCP_HEADER);
    3755                 :            :         /* Use a previous sequence.  This should cause the other
    3756                 :            :          * end to send an ack.  Don't queue or clone SKB, just
    3757                 :            :          * send it.
    3758                 :            :          */
    3759                 :          0 :         tcp_init_nondata_skb(skb, tp->snd_una - !urgent, TCPHDR_ACK);
    3760                 :          0 :         NET_INC_STATS(sock_net(sk), mib);
    3761                 :          0 :         return tcp_transmit_skb(sk, skb, 0, (__force gfp_t)0);
    3762                 :            : }
    3763                 :            : 
    3764                 :            : /* Called from setsockopt( ... TCP_REPAIR ) */
    3765                 :          0 : void tcp_send_window_probe(struct sock *sk)
    3766                 :            : {
    3767                 :          0 :         if (sk->sk_state == TCP_ESTABLISHED) {
    3768                 :          0 :                 tcp_sk(sk)->snd_wl1 = tcp_sk(sk)->rcv_nxt - 1;
    3769                 :          0 :                 tcp_mstamp_refresh(tcp_sk(sk));
    3770                 :          0 :                 tcp_xmit_probe_skb(sk, 0, LINUX_MIB_TCPWINPROBE);
    3771                 :            :         }
    3772                 :          0 : }
    3773                 :            : 
    3774                 :            : /* Initiate keepalive or window probe from timer. */
    3775                 :          0 : int tcp_write_wakeup(struct sock *sk, int mib)
    3776                 :            : {
    3777                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3778                 :            :         struct sk_buff *skb;
    3779                 :            : 
    3780                 :          0 :         if (sk->sk_state == TCP_CLOSE)
    3781                 :            :                 return -1;
    3782                 :            : 
    3783                 :            :         skb = tcp_send_head(sk);
    3784                 :          0 :         if (skb && before(TCP_SKB_CB(skb)->seq, tcp_wnd_end(tp))) {
    3785                 :            :                 int err;
    3786                 :          0 :                 unsigned int mss = tcp_current_mss(sk);
    3787                 :          0 :                 unsigned int seg_size = tcp_wnd_end(tp) - TCP_SKB_CB(skb)->seq;
    3788                 :            : 
    3789                 :          0 :                 if (before(tp->pushed_seq, TCP_SKB_CB(skb)->end_seq))
    3790                 :          0 :                         tp->pushed_seq = TCP_SKB_CB(skb)->end_seq;
    3791                 :            : 
    3792                 :            :                 /* We are probing the opening of a window
    3793                 :            :                  * but the window size is != 0
    3794                 :            :                  * must have been a result SWS avoidance ( sender )
    3795                 :            :                  */
    3796                 :          0 :                 if (seg_size < TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq ||
    3797                 :          0 :                     skb->len > mss) {
    3798                 :          0 :                         seg_size = min(seg_size, mss);
    3799                 :          0 :                         TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
    3800                 :          0 :                         if (tcp_fragment(sk, TCP_FRAG_IN_WRITE_QUEUE,
    3801                 :            :                                          skb, seg_size, mss, GFP_ATOMIC))
    3802                 :            :                                 return -1;
    3803                 :          0 :                 } else if (!tcp_skb_pcount(skb))
    3804                 :            :                         tcp_set_skb_tso_segs(skb, mss);
    3805                 :            : 
    3806                 :          0 :                 TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
    3807                 :            :                 err = tcp_transmit_skb(sk, skb, 1, GFP_ATOMIC);
    3808                 :          0 :                 if (!err)
    3809                 :          0 :                         tcp_event_new_data_sent(sk, skb);
    3810                 :          0 :                 return err;
    3811                 :            :         } else {
    3812                 :          0 :                 if (between(tp->snd_up, tp->snd_una + 1, tp->snd_una + 0xFFFF))
    3813                 :          0 :                         tcp_xmit_probe_skb(sk, 1, mib);
    3814                 :          0 :                 return tcp_xmit_probe_skb(sk, 0, mib);
    3815                 :            :         }
    3816                 :            : }
    3817                 :            : 
    3818                 :            : /* A window probe timeout has occurred.  If window is not closed send
    3819                 :            :  * a partial packet else a zero probe.
    3820                 :            :  */
    3821                 :          0 : void tcp_send_probe0(struct sock *sk)
    3822                 :            : {
    3823                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    3824                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3825                 :            :         struct net *net = sock_net(sk);
    3826                 :            :         unsigned long timeout;
    3827                 :            :         int err;
    3828                 :            : 
    3829                 :          0 :         err = tcp_write_wakeup(sk, LINUX_MIB_TCPWINPROBE);
    3830                 :            : 
    3831                 :          0 :         if (tp->packets_out || tcp_write_queue_empty(sk)) {
    3832                 :            :                 /* Cancel probe timer, if it is not required. */
    3833                 :          0 :                 icsk->icsk_probes_out = 0;
    3834                 :          0 :                 icsk->icsk_backoff = 0;
    3835                 :          0 :                 return;
    3836                 :            :         }
    3837                 :            : 
    3838                 :          0 :         icsk->icsk_probes_out++;
    3839                 :          0 :         if (err <= 0) {
    3840                 :          0 :                 if (icsk->icsk_backoff < net->ipv4.sysctl_tcp_retries2)
    3841                 :          0 :                         icsk->icsk_backoff++;
    3842                 :            :                 timeout = tcp_probe0_when(sk, TCP_RTO_MAX);
    3843                 :            :         } else {
    3844                 :            :                 /* If packet was not sent due to local congestion,
    3845                 :            :                  * Let senders fight for local resources conservatively.
    3846                 :            :                  */
    3847                 :            :                 timeout = TCP_RESOURCE_PROBE_INTERVAL;
    3848                 :            :         }
    3849                 :          0 :         tcp_reset_xmit_timer(sk, ICSK_TIME_PROBE0, timeout, TCP_RTO_MAX, NULL);
    3850                 :            : }
    3851                 :            : 
    3852                 :          0 : int tcp_rtx_synack(const struct sock *sk, struct request_sock *req)
    3853                 :            : {
    3854                 :          0 :         const struct tcp_request_sock_ops *af_ops = tcp_rsk(req)->af_specific;
    3855                 :            :         struct flowi fl;
    3856                 :            :         int res;
    3857                 :            : 
    3858                 :          0 :         tcp_rsk(req)->txhash = net_tx_rndhash();
    3859                 :          0 :         res = af_ops->send_synack(sk, NULL, &fl, req, NULL, TCP_SYNACK_NORMAL);
    3860                 :          0 :         if (!res) {
    3861                 :          0 :                 __TCP_INC_STATS(sock_net(sk), TCP_MIB_RETRANSSEGS);
    3862                 :          0 :                 __NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPSYNRETRANS);
    3863                 :          0 :                 if (unlikely(tcp_passive_fastopen(sk)))
    3864                 :          0 :                         tcp_sk(sk)->total_retrans++;
    3865                 :          0 :                 trace_tcp_retransmit_synack(sk, req);
    3866                 :            :         }
    3867                 :          0 :         return res;
    3868                 :            : }
    3869                 :            : EXPORT_SYMBOL(tcp_rtx_synack);
    

Generated by: LCOV version 1.14