LCOV - code coverage report
Current view: top level - net/ipv4 - tcp_output.c (source / functions) Hit Total Coverage
Test: combined.info Lines: 12 1693 0.7 %
Date: 2022-04-01 14:58:12 Functions: 2 77 2.6 %
Branches: 3 1512 0.2 %

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

Generated by: LCOV version 1.14