LCOV - code coverage report
Current view: top level - include/net - tcp.h (source / functions) Hit Total Coverage
Test: combined.info Lines: 17 446 3.8 %
Date: 2022-04-01 14:58:12 Functions: 0 24 0.0 %
Branches: 0 1043 0.0 %

           Branch data     Line data    Source code
       1                 :            : /* SPDX-License-Identifier: GPL-2.0-or-later */
       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                 :            :  *              Definitions for the TCP module.
       8                 :            :  *
       9                 :            :  * Version:     @(#)tcp.h       1.0.5   05/23/93
      10                 :            :  *
      11                 :            :  * Authors:     Ross Biro
      12                 :            :  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
      13                 :            :  */
      14                 :            : #ifndef _TCP_H
      15                 :            : #define _TCP_H
      16                 :            : 
      17                 :            : #define FASTRETRANS_DEBUG 1
      18                 :            : 
      19                 :            : #include <linux/list.h>
      20                 :            : #include <linux/tcp.h>
      21                 :            : #include <linux/bug.h>
      22                 :            : #include <linux/slab.h>
      23                 :            : #include <linux/cache.h>
      24                 :            : #include <linux/percpu.h>
      25                 :            : #include <linux/skbuff.h>
      26                 :            : #include <linux/cryptohash.h>
      27                 :            : #include <linux/kref.h>
      28                 :            : #include <linux/ktime.h>
      29                 :            : 
      30                 :            : #include <net/inet_connection_sock.h>
      31                 :            : #include <net/inet_timewait_sock.h>
      32                 :            : #include <net/inet_hashtables.h>
      33                 :            : #include <net/checksum.h>
      34                 :            : #include <net/request_sock.h>
      35                 :            : #include <net/sock_reuseport.h>
      36                 :            : #include <net/sock.h>
      37                 :            : #include <net/snmp.h>
      38                 :            : #include <net/ip.h>
      39                 :            : #include <net/tcp_states.h>
      40                 :            : #include <net/inet_ecn.h>
      41                 :            : #include <net/dst.h>
      42                 :            : #include <net/mptcp.h>
      43                 :            : 
      44                 :            : #include <linux/seq_file.h>
      45                 :            : #include <linux/memcontrol.h>
      46                 :            : #include <linux/bpf-cgroup.h>
      47                 :            : #include <linux/siphash.h>
      48                 :            : 
      49                 :            : extern struct inet_hashinfo tcp_hashinfo;
      50                 :            : 
      51                 :            : extern struct percpu_counter tcp_orphan_count;
      52                 :            : void tcp_time_wait(struct sock *sk, int state, int timeo);
      53                 :            : 
      54                 :            : #define MAX_TCP_HEADER  (128 + MAX_HEADER)
      55                 :            : #define MAX_TCP_OPTION_SPACE 40
      56                 :            : #define TCP_MIN_SND_MSS         48
      57                 :            : #define TCP_MIN_GSO_SIZE        (TCP_MIN_SND_MSS - MAX_TCP_OPTION_SPACE)
      58                 :            : 
      59                 :            : /*
      60                 :            :  * Never offer a window over 32767 without using window scaling. Some
      61                 :            :  * poor stacks do signed 16bit maths!
      62                 :            :  */
      63                 :            : #define MAX_TCP_WINDOW          32767U
      64                 :            : 
      65                 :            : /* Minimal accepted MSS. It is (60+60+8) - (20+20). */
      66                 :            : #define TCP_MIN_MSS             88U
      67                 :            : 
      68                 :            : /* The initial MTU to use for probing */
      69                 :            : #define TCP_BASE_MSS            1024
      70                 :            : 
      71                 :            : /* probing interval, default to 10 minutes as per RFC4821 */
      72                 :            : #define TCP_PROBE_INTERVAL      600
      73                 :            : 
      74                 :            : /* Specify interval when tcp mtu probing will stop */
      75                 :            : #define TCP_PROBE_THRESHOLD     8
      76                 :            : 
      77                 :            : /* After receiving this amount of duplicate ACKs fast retransmit starts. */
      78                 :            : #define TCP_FASTRETRANS_THRESH 3
      79                 :            : 
      80                 :            : /* Maximal number of ACKs sent quickly to accelerate slow-start. */
      81                 :            : #define TCP_MAX_QUICKACKS       16U
      82                 :            : 
      83                 :            : /* Maximal number of window scale according to RFC1323 */
      84                 :            : #define TCP_MAX_WSCALE          14U
      85                 :            : 
      86                 :            : /* urg_data states */
      87                 :            : #define TCP_URG_VALID   0x0100
      88                 :            : #define TCP_URG_NOTYET  0x0200
      89                 :            : #define TCP_URG_READ    0x0400
      90                 :            : 
      91                 :            : #define TCP_RETR1       3       /*
      92                 :            :                                  * This is how many retries it does before it
      93                 :            :                                  * tries to figure out if the gateway is
      94                 :            :                                  * down. Minimal RFC value is 3; it corresponds
      95                 :            :                                  * to ~3sec-8min depending on RTO.
      96                 :            :                                  */
      97                 :            : 
      98                 :            : #define TCP_RETR2       15      /*
      99                 :            :                                  * This should take at least
     100                 :            :                                  * 90 minutes to time out.
     101                 :            :                                  * RFC1122 says that the limit is 100 sec.
     102                 :            :                                  * 15 is ~13-30min depending on RTO.
     103                 :            :                                  */
     104                 :            : 
     105                 :            : #define TCP_SYN_RETRIES  6      /* This is how many retries are done
     106                 :            :                                  * when active opening a connection.
     107                 :            :                                  * RFC1122 says the minimum retry MUST
     108                 :            :                                  * be at least 180secs.  Nevertheless
     109                 :            :                                  * this value is corresponding to
     110                 :            :                                  * 63secs of retransmission with the
     111                 :            :                                  * current initial RTO.
     112                 :            :                                  */
     113                 :            : 
     114                 :            : #define TCP_SYNACK_RETRIES 5    /* This is how may retries are done
     115                 :            :                                  * when passive opening a connection.
     116                 :            :                                  * This is corresponding to 31secs of
     117                 :            :                                  * retransmission with the current
     118                 :            :                                  * initial RTO.
     119                 :            :                                  */
     120                 :            : 
     121                 :            : #define TCP_TIMEWAIT_LEN (60*HZ) /* how long to wait to destroy TIME-WAIT
     122                 :            :                                   * state, about 60 seconds     */
     123                 :            : #define TCP_FIN_TIMEOUT TCP_TIMEWAIT_LEN
     124                 :            :                                  /* BSD style FIN_WAIT2 deadlock breaker.
     125                 :            :                                   * It used to be 3min, new value is 60sec,
     126                 :            :                                   * to combine FIN-WAIT-2 timeout with
     127                 :            :                                   * TIME-WAIT timer.
     128                 :            :                                   */
     129                 :            : 
     130                 :            : #define TCP_DELACK_MAX  ((unsigned)(HZ/5))      /* maximal time to delay before sending an ACK */
     131                 :            : #if HZ >= 100
     132                 :            : #define TCP_DELACK_MIN  ((unsigned)(HZ/25))     /* minimal time to delay before sending an ACK */
     133                 :            : #define TCP_ATO_MIN     ((unsigned)(HZ/25))
     134                 :            : #else
     135                 :            : #define TCP_DELACK_MIN  4U
     136                 :            : #define TCP_ATO_MIN     4U
     137                 :            : #endif
     138                 :            : #define TCP_RTO_MAX     ((unsigned)(120*HZ))
     139                 :            : #define TCP_RTO_MIN     ((unsigned)(HZ/5))
     140                 :            : #define TCP_TIMEOUT_MIN (2U) /* Min timeout for TCP timers in jiffies */
     141                 :            : #define TCP_TIMEOUT_INIT ((unsigned)(1*HZ))     /* RFC6298 2.1 initial RTO value        */
     142                 :            : #define TCP_TIMEOUT_FALLBACK ((unsigned)(3*HZ)) /* RFC 1122 initial RTO value, now
     143                 :            :                                                  * used as a fallback RTO for the
     144                 :            :                                                  * initial data transmission if no
     145                 :            :                                                  * valid RTT sample has been acquired,
     146                 :            :                                                  * most likely due to retrans in 3WHS.
     147                 :            :                                                  */
     148                 :            : 
     149                 :            : #define TCP_RESOURCE_PROBE_INTERVAL ((unsigned)(HZ/2U)) /* Maximal interval between probes
     150                 :            :                                                          * for local resources.
     151                 :            :                                                          */
     152                 :            : #define TCP_KEEPALIVE_TIME      (120*60*HZ)     /* two hours */
     153                 :            : #define TCP_KEEPALIVE_PROBES    9               /* Max of 9 keepalive probes    */
     154                 :            : #define TCP_KEEPALIVE_INTVL     (75*HZ)
     155                 :            : 
     156                 :            : #define MAX_TCP_KEEPIDLE        32767
     157                 :            : #define MAX_TCP_KEEPINTVL       32767
     158                 :            : #define MAX_TCP_KEEPCNT         127
     159                 :            : #define MAX_TCP_SYNCNT          127
     160                 :            : 
     161                 :            : #define TCP_SYNQ_INTERVAL       (HZ/5)  /* Period of SYNACK timer */
     162                 :            : 
     163                 :            : #define TCP_PAWS_24DAYS (60 * 60 * 24 * 24)
     164                 :            : #define TCP_PAWS_MSL    60              /* Per-host timestamps are invalidated
     165                 :            :                                          * after this time. It should be equal
     166                 :            :                                          * (or greater than) TCP_TIMEWAIT_LEN
     167                 :            :                                          * to provide reliability equal to one
     168                 :            :                                          * provided by timewait state.
     169                 :            :                                          */
     170                 :            : #define TCP_PAWS_WINDOW 1               /* Replay window for per-host
     171                 :            :                                          * timestamps. It must be less than
     172                 :            :                                          * minimal timewait lifetime.
     173                 :            :                                          */
     174                 :            : /*
     175                 :            :  *      TCP option
     176                 :            :  */
     177                 :            : 
     178                 :            : #define TCPOPT_NOP              1       /* Padding */
     179                 :            : #define TCPOPT_EOL              0       /* End of options */
     180                 :            : #define TCPOPT_MSS              2       /* Segment size negotiating */
     181                 :            : #define TCPOPT_WINDOW           3       /* Window scaling */
     182                 :            : #define TCPOPT_SACK_PERM        4       /* SACK Permitted */
     183                 :            : #define TCPOPT_SACK             5       /* SACK Block */
     184                 :            : #define TCPOPT_TIMESTAMP        8       /* Better RTT estimations/PAWS */
     185                 :            : #define TCPOPT_MD5SIG           19      /* MD5 Signature (RFC2385) */
     186                 :            : #define TCPOPT_MPTCP            30      /* Multipath TCP (RFC6824) */
     187                 :            : #define TCPOPT_FASTOPEN         34      /* Fast open (RFC7413) */
     188                 :            : #define TCPOPT_EXP              254     /* Experimental */
     189                 :            : /* Magic number to be after the option value for sharing TCP
     190                 :            :  * experimental options. See draft-ietf-tcpm-experimental-options-00.txt
     191                 :            :  */
     192                 :            : #define TCPOPT_FASTOPEN_MAGIC   0xF989
     193                 :            : #define TCPOPT_SMC_MAGIC        0xE2D4C3D9
     194                 :            : 
     195                 :            : /*
     196                 :            :  *     TCP option lengths
     197                 :            :  */
     198                 :            : 
     199                 :            : #define TCPOLEN_MSS            4
     200                 :            : #define TCPOLEN_WINDOW         3
     201                 :            : #define TCPOLEN_SACK_PERM      2
     202                 :            : #define TCPOLEN_TIMESTAMP      10
     203                 :            : #define TCPOLEN_MD5SIG         18
     204                 :            : #define TCPOLEN_FASTOPEN_BASE  2
     205                 :            : #define TCPOLEN_EXP_FASTOPEN_BASE  4
     206                 :            : #define TCPOLEN_EXP_SMC_BASE   6
     207                 :            : 
     208                 :            : /* But this is what stacks really send out. */
     209                 :            : #define TCPOLEN_TSTAMP_ALIGNED          12
     210                 :            : #define TCPOLEN_WSCALE_ALIGNED          4
     211                 :            : #define TCPOLEN_SACKPERM_ALIGNED        4
     212                 :            : #define TCPOLEN_SACK_BASE               2
     213                 :            : #define TCPOLEN_SACK_BASE_ALIGNED       4
     214                 :            : #define TCPOLEN_SACK_PERBLOCK           8
     215                 :            : #define TCPOLEN_MD5SIG_ALIGNED          20
     216                 :            : #define TCPOLEN_MSS_ALIGNED             4
     217                 :            : #define TCPOLEN_EXP_SMC_BASE_ALIGNED    8
     218                 :            : 
     219                 :            : /* Flags in tp->nonagle */
     220                 :            : #define TCP_NAGLE_OFF           1       /* Nagle's algo is disabled */
     221                 :            : #define TCP_NAGLE_CORK          2       /* Socket is corked         */
     222                 :            : #define TCP_NAGLE_PUSH          4       /* Cork is overridden for already queued data */
     223                 :            : 
     224                 :            : /* TCP thin-stream limits */
     225                 :            : #define TCP_THIN_LINEAR_RETRIES 6       /* After 6 linear retries, do exp. backoff */
     226                 :            : 
     227                 :            : /* TCP initial congestion window as per rfc6928 */
     228                 :            : #define TCP_INIT_CWND           10
     229                 :            : 
     230                 :            : /* Bit Flags for sysctl_tcp_fastopen */
     231                 :            : #define TFO_CLIENT_ENABLE       1
     232                 :            : #define TFO_SERVER_ENABLE       2
     233                 :            : #define TFO_CLIENT_NO_COOKIE    4       /* Data in SYN w/o cookie option */
     234                 :            : 
     235                 :            : /* Accept SYN data w/o any cookie option */
     236                 :            : #define TFO_SERVER_COOKIE_NOT_REQD      0x200
     237                 :            : 
     238                 :            : /* Force enable TFO on all listeners, i.e., not requiring the
     239                 :            :  * TCP_FASTOPEN socket option.
     240                 :            :  */
     241                 :            : #define TFO_SERVER_WO_SOCKOPT1  0x400
     242                 :            : 
     243                 :            : 
     244                 :            : /* sysctl variables for tcp */
     245                 :            : extern int sysctl_tcp_max_orphans;
     246                 :            : extern long sysctl_tcp_mem[3];
     247                 :            : 
     248                 :            : #define TCP_RACK_LOSS_DETECTION  0x1 /* Use RACK to detect losses */
     249                 :            : #define TCP_RACK_STATIC_REO_WND  0x2 /* Use static RACK reo wnd */
     250                 :            : #define TCP_RACK_NO_DUPTHRESH    0x4 /* Do not use DUPACK threshold in RACK */
     251                 :            : 
     252                 :            : extern atomic_long_t tcp_memory_allocated;
     253                 :            : extern struct percpu_counter tcp_sockets_allocated;
     254                 :            : extern unsigned long tcp_memory_pressure;
     255                 :            : 
     256                 :            : /* optimized version of sk_under_memory_pressure() for TCP sockets */
     257                 :          0 : static inline bool tcp_under_memory_pressure(const struct sock *sk)
     258                 :            : {
     259                 :          0 :         if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
     260                 :            :             mem_cgroup_under_socket_pressure(sk->sk_memcg))
     261                 :            :                 return true;
     262                 :            : 
     263   [ #  #  #  #  :          0 :         return READ_ONCE(tcp_memory_pressure);
             #  #  #  # ]
     264                 :            : }
     265                 :            : /*
     266                 :            :  * The next routines deal with comparing 32 bit unsigned ints
     267                 :            :  * and worry about wraparound (automatic with unsigned arithmetic).
     268                 :            :  */
     269                 :            : 
     270                 :          0 : static inline bool before(__u32 seq1, __u32 seq2)
     271                 :            : {
     272   [ #  #  #  #  :          0 :         return (__s32)(seq1-seq2) < 0;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     273                 :            : }
     274                 :            : #define after(seq2, seq1)       before(seq1, seq2)
     275                 :            : 
     276                 :            : /* is s2<=s1<=s3 ? */
     277                 :          0 : static inline bool between(__u32 seq1, __u32 seq2, __u32 seq3)
     278                 :            : {
     279   [ #  #  #  # ]:          0 :         return seq3 - seq2 >= seq1 - seq2;
     280                 :            : }
     281                 :            : 
     282                 :          0 : static inline bool tcp_out_of_memory(struct sock *sk)
     283                 :            : {
     284   [ #  #  #  # ]:          0 :         if (sk->sk_wmem_queued > SOCK_MIN_SNDBUF &&
     285                 :            :             sk_memory_allocated(sk) > sk_prot_mem_limits(sk, 2))
     286                 :          0 :                 return true;
     287                 :            :         return false;
     288                 :            : }
     289                 :            : 
     290                 :            : void sk_forced_mem_schedule(struct sock *sk, int size);
     291                 :            : 
     292                 :          0 : static inline bool tcp_too_many_orphans(struct sock *sk, int shift)
     293                 :            : {
     294                 :          0 :         struct percpu_counter *ocp = sk->sk_prot->orphan_count;
     295                 :          0 :         int orphans = percpu_counter_read_positive(ocp);
     296                 :            : 
     297         [ #  # ]:          0 :         if (orphans << shift > sysctl_tcp_max_orphans) {
     298                 :          0 :                 orphans = percpu_counter_sum_positive(ocp);
     299         [ #  # ]:          0 :                 if (orphans << shift > sysctl_tcp_max_orphans)
     300                 :          0 :                         return true;
     301                 :            :         }
     302                 :            :         return false;
     303                 :            : }
     304                 :            : 
     305                 :            : bool tcp_check_oom(struct sock *sk, int shift);
     306                 :            : 
     307                 :            : 
     308                 :            : extern struct proto tcp_prot;
     309                 :            : 
     310                 :            : #define TCP_INC_STATS(net, field)       SNMP_INC_STATS((net)->mib.tcp_statistics, field)
     311                 :            : #define __TCP_INC_STATS(net, field)     __SNMP_INC_STATS((net)->mib.tcp_statistics, field)
     312                 :            : #define TCP_DEC_STATS(net, field)       SNMP_DEC_STATS((net)->mib.tcp_statistics, field)
     313                 :            : #define TCP_ADD_STATS(net, field, val)  SNMP_ADD_STATS((net)->mib.tcp_statistics, field, val)
     314                 :            : 
     315                 :            : void tcp_tasklet_init(void);
     316                 :            : 
     317                 :            : int tcp_v4_err(struct sk_buff *skb, u32);
     318                 :            : 
     319                 :            : void tcp_shutdown(struct sock *sk, int how);
     320                 :            : 
     321                 :            : int tcp_v4_early_demux(struct sk_buff *skb);
     322                 :            : int tcp_v4_rcv(struct sk_buff *skb);
     323                 :            : 
     324                 :            : int tcp_v4_tw_remember_stamp(struct inet_timewait_sock *tw);
     325                 :            : int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size);
     326                 :            : int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size);
     327                 :            : int tcp_sendpage(struct sock *sk, struct page *page, int offset, size_t size,
     328                 :            :                  int flags);
     329                 :            : int tcp_sendpage_locked(struct sock *sk, struct page *page, int offset,
     330                 :            :                         size_t size, int flags);
     331                 :            : ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset,
     332                 :            :                  size_t size, int flags);
     333                 :            : int tcp_send_mss(struct sock *sk, int *size_goal, int flags);
     334                 :            : void tcp_push(struct sock *sk, int flags, int mss_now, int nonagle,
     335                 :            :               int size_goal);
     336                 :            : void tcp_release_cb(struct sock *sk);
     337                 :            : void tcp_wfree(struct sk_buff *skb);
     338                 :            : void tcp_write_timer_handler(struct sock *sk);
     339                 :            : void tcp_delack_timer_handler(struct sock *sk);
     340                 :            : int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg);
     341                 :            : int tcp_rcv_state_process(struct sock *sk, struct sk_buff *skb);
     342                 :            : void tcp_rcv_established(struct sock *sk, struct sk_buff *skb);
     343                 :            : void tcp_rcv_space_adjust(struct sock *sk);
     344                 :            : int tcp_twsk_unique(struct sock *sk, struct sock *sktw, void *twp);
     345                 :            : void tcp_twsk_destructor(struct sock *sk);
     346                 :            : ssize_t tcp_splice_read(struct socket *sk, loff_t *ppos,
     347                 :            :                         struct pipe_inode_info *pipe, size_t len,
     348                 :            :                         unsigned int flags);
     349                 :            : 
     350                 :            : void tcp_enter_quickack_mode(struct sock *sk, unsigned int max_quickacks);
     351                 :          0 : static inline void tcp_dec_quickack_mode(struct sock *sk,
     352                 :            :                                          const unsigned int pkts)
     353                 :            : {
     354         [ #  # ]:          0 :         struct inet_connection_sock *icsk = inet_csk(sk);
     355                 :            : 
     356         [ #  # ]:          0 :         if (icsk->icsk_ack.quick) {
     357         [ #  # ]:          0 :                 if (pkts >= icsk->icsk_ack.quick) {
     358                 :          0 :                         icsk->icsk_ack.quick = 0;
     359                 :            :                         /* Leaving quickack mode we deflate ATO. */
     360                 :          0 :                         icsk->icsk_ack.ato   = TCP_ATO_MIN;
     361                 :            :                 } else
     362                 :          0 :                         icsk->icsk_ack.quick -= pkts;
     363                 :            :         }
     364                 :            : }
     365                 :            : 
     366                 :            : #define TCP_ECN_OK              1
     367                 :            : #define TCP_ECN_QUEUE_CWR       2
     368                 :            : #define TCP_ECN_DEMAND_CWR      4
     369                 :            : #define TCP_ECN_SEEN            8
     370                 :            : 
     371                 :            : enum tcp_tw_status {
     372                 :            :         TCP_TW_SUCCESS = 0,
     373                 :            :         TCP_TW_RST = 1,
     374                 :            :         TCP_TW_ACK = 2,
     375                 :            :         TCP_TW_SYN = 3
     376                 :            : };
     377                 :            : 
     378                 :            : 
     379                 :            : enum tcp_tw_status tcp_timewait_state_process(struct inet_timewait_sock *tw,
     380                 :            :                                               struct sk_buff *skb,
     381                 :            :                                               const struct tcphdr *th);
     382                 :            : struct sock *tcp_check_req(struct sock *sk, struct sk_buff *skb,
     383                 :            :                            struct request_sock *req, bool fastopen,
     384                 :            :                            bool *lost_race);
     385                 :            : int tcp_child_process(struct sock *parent, struct sock *child,
     386                 :            :                       struct sk_buff *skb);
     387                 :            : void tcp_enter_loss(struct sock *sk);
     388                 :            : void tcp_cwnd_reduction(struct sock *sk, int newly_acked_sacked, int flag);
     389                 :            : void tcp_clear_retrans(struct tcp_sock *tp);
     390                 :            : void tcp_update_metrics(struct sock *sk);
     391                 :            : void tcp_init_metrics(struct sock *sk);
     392                 :            : void tcp_metrics_init(void);
     393                 :            : bool tcp_peer_is_proven(struct request_sock *req, struct dst_entry *dst);
     394                 :            : void tcp_close(struct sock *sk, long timeout);
     395                 :            : void tcp_init_sock(struct sock *sk);
     396                 :            : void tcp_init_transfer(struct sock *sk, int bpf_op);
     397                 :            : __poll_t tcp_poll(struct file *file, struct socket *sock,
     398                 :            :                       struct poll_table_struct *wait);
     399                 :            : int tcp_getsockopt(struct sock *sk, int level, int optname,
     400                 :            :                    char __user *optval, int __user *optlen);
     401                 :            : int tcp_setsockopt(struct sock *sk, int level, int optname,
     402                 :            :                    char __user *optval, unsigned int optlen);
     403                 :            : int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
     404                 :            :                           char __user *optval, int __user *optlen);
     405                 :            : int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
     406                 :            :                           char __user *optval, unsigned int optlen);
     407                 :            : void tcp_set_keepalive(struct sock *sk, int val);
     408                 :            : void tcp_syn_ack_timeout(const struct request_sock *req);
     409                 :            : int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
     410                 :            :                 int flags, int *addr_len);
     411                 :            : int tcp_set_rcvlowat(struct sock *sk, int val);
     412                 :            : void tcp_data_ready(struct sock *sk);
     413                 :            : #ifdef CONFIG_MMU
     414                 :            : int tcp_mmap(struct file *file, struct socket *sock,
     415                 :            :              struct vm_area_struct *vma);
     416                 :            : #endif
     417                 :            : void tcp_parse_options(const struct net *net, const struct sk_buff *skb,
     418                 :            :                        struct tcp_options_received *opt_rx,
     419                 :            :                        int estab, struct tcp_fastopen_cookie *foc);
     420                 :            : const u8 *tcp_parse_md5sig_option(const struct tcphdr *th);
     421                 :            : 
     422                 :            : /*
     423                 :            :  *      BPF SKB-less helpers
     424                 :            :  */
     425                 :            : u16 tcp_v4_get_syncookie(struct sock *sk, struct iphdr *iph,
     426                 :            :                          struct tcphdr *th, u32 *cookie);
     427                 :            : u16 tcp_v6_get_syncookie(struct sock *sk, struct ipv6hdr *iph,
     428                 :            :                          struct tcphdr *th, u32 *cookie);
     429                 :            : u16 tcp_get_syncookie_mss(struct request_sock_ops *rsk_ops,
     430                 :            :                           const struct tcp_request_sock_ops *af_ops,
     431                 :            :                           struct sock *sk, struct tcphdr *th);
     432                 :            : /*
     433                 :            :  *      TCP v4 functions exported for the inet6 API
     434                 :            :  */
     435                 :            : 
     436                 :            : void tcp_v4_send_check(struct sock *sk, struct sk_buff *skb);
     437                 :            : void tcp_v4_mtu_reduced(struct sock *sk);
     438                 :            : void tcp_req_err(struct sock *sk, u32 seq, bool abort);
     439                 :            : int tcp_v4_conn_request(struct sock *sk, struct sk_buff *skb);
     440                 :            : struct sock *tcp_create_openreq_child(const struct sock *sk,
     441                 :            :                                       struct request_sock *req,
     442                 :            :                                       struct sk_buff *skb);
     443                 :            : void tcp_ca_openreq_child(struct sock *sk, const struct dst_entry *dst);
     444                 :            : struct sock *tcp_v4_syn_recv_sock(const struct sock *sk, struct sk_buff *skb,
     445                 :            :                                   struct request_sock *req,
     446                 :            :                                   struct dst_entry *dst,
     447                 :            :                                   struct request_sock *req_unhash,
     448                 :            :                                   bool *own_req);
     449                 :            : int tcp_v4_do_rcv(struct sock *sk, struct sk_buff *skb);
     450                 :            : int tcp_v4_connect(struct sock *sk, struct sockaddr *uaddr, int addr_len);
     451                 :            : int tcp_connect(struct sock *sk);
     452                 :            : enum tcp_synack_type {
     453                 :            :         TCP_SYNACK_NORMAL,
     454                 :            :         TCP_SYNACK_FASTOPEN,
     455                 :            :         TCP_SYNACK_COOKIE,
     456                 :            : };
     457                 :            : struct sk_buff *tcp_make_synack(const struct sock *sk, struct dst_entry *dst,
     458                 :            :                                 struct request_sock *req,
     459                 :            :                                 struct tcp_fastopen_cookie *foc,
     460                 :            :                                 enum tcp_synack_type synack_type);
     461                 :            : int tcp_disconnect(struct sock *sk, int flags);
     462                 :            : 
     463                 :            : void tcp_finish_connect(struct sock *sk, struct sk_buff *skb);
     464                 :            : int tcp_send_rcvq(struct sock *sk, struct msghdr *msg, size_t size);
     465                 :            : void inet_sk_rx_dst_set(struct sock *sk, const struct sk_buff *skb);
     466                 :            : 
     467                 :            : /* From syncookies.c */
     468                 :            : struct sock *tcp_get_cookie_sock(struct sock *sk, struct sk_buff *skb,
     469                 :            :                                  struct request_sock *req,
     470                 :            :                                  struct dst_entry *dst, u32 tsoff);
     471                 :            : int __cookie_v4_check(const struct iphdr *iph, const struct tcphdr *th,
     472                 :            :                       u32 cookie);
     473                 :            : struct sock *cookie_v4_check(struct sock *sk, struct sk_buff *skb);
     474                 :            : #ifdef CONFIG_SYN_COOKIES
     475                 :            : 
     476                 :            : /* Syncookies use a monotonic timer which increments every 60 seconds.
     477                 :            :  * This counter is used both as a hash input and partially encoded into
     478                 :            :  * the cookie value.  A cookie is only validated further if the delta
     479                 :            :  * between the current counter value and the encoded one is less than this,
     480                 :            :  * i.e. a sent cookie is valid only at most for 2*60 seconds (or less if
     481                 :            :  * the counter advances immediately after a cookie is generated).
     482                 :            :  */
     483                 :            : #define MAX_SYNCOOKIE_AGE       2
     484                 :            : #define TCP_SYNCOOKIE_PERIOD    (60 * HZ)
     485                 :            : #define TCP_SYNCOOKIE_VALID     (MAX_SYNCOOKIE_AGE * TCP_SYNCOOKIE_PERIOD)
     486                 :            : 
     487                 :            : /* syncookies: remember time of last synqueue overflow
     488                 :            :  * But do not dirty this field too often (once per second is enough)
     489                 :            :  * It is racy as we do not hold a lock, but race is very minor.
     490                 :            :  */
     491                 :          0 : static inline void tcp_synq_overflow(const struct sock *sk)
     492                 :            : {
     493                 :          0 :         unsigned int last_overflow;
     494                 :          0 :         unsigned int now = jiffies;
     495                 :            : 
     496         [ #  # ]:          0 :         if (sk->sk_reuseport) {
     497                 :          0 :                 struct sock_reuseport *reuse;
     498                 :            : 
     499         [ #  # ]:          0 :                 reuse = rcu_dereference(sk->sk_reuseport_cb);
     500         [ #  # ]:          0 :                 if (likely(reuse)) {
     501         [ #  # ]:          0 :                         last_overflow = READ_ONCE(reuse->synq_overflow_ts);
     502         [ #  # ]:          0 :                         if (!time_between32(now, last_overflow,
     503                 :            :                                             last_overflow + HZ))
     504                 :          0 :                                 WRITE_ONCE(reuse->synq_overflow_ts, now);
     505                 :            :                         return;
     506                 :            :                 }
     507                 :            :         }
     508                 :            : 
     509         [ #  # ]:          0 :         last_overflow = READ_ONCE(tcp_sk(sk)->rx_opt.ts_recent_stamp);
     510         [ #  # ]:          0 :         if (!time_between32(now, last_overflow, last_overflow + HZ))
     511                 :          0 :                 WRITE_ONCE(tcp_sk(sk)->rx_opt.ts_recent_stamp, now);
     512                 :            : }
     513                 :            : 
     514                 :            : /* syncookies: no recent synqueue overflow on this listening socket? */
     515                 :          0 : static inline bool tcp_synq_no_recent_overflow(const struct sock *sk)
     516                 :            : {
     517                 :          0 :         unsigned int last_overflow;
     518                 :          0 :         unsigned int now = jiffies;
     519                 :            : 
     520         [ #  # ]:          0 :         if (sk->sk_reuseport) {
     521                 :          0 :                 struct sock_reuseport *reuse;
     522                 :            : 
     523         [ #  # ]:          0 :                 reuse = rcu_dereference(sk->sk_reuseport_cb);
     524         [ #  # ]:          0 :                 if (likely(reuse)) {
     525                 :          0 :                         last_overflow = READ_ONCE(reuse->synq_overflow_ts);
     526                 :          0 :                         return !time_between32(now, last_overflow - HZ,
     527                 :            :                                                last_overflow +
     528                 :            :                                                TCP_SYNCOOKIE_VALID);
     529                 :            :                 }
     530                 :            :         }
     531                 :            : 
     532                 :          0 :         last_overflow = READ_ONCE(tcp_sk(sk)->rx_opt.ts_recent_stamp);
     533                 :            : 
     534                 :            :         /* If last_overflow <= jiffies <= last_overflow + TCP_SYNCOOKIE_VALID,
     535                 :            :          * then we're under synflood. However, we have to use
     536                 :            :          * 'last_overflow - HZ' as lower bound. That's because a concurrent
     537                 :            :          * tcp_synq_overflow() could update .ts_recent_stamp after we read
     538                 :            :          * jiffies but before we store .ts_recent_stamp into last_overflow,
     539                 :            :          * which could lead to rejecting a valid syncookie.
     540                 :            :          */
     541                 :          0 :         return !time_between32(now, last_overflow - HZ,
     542                 :            :                                last_overflow + TCP_SYNCOOKIE_VALID);
     543                 :            : }
     544                 :            : 
     545                 :          0 : static inline u32 tcp_cookie_time(void)
     546                 :            : {
     547                 :          0 :         u64 val = get_jiffies_64();
     548                 :            : 
     549                 :          0 :         do_div(val, TCP_SYNCOOKIE_PERIOD);
     550                 :          0 :         return val;
     551                 :            : }
     552                 :            : 
     553                 :            : u32 __cookie_v4_init_sequence(const struct iphdr *iph, const struct tcphdr *th,
     554                 :            :                               u16 *mssp);
     555                 :            : __u32 cookie_v4_init_sequence(const struct sk_buff *skb, __u16 *mss);
     556                 :            : u64 cookie_init_timestamp(struct request_sock *req, u64 now);
     557                 :            : bool cookie_timestamp_decode(const struct net *net,
     558                 :            :                              struct tcp_options_received *opt);
     559                 :            : bool cookie_ecn_ok(const struct tcp_options_received *opt,
     560                 :            :                    const struct net *net, const struct dst_entry *dst);
     561                 :            : 
     562                 :            : /* From net/ipv6/syncookies.c */
     563                 :            : int __cookie_v6_check(const struct ipv6hdr *iph, const struct tcphdr *th,
     564                 :            :                       u32 cookie);
     565                 :            : struct sock *cookie_v6_check(struct sock *sk, struct sk_buff *skb);
     566                 :            : 
     567                 :            : u32 __cookie_v6_init_sequence(const struct ipv6hdr *iph,
     568                 :            :                               const struct tcphdr *th, u16 *mssp);
     569                 :            : __u32 cookie_v6_init_sequence(const struct sk_buff *skb, __u16 *mss);
     570                 :            : #endif
     571                 :            : /* tcp_output.c */
     572                 :            : 
     573                 :            : void __tcp_push_pending_frames(struct sock *sk, unsigned int cur_mss,
     574                 :            :                                int nonagle);
     575                 :            : int __tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs);
     576                 :            : int tcp_retransmit_skb(struct sock *sk, struct sk_buff *skb, int segs);
     577                 :            : void tcp_retransmit_timer(struct sock *sk);
     578                 :            : void tcp_xmit_retransmit_queue(struct sock *);
     579                 :            : void tcp_simple_retransmit(struct sock *);
     580                 :            : void tcp_enter_recovery(struct sock *sk, bool ece_ack);
     581                 :            : int tcp_trim_head(struct sock *, struct sk_buff *, u32);
     582                 :            : enum tcp_queue {
     583                 :            :         TCP_FRAG_IN_WRITE_QUEUE,
     584                 :            :         TCP_FRAG_IN_RTX_QUEUE,
     585                 :            : };
     586                 :            : int tcp_fragment(struct sock *sk, enum tcp_queue tcp_queue,
     587                 :            :                  struct sk_buff *skb, u32 len,
     588                 :            :                  unsigned int mss_now, gfp_t gfp);
     589                 :            : 
     590                 :            : void tcp_send_probe0(struct sock *);
     591                 :            : void tcp_send_partial(struct sock *);
     592                 :            : int tcp_write_wakeup(struct sock *, int mib);
     593                 :            : void tcp_send_fin(struct sock *sk);
     594                 :            : void tcp_send_active_reset(struct sock *sk, gfp_t priority);
     595                 :            : int tcp_send_synack(struct sock *);
     596                 :            : void tcp_push_one(struct sock *, unsigned int mss_now);
     597                 :            : void __tcp_send_ack(struct sock *sk, u32 rcv_nxt);
     598                 :            : void tcp_send_ack(struct sock *sk);
     599                 :            : void tcp_send_delayed_ack(struct sock *sk);
     600                 :            : void tcp_send_loss_probe(struct sock *sk);
     601                 :            : bool tcp_schedule_loss_probe(struct sock *sk, bool advancing_rto);
     602                 :            : void tcp_skb_collapse_tstamp(struct sk_buff *skb,
     603                 :            :                              const struct sk_buff *next_skb);
     604                 :            : 
     605                 :            : /* tcp_input.c */
     606                 :            : void tcp_rearm_rto(struct sock *sk);
     607                 :            : void tcp_synack_rtt_meas(struct sock *sk, struct request_sock *req);
     608                 :            : void tcp_reset(struct sock *sk);
     609                 :            : void tcp_skb_mark_lost_uncond_verify(struct tcp_sock *tp, struct sk_buff *skb);
     610                 :            : void tcp_fin(struct sock *sk);
     611                 :            : 
     612                 :            : /* tcp_timer.c */
     613                 :            : void tcp_init_xmit_timers(struct sock *);
     614                 :          0 : static inline void tcp_clear_xmit_timers(struct sock *sk)
     615                 :            : {
     616         [ #  # ]:          0 :         if (hrtimer_try_to_cancel(&tcp_sk(sk)->pacing_timer) == 1)
     617                 :          0 :                 __sock_put(sk);
     618                 :            : 
     619         [ #  # ]:          0 :         if (hrtimer_try_to_cancel(&tcp_sk(sk)->compressed_ack_timer) == 1)
     620                 :          0 :                 __sock_put(sk);
     621                 :            : 
     622                 :          0 :         inet_csk_clear_xmit_timers(sk);
     623                 :          0 : }
     624                 :            : 
     625                 :            : unsigned int tcp_sync_mss(struct sock *sk, u32 pmtu);
     626                 :            : unsigned int tcp_current_mss(struct sock *sk);
     627                 :            : 
     628                 :            : /* Bound MSS / TSO packet size with the half of the window */
     629                 :          0 : static inline int tcp_bound_to_half_wnd(struct tcp_sock *tp, int pktsize)
     630                 :            : {
     631                 :          0 :         int cutoff;
     632                 :            : 
     633                 :            :         /* When peer uses tiny windows, there is no use in packetizing
     634                 :            :          * to sub-MSS pieces for the sake of SWS or making sure there
     635                 :            :          * are enough packets in the pipe for fast recovery.
     636                 :            :          *
     637                 :            :          * On the other hand, for extremely large MSS devices, handling
     638                 :            :          * smaller than MSS windows in this way does make sense.
     639                 :            :          */
     640         [ #  # ]:          0 :         if (tp->max_window > TCP_MSS_DEFAULT)
     641                 :          0 :                 cutoff = (tp->max_window >> 1);
     642                 :            :         else
     643                 :          0 :                 cutoff = tp->max_window;
     644                 :            : 
     645         [ #  # ]:          0 :         if (cutoff && pktsize > cutoff)
     646                 :          0 :                 return max_t(int, cutoff, 68U - tp->tcp_header_len);
     647                 :            :         else
     648                 :            :                 return pktsize;
     649                 :            : }
     650                 :            : 
     651                 :            : /* tcp.c */
     652                 :            : void tcp_get_info(struct sock *, struct tcp_info *);
     653                 :            : 
     654                 :            : /* Read 'sendfile()'-style from a TCP socket */
     655                 :            : int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
     656                 :            :                   sk_read_actor_t recv_actor);
     657                 :            : 
     658                 :            : void tcp_initialize_rcv_mss(struct sock *sk);
     659                 :            : 
     660                 :            : int tcp_mtu_to_mss(struct sock *sk, int pmtu);
     661                 :            : int tcp_mss_to_mtu(struct sock *sk, int mss);
     662                 :            : void tcp_mtup_init(struct sock *sk);
     663                 :            : void tcp_init_buffer_space(struct sock *sk);
     664                 :            : 
     665                 :            : static inline void tcp_bound_rto(const struct sock *sk)
     666                 :            : {
     667                 :            :         if (inet_csk(sk)->icsk_rto > TCP_RTO_MAX)
     668                 :            :                 inet_csk(sk)->icsk_rto = TCP_RTO_MAX;
     669                 :            : }
     670                 :            : 
     671                 :          0 : static inline u32 __tcp_set_rto(const struct tcp_sock *tp)
     672                 :            : {
     673         [ #  # ]:          0 :         return usecs_to_jiffies((tp->srtt_us >> 3) + tp->rttvar_us);
     674                 :            : }
     675                 :            : 
     676                 :          0 : static inline void __tcp_fast_path_on(struct tcp_sock *tp, u32 snd_wnd)
     677                 :            : {
     678                 :          0 :         tp->pred_flags = htonl((tp->tcp_header_len << 26) |
     679                 :            :                                ntohl(TCP_FLAG_ACK) |
     680                 :            :                                snd_wnd);
     681                 :          0 : }
     682                 :            : 
     683                 :          0 : static inline void tcp_fast_path_on(struct tcp_sock *tp)
     684                 :            : {
     685                 :          0 :         __tcp_fast_path_on(tp, tp->snd_wnd >> tp->rx_opt.snd_wscale);
     686                 :          0 : }
     687                 :            : 
     688                 :          0 : static inline void tcp_fast_path_check(struct sock *sk)
     689                 :            : {
     690         [ #  # ]:          0 :         struct tcp_sock *tp = tcp_sk(sk);
     691                 :            : 
     692         [ #  # ]:          0 :         if (RB_EMPTY_ROOT(&tp->out_of_order_queue) &&
     693         [ #  # ]:          0 :             tp->rcv_wnd &&
     694         [ #  # ]:          0 :             atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf &&
     695         [ #  # ]:          0 :             !tp->urg_data)
     696                 :          0 :                 tcp_fast_path_on(tp);
     697                 :          0 : }
     698                 :            : 
     699                 :            : /* Compute the actual rto_min value */
     700                 :          0 : static inline u32 tcp_rto_min(struct sock *sk)
     701                 :            : {
     702         [ #  # ]:          0 :         const struct dst_entry *dst = __sk_dst_get(sk);
     703                 :          0 :         u32 rto_min = TCP_RTO_MIN;
     704                 :            : 
     705   [ #  #  #  # ]:          0 :         if (dst && dst_metric_locked(dst, RTAX_RTO_MIN))
     706                 :          0 :                 rto_min = dst_metric_rtt(dst, RTAX_RTO_MIN);
     707                 :          0 :         return rto_min;
     708                 :            : }
     709                 :            : 
     710                 :          0 : static inline u32 tcp_rto_min_us(struct sock *sk)
     711                 :            : {
     712                 :          0 :         return jiffies_to_usecs(tcp_rto_min(sk));
     713                 :            : }
     714                 :            : 
     715                 :          0 : static inline bool tcp_ca_dst_locked(const struct dst_entry *dst)
     716                 :            : {
     717                 :          0 :         return dst_metric_locked(dst, RTAX_CC_ALGO);
     718                 :            : }
     719                 :            : 
     720                 :            : /* Minimum RTT in usec. ~0 means not available. */
     721                 :          0 : static inline u32 tcp_min_rtt(const struct tcp_sock *tp)
     722                 :            : {
     723         [ #  # ]:          0 :         return minmax_get(&tp->rtt_min);
     724                 :            : }
     725                 :            : 
     726                 :            : /* Compute the actual receive window we are currently advertising.
     727                 :            :  * Rcv_nxt can be after the window if our peer push more data
     728                 :            :  * than the offered window.
     729                 :            :  */
     730                 :          0 : static inline u32 tcp_receive_window(const struct tcp_sock *tp)
     731                 :            : {
     732                 :          0 :         s32 win = tp->rcv_wup + tp->rcv_wnd - tp->rcv_nxt;
     733                 :            : 
     734                 :          0 :         if (win < 0)
     735                 :            :                 win = 0;
     736   [ #  #  #  #  :          0 :         return (u32) win;
             #  #  #  # ]
     737                 :            : }
     738                 :            : 
     739                 :            : /* Choose a new window, without checks for shrinking, and without
     740                 :            :  * scaling applied to the result.  The caller does these things
     741                 :            :  * if necessary.  This is a "raw" window selection.
     742                 :            :  */
     743                 :            : u32 __tcp_select_window(struct sock *sk);
     744                 :            : 
     745                 :            : void tcp_send_window_probe(struct sock *sk);
     746                 :            : 
     747                 :            : /* TCP uses 32bit jiffies to save some space.
     748                 :            :  * Note that this is different from tcp_time_stamp, which
     749                 :            :  * historically has been the same until linux-4.13.
     750                 :            :  */
     751                 :            : #define tcp_jiffies32 ((u32)jiffies)
     752                 :            : 
     753                 :            : /*
     754                 :            :  * Deliver a 32bit value for TCP timestamp option (RFC 7323)
     755                 :            :  * It is no longer tied to jiffies, but to 1 ms clock.
     756                 :            :  * Note: double check if you want to use tcp_jiffies32 instead of this.
     757                 :            :  */
     758                 :            : #define TCP_TS_HZ       1000
     759                 :            : 
     760                 :          0 : static inline u64 tcp_clock_ns(void)
     761                 :            : {
     762                 :          0 :         return ktime_get_ns();
     763                 :            : }
     764                 :            : 
     765                 :          0 : static inline u64 tcp_clock_us(void)
     766                 :            : {
     767                 :          0 :         return div_u64(tcp_clock_ns(), NSEC_PER_USEC);
     768                 :            : }
     769                 :            : 
     770                 :            : /* This should only be used in contexts where tp->tcp_mstamp is up to date */
     771                 :          0 : static inline u32 tcp_time_stamp(const struct tcp_sock *tp)
     772                 :            : {
     773   [ #  #  #  # ]:          0 :         return div_u64(tp->tcp_mstamp, USEC_PER_SEC / TCP_TS_HZ);
     774                 :            : }
     775                 :            : 
     776                 :            : /* Convert a nsec timestamp into TCP TSval timestamp (ms based currently) */
     777                 :          0 : static inline u32 tcp_ns_to_ts(u64 ns)
     778                 :            : {
     779         [ #  # ]:          0 :         return div_u64(ns, NSEC_PER_SEC / TCP_TS_HZ);
     780                 :            : }
     781                 :            : 
     782                 :            : /* Could use tcp_clock_us() / 1000, but this version uses a single divide */
     783                 :          0 : static inline u32 tcp_time_stamp_raw(void)
     784                 :            : {
     785                 :          0 :         return tcp_ns_to_ts(tcp_clock_ns());
     786                 :            : }
     787                 :            : 
     788                 :            : void tcp_mstamp_refresh(struct tcp_sock *tp);
     789                 :            : 
     790                 :          0 : static inline u32 tcp_stamp_us_delta(u64 t1, u64 t0)
     791                 :            : {
     792   [ #  #  #  #  :          0 :         return max_t(s64, t1 - t0, 0);
             #  #  #  # ]
     793                 :            : }
     794                 :            : 
     795                 :          0 : static inline u32 tcp_skb_timestamp(const struct sk_buff *skb)
     796                 :            : {
     797         [ #  # ]:          0 :         return tcp_ns_to_ts(skb->skb_mstamp_ns);
     798                 :            : }
     799                 :            : 
     800                 :            : /* provide the departure time in us unit */
     801                 :          0 : static inline u64 tcp_skb_timestamp_us(const struct sk_buff *skb)
     802                 :            : {
     803   [ #  #  #  # ]:          0 :         return div_u64(skb->skb_mstamp_ns, NSEC_PER_USEC);
     804                 :            : }
     805                 :            : 
     806                 :            : 
     807                 :            : #define tcp_flag_byte(th) (((u_int8_t *)th)[13])
     808                 :            : 
     809                 :            : #define TCPHDR_FIN 0x01
     810                 :            : #define TCPHDR_SYN 0x02
     811                 :            : #define TCPHDR_RST 0x04
     812                 :            : #define TCPHDR_PSH 0x08
     813                 :            : #define TCPHDR_ACK 0x10
     814                 :            : #define TCPHDR_URG 0x20
     815                 :            : #define TCPHDR_ECE 0x40
     816                 :            : #define TCPHDR_CWR 0x80
     817                 :            : 
     818                 :            : #define TCPHDR_SYN_ECN  (TCPHDR_SYN | TCPHDR_ECE | TCPHDR_CWR)
     819                 :            : 
     820                 :            : /* This is what the send packet queuing engine uses to pass
     821                 :            :  * TCP per-packet control information to the transmission code.
     822                 :            :  * We also store the host-order sequence numbers in here too.
     823                 :            :  * This is 44 bytes if IPV6 is enabled.
     824                 :            :  * If this grows please adjust skbuff.h:skbuff->cb[xxx] size appropriately.
     825                 :            :  */
     826                 :            : struct tcp_skb_cb {
     827                 :            :         __u32           seq;            /* Starting sequence number     */
     828                 :            :         __u32           end_seq;        /* SEQ + FIN + SYN + datalen    */
     829                 :            :         union {
     830                 :            :                 /* Note : tcp_tw_isn is used in input path only
     831                 :            :                  *        (isn chosen by tcp_timewait_state_process())
     832                 :            :                  *
     833                 :            :                  *        tcp_gso_segs/size are used in write queue only,
     834                 :            :                  *        cf tcp_skb_pcount()/tcp_skb_mss()
     835                 :            :                  */
     836                 :            :                 __u32           tcp_tw_isn;
     837                 :            :                 struct {
     838                 :            :                         u16     tcp_gso_segs;
     839                 :            :                         u16     tcp_gso_size;
     840                 :            :                 };
     841                 :            :         };
     842                 :            :         __u8            tcp_flags;      /* TCP header flags. (tcp[13])  */
     843                 :            : 
     844                 :            :         __u8            sacked;         /* State flags for SACK.        */
     845                 :            : #define TCPCB_SACKED_ACKED      0x01    /* SKB ACK'd by a SACK block    */
     846                 :            : #define TCPCB_SACKED_RETRANS    0x02    /* SKB retransmitted            */
     847                 :            : #define TCPCB_LOST              0x04    /* SKB is lost                  */
     848                 :            : #define TCPCB_TAGBITS           0x07    /* All tag bits                 */
     849                 :            : #define TCPCB_REPAIRED          0x10    /* SKB repaired (no skb_mstamp_ns)      */
     850                 :            : #define TCPCB_EVER_RETRANS      0x80    /* Ever retransmitted frame     */
     851                 :            : #define TCPCB_RETRANS           (TCPCB_SACKED_RETRANS|TCPCB_EVER_RETRANS| \
     852                 :            :                                 TCPCB_REPAIRED)
     853                 :            : 
     854                 :            :         __u8            ip_dsfield;     /* IPv4 tos or IPv6 dsfield     */
     855                 :            :         __u8            txstamp_ack:1,  /* Record TX timestamp for ack? */
     856                 :            :                         eor:1,          /* Is skb MSG_EOR marked? */
     857                 :            :                         has_rxtstamp:1, /* SKB has a RX timestamp       */
     858                 :            :                         unused:5;
     859                 :            :         __u32           ack_seq;        /* Sequence number ACK'd        */
     860                 :            :         union {
     861                 :            :                 struct {
     862                 :            :                         /* There is space for up to 24 bytes */
     863                 :            :                         __u32 in_flight:30,/* Bytes in flight at transmit */
     864                 :            :                               is_app_limited:1, /* cwnd not fully used? */
     865                 :            :                               unused:1;
     866                 :            :                         /* pkts S/ACKed so far upon tx of skb, incl retrans: */
     867                 :            :                         __u32 delivered;
     868                 :            :                         /* start of send pipeline phase */
     869                 :            :                         u64 first_tx_mstamp;
     870                 :            :                         /* when we reached the "delivered" count */
     871                 :            :                         u64 delivered_mstamp;
     872                 :            :                 } tx;   /* only used for outgoing skbs */
     873                 :            :                 union {
     874                 :            :                         struct inet_skb_parm    h4;
     875                 :            : #if IS_ENABLED(CONFIG_IPV6)
     876                 :            :                         struct inet6_skb_parm   h6;
     877                 :            : #endif
     878                 :            :                 } header;       /* For incoming skbs */
     879                 :            :                 struct {
     880                 :            :                         __u32 flags;
     881                 :            :                         struct sock *sk_redir;
     882                 :            :                         void *data_end;
     883                 :            :                 } bpf;
     884                 :            :         };
     885                 :            : };
     886                 :            : 
     887                 :            : #define TCP_SKB_CB(__skb)       ((struct tcp_skb_cb *)&((__skb)->cb[0]))
     888                 :            : 
     889                 :          0 : static inline void bpf_compute_data_end_sk_skb(struct sk_buff *skb)
     890                 :            : {
     891                 :          0 :         TCP_SKB_CB(skb)->bpf.data_end = skb->data + skb_headlen(skb);
     892                 :            : }
     893                 :            : 
     894                 :            : static inline bool tcp_skb_bpf_ingress(const struct sk_buff *skb)
     895                 :            : {
     896                 :            :         return TCP_SKB_CB(skb)->bpf.flags & BPF_F_INGRESS;
     897                 :            : }
     898                 :            : 
     899                 :            : static inline struct sock *tcp_skb_bpf_redirect_fetch(struct sk_buff *skb)
     900                 :            : {
     901                 :            :         return TCP_SKB_CB(skb)->bpf.sk_redir;
     902                 :            : }
     903                 :            : 
     904                 :            : static inline void tcp_skb_bpf_redirect_clear(struct sk_buff *skb)
     905                 :            : {
     906                 :            :         TCP_SKB_CB(skb)->bpf.sk_redir = NULL;
     907                 :            : }
     908                 :            : 
     909                 :            : #if IS_ENABLED(CONFIG_IPV6)
     910                 :            : /* This is the variant of inet6_iif() that must be used by TCP,
     911                 :            :  * as TCP moves IP6CB into a different location in skb->cb[]
     912                 :            :  */
     913                 :          0 : static inline int tcp_v6_iif(const struct sk_buff *skb)
     914                 :            : {
     915         [ #  # ]:          0 :         return TCP_SKB_CB(skb)->header.h6.iif;
     916                 :            : }
     917                 :            : 
     918                 :          0 : static inline int tcp_v6_iif_l3_slave(const struct sk_buff *skb)
     919                 :            : {
     920                 :          0 :         bool l3_slave = ipv6_l3mdev_skb(TCP_SKB_CB(skb)->header.h6.flags);
     921                 :            : 
     922                 :          0 :         return l3_slave ? skb->skb_iif : TCP_SKB_CB(skb)->header.h6.iif;
     923                 :            : }
     924                 :            : 
     925                 :            : /* TCP_SKB_CB reference means this can not be used from early demux */
     926                 :          0 : static inline int tcp_v6_sdif(const struct sk_buff *skb)
     927                 :            : {
     928                 :            : #if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)
     929                 :            :         if (skb && ipv6_l3mdev_skb(TCP_SKB_CB(skb)->header.h6.flags))
     930                 :            :                 return TCP_SKB_CB(skb)->header.h6.iif;
     931                 :            : #endif
     932                 :          0 :         return 0;
     933                 :            : }
     934                 :            : #endif
     935                 :            : 
     936                 :          0 : static inline bool inet_exact_dif_match(struct net *net, struct sk_buff *skb)
     937                 :            : {
     938                 :            : #if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)
     939                 :            :         if (!net->ipv4.sysctl_tcp_l3mdev_accept &&
     940                 :            :             skb && ipv4_l3mdev_skb(IPCB(skb)->flags))
     941                 :            :                 return true;
     942                 :            : #endif
     943         [ #  # ]:          0 :         return false;
     944                 :            : }
     945                 :            : 
     946                 :            : /* TCP_SKB_CB reference means this can not be used from early demux */
     947                 :          0 : static inline int tcp_v4_sdif(struct sk_buff *skb)
     948                 :            : {
     949                 :            : #if IS_ENABLED(CONFIG_NET_L3_MASTER_DEV)
     950                 :            :         if (skb && ipv4_l3mdev_skb(TCP_SKB_CB(skb)->header.h4.flags))
     951                 :            :                 return TCP_SKB_CB(skb)->header.h4.iif;
     952                 :            : #endif
     953         [ #  # ]:          0 :         return 0;
     954                 :            : }
     955                 :            : 
     956                 :            : /* Due to TSO, an SKB can be composed of multiple actual
     957                 :            :  * packets.  To keep these tracked properly, we use this.
     958                 :            :  */
     959                 :          0 : static inline int tcp_skb_pcount(const struct sk_buff *skb)
     960                 :            : {
     961   [ #  #  #  #  :          0 :         return TCP_SKB_CB(skb)->tcp_gso_segs;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
     962                 :            : }
     963                 :            : 
     964                 :          0 : static inline void tcp_skb_pcount_set(struct sk_buff *skb, int segs)
     965                 :            : {
     966   [ #  #  #  # ]:          0 :         TCP_SKB_CB(skb)->tcp_gso_segs = segs;
     967                 :            : }
     968                 :            : 
     969                 :          0 : static inline void tcp_skb_pcount_add(struct sk_buff *skb, int segs)
     970                 :            : {
     971   [ #  #  #  # ]:          0 :         TCP_SKB_CB(skb)->tcp_gso_segs += segs;
     972                 :            : }
     973                 :            : 
     974                 :            : /* This is valid iff skb is in write queue and tcp_skb_pcount() > 1. */
     975                 :          0 : static inline int tcp_skb_mss(const struct sk_buff *skb)
     976                 :            : {
     977   [ #  #  #  #  :          0 :         return TCP_SKB_CB(skb)->tcp_gso_size;
          #  #  #  #  #  
                      # ]
     978                 :            : }
     979                 :            : 
     980                 :          0 : static inline bool tcp_skb_can_collapse_to(const struct sk_buff *skb)
     981                 :            : {
     982   [ #  #  #  # ]:          0 :         return likely(!TCP_SKB_CB(skb)->eor);
     983                 :            : }
     984                 :            : 
     985                 :          0 : static inline bool tcp_skb_can_collapse(const struct sk_buff *to,
     986                 :            :                                         const struct sk_buff *from)
     987                 :            : {
     988   [ #  #  #  # ]:          0 :         return likely(tcp_skb_can_collapse_to(to) &&
     989                 :            :                       mptcp_skb_can_collapse(to, from));
     990                 :            : }
     991                 :            : 
     992                 :            : /* Events passed to congestion control interface */
     993                 :            : enum tcp_ca_event {
     994                 :            :         CA_EVENT_TX_START,      /* first transmit when no packets in flight */
     995                 :            :         CA_EVENT_CWND_RESTART,  /* congestion window restart */
     996                 :            :         CA_EVENT_COMPLETE_CWR,  /* end of congestion recovery */
     997                 :            :         CA_EVENT_LOSS,          /* loss timeout */
     998                 :            :         CA_EVENT_ECN_NO_CE,     /* ECT set, but not CE marked */
     999                 :            :         CA_EVENT_ECN_IS_CE,     /* received CE marked IP packet */
    1000                 :            : };
    1001                 :            : 
    1002                 :            : /* Information about inbound ACK, passed to cong_ops->in_ack_event() */
    1003                 :            : enum tcp_ca_ack_event_flags {
    1004                 :            :         CA_ACK_SLOWPATH         = (1 << 0),       /* In slow path processing */
    1005                 :            :         CA_ACK_WIN_UPDATE       = (1 << 1),       /* ACK updated window */
    1006                 :            :         CA_ACK_ECE              = (1 << 2),       /* ECE bit is set on ack */
    1007                 :            : };
    1008                 :            : 
    1009                 :            : /*
    1010                 :            :  * Interface for adding new TCP congestion control handlers
    1011                 :            :  */
    1012                 :            : #define TCP_CA_NAME_MAX 16
    1013                 :            : #define TCP_CA_MAX      128
    1014                 :            : #define TCP_CA_BUF_MAX  (TCP_CA_NAME_MAX*TCP_CA_MAX)
    1015                 :            : 
    1016                 :            : #define TCP_CA_UNSPEC   0
    1017                 :            : 
    1018                 :            : /* Algorithm can be set on socket without CAP_NET_ADMIN privileges */
    1019                 :            : #define TCP_CONG_NON_RESTRICTED 0x1
    1020                 :            : /* Requires ECN/ECT set on all packets */
    1021                 :            : #define TCP_CONG_NEEDS_ECN      0x2
    1022                 :            : #define TCP_CONG_MASK   (TCP_CONG_NON_RESTRICTED | TCP_CONG_NEEDS_ECN)
    1023                 :            : 
    1024                 :            : union tcp_cc_info;
    1025                 :            : 
    1026                 :            : struct ack_sample {
    1027                 :            :         u32 pkts_acked;
    1028                 :            :         s32 rtt_us;
    1029                 :            :         u32 in_flight;
    1030                 :            : };
    1031                 :            : 
    1032                 :            : /* A rate sample measures the number of (original/retransmitted) data
    1033                 :            :  * packets delivered "delivered" over an interval of time "interval_us".
    1034                 :            :  * The tcp_rate.c code fills in the rate sample, and congestion
    1035                 :            :  * control modules that define a cong_control function to run at the end
    1036                 :            :  * of ACK processing can optionally chose to consult this sample when
    1037                 :            :  * setting cwnd and pacing rate.
    1038                 :            :  * A sample is invalid if "delivered" or "interval_us" is negative.
    1039                 :            :  */
    1040                 :            : struct rate_sample {
    1041                 :            :         u64  prior_mstamp; /* starting timestamp for interval */
    1042                 :            :         u32  prior_delivered;   /* tp->delivered at "prior_mstamp" */
    1043                 :            :         s32  delivered;         /* number of packets delivered over interval */
    1044                 :            :         long interval_us;       /* time for tp->delivered to incr "delivered" */
    1045                 :            :         u32 snd_interval_us;    /* snd interval for delivered packets */
    1046                 :            :         u32 rcv_interval_us;    /* rcv interval for delivered packets */
    1047                 :            :         long rtt_us;            /* RTT of last (S)ACKed packet (or -1) */
    1048                 :            :         int  losses;            /* number of packets marked lost upon ACK */
    1049                 :            :         u32  acked_sacked;      /* number of packets newly (S)ACKed upon ACK */
    1050                 :            :         u32  prior_in_flight;   /* in flight before this ACK */
    1051                 :            :         bool is_app_limited;    /* is sample from packet with bubble in pipe? */
    1052                 :            :         bool is_retrans;        /* is sample from retransmission? */
    1053                 :            :         bool is_ack_delayed;    /* is this (likely) a delayed ACK? */
    1054                 :            : };
    1055                 :            : 
    1056                 :            : struct tcp_congestion_ops {
    1057                 :            :         struct list_head        list;
    1058                 :            :         u32 key;
    1059                 :            :         u32 flags;
    1060                 :            : 
    1061                 :            :         /* initialize private data (optional) */
    1062                 :            :         void (*init)(struct sock *sk);
    1063                 :            :         /* cleanup private data  (optional) */
    1064                 :            :         void (*release)(struct sock *sk);
    1065                 :            : 
    1066                 :            :         /* return slow start threshold (required) */
    1067                 :            :         u32 (*ssthresh)(struct sock *sk);
    1068                 :            :         /* do new cwnd calculation (required) */
    1069                 :            :         void (*cong_avoid)(struct sock *sk, u32 ack, u32 acked);
    1070                 :            :         /* call before changing ca_state (optional) */
    1071                 :            :         void (*set_state)(struct sock *sk, u8 new_state);
    1072                 :            :         /* call when cwnd event occurs (optional) */
    1073                 :            :         void (*cwnd_event)(struct sock *sk, enum tcp_ca_event ev);
    1074                 :            :         /* call when ack arrives (optional) */
    1075                 :            :         void (*in_ack_event)(struct sock *sk, u32 flags);
    1076                 :            :         /* new value of cwnd after loss (required) */
    1077                 :            :         u32  (*undo_cwnd)(struct sock *sk);
    1078                 :            :         /* hook for packet ack accounting (optional) */
    1079                 :            :         void (*pkts_acked)(struct sock *sk, const struct ack_sample *sample);
    1080                 :            :         /* override sysctl_tcp_min_tso_segs */
    1081                 :            :         u32 (*min_tso_segs)(struct sock *sk);
    1082                 :            :         /* returns the multiplier used in tcp_sndbuf_expand (optional) */
    1083                 :            :         u32 (*sndbuf_expand)(struct sock *sk);
    1084                 :            :         /* call when packets are delivered to update cwnd and pacing rate,
    1085                 :            :          * after all the ca_state processing. (optional)
    1086                 :            :          */
    1087                 :            :         void (*cong_control)(struct sock *sk, const struct rate_sample *rs);
    1088                 :            :         /* get info for inet_diag (optional) */
    1089                 :            :         size_t (*get_info)(struct sock *sk, u32 ext, int *attr,
    1090                 :            :                            union tcp_cc_info *info);
    1091                 :            : 
    1092                 :            :         char            name[TCP_CA_NAME_MAX];
    1093                 :            :         struct module   *owner;
    1094                 :            : };
    1095                 :            : 
    1096                 :            : int tcp_register_congestion_control(struct tcp_congestion_ops *type);
    1097                 :            : void tcp_unregister_congestion_control(struct tcp_congestion_ops *type);
    1098                 :            : 
    1099                 :            : void tcp_assign_congestion_control(struct sock *sk);
    1100                 :            : void tcp_init_congestion_control(struct sock *sk);
    1101                 :            : void tcp_cleanup_congestion_control(struct sock *sk);
    1102                 :            : int tcp_set_default_congestion_control(struct net *net, const char *name);
    1103                 :            : void tcp_get_default_congestion_control(struct net *net, char *name);
    1104                 :            : void tcp_get_available_congestion_control(char *buf, size_t len);
    1105                 :            : void tcp_get_allowed_congestion_control(char *buf, size_t len);
    1106                 :            : int tcp_set_allowed_congestion_control(char *allowed);
    1107                 :            : int tcp_set_congestion_control(struct sock *sk, const char *name, bool load,
    1108                 :            :                                bool reinit, bool cap_net_admin);
    1109                 :            : u32 tcp_slow_start(struct tcp_sock *tp, u32 acked);
    1110                 :            : void tcp_cong_avoid_ai(struct tcp_sock *tp, u32 w, u32 acked);
    1111                 :            : 
    1112                 :            : u32 tcp_reno_ssthresh(struct sock *sk);
    1113                 :            : u32 tcp_reno_undo_cwnd(struct sock *sk);
    1114                 :            : void tcp_reno_cong_avoid(struct sock *sk, u32 ack, u32 acked);
    1115                 :            : extern struct tcp_congestion_ops tcp_reno;
    1116                 :            : 
    1117                 :            : struct tcp_congestion_ops *tcp_ca_find(const char *name);
    1118                 :            : struct tcp_congestion_ops *tcp_ca_find_key(u32 key);
    1119                 :            : u32 tcp_ca_get_key_by_name(struct net *net, const char *name, bool *ecn_ca);
    1120                 :            : #ifdef CONFIG_INET
    1121                 :            : char *tcp_ca_get_name_by_key(u32 key, char *buffer);
    1122                 :            : #else
    1123                 :            : static inline char *tcp_ca_get_name_by_key(u32 key, char *buffer)
    1124                 :            : {
    1125                 :            :         return NULL;
    1126                 :            : }
    1127                 :            : #endif
    1128                 :            : 
    1129                 :          0 : static inline bool tcp_ca_needs_ecn(const struct sock *sk)
    1130                 :            : {
    1131   [ #  #  #  #  :          0 :         const struct inet_connection_sock *icsk = inet_csk(sk);
             #  #  #  # ]
    1132                 :            : 
    1133   [ #  #  #  #  :          0 :         return icsk->icsk_ca_ops->flags & TCP_CONG_NEEDS_ECN;
             #  #  #  # ]
    1134                 :            : }
    1135                 :            : 
    1136                 :          0 : static inline void tcp_set_ca_state(struct sock *sk, const u8 ca_state)
    1137                 :            : {
    1138   [ #  #  #  #  :          0 :         struct inet_connection_sock *icsk = inet_csk(sk);
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1139                 :            : 
    1140   [ #  #  #  #  :          0 :         if (icsk->icsk_ca_ops->set_state)
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1141                 :          0 :                 icsk->icsk_ca_ops->set_state(sk, ca_state);
    1142         [ #  # ]:          0 :         icsk->icsk_ca_state = ca_state;
    1143                 :          0 : }
    1144                 :            : 
    1145                 :          0 : static inline void tcp_ca_event(struct sock *sk, const enum tcp_ca_event event)
    1146                 :            : {
    1147   [ #  #  #  #  :          0 :         const struct inet_connection_sock *icsk = inet_csk(sk);
             #  #  #  # ]
    1148                 :            : 
    1149   [ #  #  #  #  :          0 :         if (icsk->icsk_ca_ops->cwnd_event)
             #  #  #  # ]
    1150                 :          0 :                 icsk->icsk_ca_ops->cwnd_event(sk, event);
    1151                 :            : }
    1152                 :            : 
    1153                 :            : /* From tcp_rate.c */
    1154                 :            : void tcp_rate_skb_sent(struct sock *sk, struct sk_buff *skb);
    1155                 :            : void tcp_rate_skb_delivered(struct sock *sk, struct sk_buff *skb,
    1156                 :            :                             struct rate_sample *rs);
    1157                 :            : void tcp_rate_gen(struct sock *sk, u32 delivered, u32 lost,
    1158                 :            :                   bool is_sack_reneg, struct rate_sample *rs);
    1159                 :            : void tcp_rate_check_app_limited(struct sock *sk);
    1160                 :            : 
    1161                 :            : /* These functions determine how the current flow behaves in respect of SACK
    1162                 :            :  * handling. SACK is negotiated with the peer, and therefore it can vary
    1163                 :            :  * between different flows.
    1164                 :            :  *
    1165                 :            :  * tcp_is_sack - SACK enabled
    1166                 :            :  * tcp_is_reno - No SACK
    1167                 :            :  */
    1168                 :          0 : static inline int tcp_is_sack(const struct tcp_sock *tp)
    1169                 :            : {
    1170   [ #  #  #  #  :          0 :         return likely(tp->rx_opt.sack_ok);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1171                 :            : }
    1172                 :            : 
    1173                 :          0 : static inline bool tcp_is_reno(const struct tcp_sock *tp)
    1174                 :            : {
    1175   [ #  #  #  #  :          0 :         return !tcp_is_sack(tp);
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1176                 :            : }
    1177                 :            : 
    1178                 :          0 : static inline unsigned int tcp_left_out(const struct tcp_sock *tp)
    1179                 :            : {
    1180   [ #  #  #  #  :          0 :         return tp->sacked_out + tp->lost_out;
          #  #  #  #  #  
          #  #  #  #  #  
             #  #  #  # ]
    1181                 :            : }
    1182                 :            : 
    1183                 :            : /* This determines how many packets are "in the network" to the best
    1184                 :            :  * of our knowledge.  In many cases it is conservative, but where
    1185                 :            :  * detailed information is available from the receiver (via SACK
    1186                 :            :  * blocks etc.) we can make more aggressive calculations.
    1187                 :            :  *
    1188                 :            :  * Use this for decisions involving congestion control, use just
    1189                 :            :  * tp->packets_out to determine if the send queue is empty or not.
    1190                 :            :  *
    1191                 :            :  * Read this equation as:
    1192                 :            :  *
    1193                 :            :  *      "Packets sent once on transmission queue" MINUS
    1194                 :            :  *      "Packets left network, but not honestly ACKed yet" PLUS
    1195                 :            :  *      "Packets fast retransmitted"
    1196                 :            :  */
    1197                 :          0 : static inline unsigned int tcp_packets_in_flight(const struct tcp_sock *tp)
    1198                 :            : {
    1199   [ #  #  #  #  :          0 :         return tp->packets_out - tcp_left_out(tp) + tp->retrans_out;
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1200                 :            : }
    1201                 :            : 
    1202                 :            : #define TCP_INFINITE_SSTHRESH   0x7fffffff
    1203                 :            : 
    1204                 :          0 : static inline bool tcp_in_slow_start(const struct tcp_sock *tp)
    1205                 :            : {
    1206   [ #  #  #  # ]:          0 :         return tp->snd_cwnd < tp->snd_ssthresh;
    1207                 :            : }
    1208                 :            : 
    1209                 :          0 : static inline bool tcp_in_initial_slowstart(const struct tcp_sock *tp)
    1210                 :            : {
    1211         [ #  # ]:          0 :         return tp->snd_ssthresh >= TCP_INFINITE_SSTHRESH;
    1212                 :            : }
    1213                 :            : 
    1214                 :          0 : static inline bool tcp_in_cwnd_reduction(const struct sock *sk)
    1215                 :            : {
    1216   [ #  #  #  # ]:          0 :         return (TCPF_CA_CWR | TCPF_CA_Recovery) &
    1217   [ #  #  #  #  :          0 :                (1 << inet_csk(sk)->icsk_ca_state);
          #  #  #  #  #  
                      # ]
    1218                 :            : }
    1219                 :            : 
    1220                 :            : /* If cwnd > ssthresh, we may raise ssthresh to be half-way to cwnd.
    1221                 :            :  * The exception is cwnd reduction phase, when cwnd is decreasing towards
    1222                 :            :  * ssthresh.
    1223                 :            :  */
    1224                 :          0 : static inline __u32 tcp_current_ssthresh(const struct sock *sk)
    1225                 :            : {
    1226   [ #  #  #  #  :          0 :         const struct tcp_sock *tp = tcp_sk(sk);
                   #  # ]
    1227                 :            : 
    1228   [ #  #  #  #  :          0 :         if (tcp_in_cwnd_reduction(sk))
             #  #  #  # ]
    1229                 :          0 :                 return tp->snd_ssthresh;
    1230                 :            :         else
    1231                 :          0 :                 return max(tp->snd_ssthresh,
    1232                 :            :                            ((tp->snd_cwnd >> 1) +
    1233                 :            :                             (tp->snd_cwnd >> 2)));
    1234                 :            : }
    1235                 :            : 
    1236                 :            : /* Use define here intentionally to get WARN_ON location shown at the caller */
    1237                 :            : #define tcp_verify_left_out(tp) WARN_ON(tcp_left_out(tp) > tp->packets_out)
    1238                 :            : 
    1239                 :            : void tcp_enter_cwr(struct sock *sk);
    1240                 :            : __u32 tcp_init_cwnd(const struct tcp_sock *tp, const struct dst_entry *dst);
    1241                 :            : 
    1242                 :            : /* The maximum number of MSS of available cwnd for which TSO defers
    1243                 :            :  * sending if not using sysctl_tcp_tso_win_divisor.
    1244                 :            :  */
    1245                 :          0 : static inline __u32 tcp_max_tso_deferred_mss(const struct tcp_sock *tp)
    1246                 :            : {
    1247         [ #  # ]:          0 :         return 3;
    1248                 :            : }
    1249                 :            : 
    1250                 :            : /* Returns end sequence number of the receiver's advertised window */
    1251                 :          0 : static inline u32 tcp_wnd_end(const struct tcp_sock *tp)
    1252                 :            : {
    1253   [ #  #  #  #  :          0 :         return tp->snd_una + tp->snd_wnd;
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1254                 :            : }
    1255                 :            : 
    1256                 :            : /* We follow the spirit of RFC2861 to validate cwnd but implement a more
    1257                 :            :  * flexible approach. The RFC suggests cwnd should not be raised unless
    1258                 :            :  * it was fully used previously. And that's exactly what we do in
    1259                 :            :  * congestion avoidance mode. But in slow start we allow cwnd to grow
    1260                 :            :  * as long as the application has used half the cwnd.
    1261                 :            :  * Example :
    1262                 :            :  *    cwnd is 10 (IW10), but application sends 9 frames.
    1263                 :            :  *    We allow cwnd to reach 18 when all frames are ACKed.
    1264                 :            :  * This check is safe because it's as aggressive as slow start which already
    1265                 :            :  * risks 100% overshoot. The advantage is that we discourage application to
    1266                 :            :  * either send more filler packets or data to artificially blow up the cwnd
    1267                 :            :  * usage, and allow application-limited process to probe bw more aggressively.
    1268                 :            :  */
    1269                 :          0 : static inline bool tcp_is_cwnd_limited(const struct sock *sk)
    1270                 :            : {
    1271         [ #  # ]:          0 :         const struct tcp_sock *tp = tcp_sk(sk);
    1272                 :            : 
    1273                 :            :         /* If in slow start, ensure cwnd grows to twice what was ACKed. */
    1274         [ #  # ]:          0 :         if (tcp_in_slow_start(tp))
    1275                 :          0 :                 return tp->snd_cwnd < 2 * tp->max_packets_out;
    1276                 :            : 
    1277                 :          0 :         return tp->is_cwnd_limited;
    1278                 :            : }
    1279                 :            : 
    1280                 :            : /* BBR congestion control needs pacing.
    1281                 :            :  * Same remark for SO_MAX_PACING_RATE.
    1282                 :            :  * sch_fq packet scheduler is efficiently handling pacing,
    1283                 :            :  * but is not always installed/used.
    1284                 :            :  * Return true if TCP stack should pace packets itself.
    1285                 :            :  */
    1286                 :          0 : static inline bool tcp_needs_internal_pacing(const struct sock *sk)
    1287                 :            : {
    1288         [ #  # ]:          0 :         return smp_load_acquire(&sk->sk_pacing_status) == SK_PACING_NEEDED;
    1289                 :            : }
    1290                 :            : 
    1291                 :            : /* Return in jiffies the delay before one skb is sent.
    1292                 :            :  * If @skb is NULL, we look at EDT for next packet being sent on the socket.
    1293                 :            :  */
    1294                 :          0 : static inline unsigned long tcp_pacing_delay(const struct sock *sk,
    1295                 :            :                                              const struct sk_buff *skb)
    1296                 :            : {
    1297                 :          0 :         s64 pacing_delay = skb ? skb->tstamp : tcp_sk(sk)->tcp_wstamp_ns;
    1298                 :            : 
    1299         [ #  # ]:          0 :         pacing_delay -= tcp_sk(sk)->tcp_clock_cache;
    1300                 :            : 
    1301         [ #  # ]:          0 :         return pacing_delay > 0 ? nsecs_to_jiffies(pacing_delay) : 0;
    1302                 :            : }
    1303                 :            : 
    1304                 :          0 : static inline void tcp_reset_xmit_timer(struct sock *sk,
    1305                 :            :                                         const int what,
    1306                 :            :                                         unsigned long when,
    1307                 :            :                                         const unsigned long max_when,
    1308                 :            :                                         const struct sk_buff *skb)
    1309                 :            : {
    1310         [ #  # ]:          0 :         inet_csk_reset_xmit_timer(sk, what, when + tcp_pacing_delay(sk, skb),
    1311                 :            :                                   max_when);
    1312                 :          0 : }
    1313                 :            : 
    1314                 :            : /* Something is really bad, we could not queue an additional packet,
    1315                 :            :  * because qdisc is full or receiver sent a 0 window, or we are paced.
    1316                 :            :  * We do not want to add fuel to the fire, or abort too early,
    1317                 :            :  * so make sure the timer we arm now is at least 200ms in the future,
    1318                 :            :  * regardless of current icsk_rto value (as it could be ~2ms)
    1319                 :            :  */
    1320                 :          0 : static inline unsigned long tcp_probe0_base(const struct sock *sk)
    1321                 :            : {
    1322                 :          0 :         return max_t(unsigned long, inet_csk(sk)->icsk_rto, TCP_RTO_MIN);
    1323                 :            : }
    1324                 :            : 
    1325                 :            : /* Variant of inet_csk_rto_backoff() used for zero window probes */
    1326                 :          0 : static inline unsigned long tcp_probe0_when(const struct sock *sk,
    1327                 :            :                                             unsigned long max_when)
    1328                 :            : {
    1329                 :          0 :         u64 when = (u64)tcp_probe0_base(sk) << inet_csk(sk)->icsk_backoff;
    1330                 :            : 
    1331                 :          0 :         return (unsigned long)min_t(u64, when, max_when);
    1332                 :            : }
    1333                 :            : 
    1334                 :          0 : static inline void tcp_check_probe_timer(struct sock *sk)
    1335                 :            : {
    1336   [ #  #  #  # ]:          0 :         if (!tcp_sk(sk)->packets_out && !inet_csk(sk)->icsk_pending)
    1337                 :          0 :                 tcp_reset_xmit_timer(sk, ICSK_TIME_PROBE0,
    1338                 :            :                                      tcp_probe0_base(sk), TCP_RTO_MAX,
    1339                 :            :                                      NULL);
    1340                 :          0 : }
    1341                 :            : 
    1342                 :          0 : static inline void tcp_init_wl(struct tcp_sock *tp, u32 seq)
    1343                 :            : {
    1344   [ #  #  #  # ]:          0 :         tp->snd_wl1 = seq;
    1345                 :            : }
    1346                 :            : 
    1347                 :          0 : static inline void tcp_update_wl(struct tcp_sock *tp, u32 seq)
    1348                 :            : {
    1349   [ #  #  #  # ]:          0 :         tp->snd_wl1 = seq;
    1350                 :            : }
    1351                 :            : 
    1352                 :            : /*
    1353                 :            :  * Calculate(/check) TCP checksum
    1354                 :            :  */
    1355                 :          0 : static inline __sum16 tcp_v4_check(int len, __be32 saddr,
    1356                 :            :                                    __be32 daddr, __wsum base)
    1357                 :            : {
    1358         [ #  # ]:          0 :         return csum_tcpudp_magic(saddr, daddr, len, IPPROTO_TCP, base);
    1359                 :            : }
    1360                 :            : 
    1361                 :          0 : static inline bool tcp_checksum_complete(struct sk_buff *skb)
    1362                 :            : {
    1363   [ #  #  #  # ]:          0 :         return !skb_csum_unnecessary(skb) &&
    1364                 :          0 :                 __skb_checksum_complete(skb);
    1365                 :            : }
    1366                 :            : 
    1367                 :            : bool tcp_add_backlog(struct sock *sk, struct sk_buff *skb);
    1368                 :            : int tcp_filter(struct sock *sk, struct sk_buff *skb);
    1369                 :            : void tcp_set_state(struct sock *sk, int state);
    1370                 :            : void tcp_done(struct sock *sk);
    1371                 :            : int tcp_abort(struct sock *sk, int err);
    1372                 :            : 
    1373                 :          0 : static inline void tcp_sack_reset(struct tcp_options_received *rx_opt)
    1374                 :            : {
    1375                 :          0 :         rx_opt->dsack = 0;
    1376                 :          0 :         rx_opt->num_sacks = 0;
    1377                 :          0 : }
    1378                 :            : 
    1379                 :            : u32 tcp_default_init_rwnd(u32 mss);
    1380                 :            : void tcp_cwnd_restart(struct sock *sk, s32 delta);
    1381                 :            : 
    1382                 :          0 : static inline void tcp_slow_start_after_idle_check(struct sock *sk)
    1383                 :            : {
    1384         [ #  # ]:          0 :         const struct tcp_congestion_ops *ca_ops = inet_csk(sk)->icsk_ca_ops;
    1385         [ #  # ]:          0 :         struct tcp_sock *tp = tcp_sk(sk);
    1386                 :          0 :         s32 delta;
    1387                 :            : 
    1388   [ #  #  #  # ]:          0 :         if (!sock_net(sk)->ipv4.sysctl_tcp_slow_start_after_idle || tp->packets_out ||
    1389         [ #  # ]:          0 :             ca_ops->cong_control)
    1390                 :            :                 return;
    1391                 :          0 :         delta = tcp_jiffies32 - tp->lsndtime;
    1392         [ #  # ]:          0 :         if (delta > inet_csk(sk)->icsk_rto)
    1393                 :          0 :                 tcp_cwnd_restart(sk, delta);
    1394                 :            : }
    1395                 :            : 
    1396                 :            : /* Determine a window scaling and initial window to offer. */
    1397                 :            : void tcp_select_initial_window(const struct sock *sk, int __space,
    1398                 :            :                                __u32 mss, __u32 *rcv_wnd,
    1399                 :            :                                __u32 *window_clamp, int wscale_ok,
    1400                 :            :                                __u8 *rcv_wscale, __u32 init_rcv_wnd);
    1401                 :            : 
    1402                 :          0 : static inline int tcp_win_from_space(const struct sock *sk, int space)
    1403                 :            : {
    1404   [ #  #  #  #  :          0 :         int tcp_adv_win_scale = sock_net(sk)->ipv4.sysctl_tcp_adv_win_scale;
             #  #  #  # ]
    1405                 :            : 
    1406                 :          0 :         return tcp_adv_win_scale <= 0 ?
    1407   [ #  #  #  #  :          0 :                 (space>>(-tcp_adv_win_scale)) :
          #  #  #  #  #  
                      # ]
    1408                 :          0 :                 space - (space>>tcp_adv_win_scale);
    1409                 :            : }
    1410                 :            : 
    1411                 :            : /* Note: caller must be prepared to deal with negative returns */
    1412                 :          0 : static inline int tcp_space(const struct sock *sk)
    1413                 :            : {
    1414         [ #  # ]:          0 :         return tcp_win_from_space(sk, READ_ONCE(sk->sk_rcvbuf) -
    1415                 :          0 :                                   READ_ONCE(sk->sk_backlog.len) -
    1416                 :          0 :                                   atomic_read(&sk->sk_rmem_alloc));
    1417                 :            : }
    1418                 :            : 
    1419                 :          0 : static inline int tcp_full_space(const struct sock *sk)
    1420                 :            : {
    1421   [ #  #  #  #  :          0 :         return tcp_win_from_space(sk, READ_ONCE(sk->sk_rcvbuf));
             #  #  #  # ]
    1422                 :            : }
    1423                 :            : 
    1424                 :            : extern void tcp_openreq_init_rwin(struct request_sock *req,
    1425                 :            :                                   const struct sock *sk_listener,
    1426                 :            :                                   const struct dst_entry *dst);
    1427                 :            : 
    1428                 :            : void tcp_enter_memory_pressure(struct sock *sk);
    1429                 :            : void tcp_leave_memory_pressure(struct sock *sk);
    1430                 :            : 
    1431                 :          0 : static inline int keepalive_intvl_when(const struct tcp_sock *tp)
    1432                 :            : {
    1433         [ #  # ]:          0 :         struct net *net = sock_net((struct sock *)tp);
    1434                 :            : 
    1435         [ #  # ]:          0 :         return tp->keepalive_intvl ? : net->ipv4.sysctl_tcp_keepalive_intvl;
    1436                 :            : }
    1437                 :            : 
    1438                 :          0 : static inline int keepalive_time_when(const struct tcp_sock *tp)
    1439                 :            : {
    1440   [ #  #  #  #  :          0 :         struct net *net = sock_net((struct sock *)tp);
                   #  # ]
    1441                 :            : 
    1442   [ #  #  #  #  :          0 :         return tp->keepalive_time ? : net->ipv4.sysctl_tcp_keepalive_time;
                   #  # ]
    1443                 :            : }
    1444                 :            : 
    1445                 :          0 : static inline int keepalive_probes(const struct tcp_sock *tp)
    1446                 :            : {
    1447         [ #  # ]:          0 :         struct net *net = sock_net((struct sock *)tp);
    1448                 :            : 
    1449         [ #  # ]:          0 :         return tp->keepalive_probes ? : net->ipv4.sysctl_tcp_keepalive_probes;
    1450                 :            : }
    1451                 :            : 
    1452                 :          0 : static inline u32 keepalive_time_elapsed(const struct tcp_sock *tp)
    1453                 :            : {
    1454                 :          0 :         const struct inet_connection_sock *icsk = &tp->inet_conn;
    1455                 :            : 
    1456         [ #  # ]:          0 :         return min_t(u32, tcp_jiffies32 - icsk->icsk_ack.lrcvtime,
    1457                 :            :                           tcp_jiffies32 - tp->rcv_tstamp);
    1458                 :            : }
    1459                 :            : 
    1460                 :          0 : static inline int tcp_fin_time(const struct sock *sk)
    1461                 :            : {
    1462         [ #  # ]:          0 :         int fin_timeout = tcp_sk(sk)->linger2 ? : sock_net(sk)->ipv4.sysctl_tcp_fin_timeout;
    1463         [ #  # ]:          0 :         const int rto = inet_csk(sk)->icsk_rto;
    1464                 :            : 
    1465                 :          0 :         if (fin_timeout < (rto << 2) - (rto >> 1))
    1466                 :            :                 fin_timeout = (rto << 2) - (rto >> 1);
    1467                 :            : 
    1468         [ #  # ]:          0 :         return fin_timeout;
    1469                 :            : }
    1470                 :            : 
    1471                 :          0 : static inline bool tcp_paws_check(const struct tcp_options_received *rx_opt,
    1472                 :            :                                   int paws_win)
    1473                 :            : {
    1474         [ #  # ]:          0 :         if ((s32)(rx_opt->ts_recent - rx_opt->rcv_tsval) <= paws_win)
    1475                 :            :                 return true;
    1476         [ #  # ]:          0 :         if (unlikely(!time_before32(ktime_get_seconds(),
    1477                 :            :                                     rx_opt->ts_recent_stamp + TCP_PAWS_24DAYS)))
    1478                 :            :                 return true;
    1479                 :            :         /*
    1480                 :            :          * Some OSes send SYN and SYNACK messages with tsval=0 tsecr=0,
    1481                 :            :          * then following tcp messages have valid values. Ignore 0 value,
    1482                 :            :          * or else 'negative' tsval might forbid us to accept their packets.
    1483                 :            :          */
    1484         [ #  # ]:          0 :         if (!rx_opt->ts_recent)
    1485                 :          0 :                 return true;
    1486                 :            :         return false;
    1487                 :            : }
    1488                 :            : 
    1489                 :          0 : static inline bool tcp_paws_reject(const struct tcp_options_received *rx_opt,
    1490                 :            :                                    int rst)
    1491                 :            : {
    1492         [ #  # ]:          0 :         if (tcp_paws_check(rx_opt, 0))
    1493                 :            :                 return false;
    1494                 :            : 
    1495                 :            :         /* RST segments are not recommended to carry timestamp,
    1496                 :            :            and, if they do, it is recommended to ignore PAWS because
    1497                 :            :            "their cleanup function should take precedence over timestamps."
    1498                 :            :            Certainly, it is mistake. It is necessary to understand the reasons
    1499                 :            :            of this constraint to relax it: if peer reboots, clock may go
    1500                 :            :            out-of-sync and half-open connections will not be reset.
    1501                 :            :            Actually, the problem would be not existing if all
    1502                 :            :            the implementations followed draft about maintaining clock
    1503                 :            :            via reboots. Linux-2.2 DOES NOT!
    1504                 :            : 
    1505                 :            :            However, we can relax time bounds for RST segments to MSL.
    1506                 :            :          */
    1507   [ #  #  #  # ]:          0 :         if (rst && !time_before32(ktime_get_seconds(),
    1508                 :            :                                   rx_opt->ts_recent_stamp + TCP_PAWS_MSL))
    1509                 :          0 :                 return false;
    1510                 :            :         return true;
    1511                 :            : }
    1512                 :            : 
    1513                 :            : bool tcp_oow_rate_limited(struct net *net, const struct sk_buff *skb,
    1514                 :            :                           int mib_idx, u32 *last_oow_ack_time);
    1515                 :            : 
    1516                 :          3 : static inline void tcp_mib_init(struct net *net)
    1517                 :            : {
    1518                 :            :         /* See RFC 2012 */
    1519                 :          3 :         TCP_ADD_STATS(net, TCP_MIB_RTOALGORITHM, 1);
    1520                 :          3 :         TCP_ADD_STATS(net, TCP_MIB_RTOMIN, TCP_RTO_MIN*1000/HZ);
    1521                 :          3 :         TCP_ADD_STATS(net, TCP_MIB_RTOMAX, TCP_RTO_MAX*1000/HZ);
    1522                 :          3 :         TCP_ADD_STATS(net, TCP_MIB_MAXCONN, -1);
    1523                 :            : }
    1524                 :            : 
    1525                 :            : /* from STCP */
    1526                 :          0 : static inline void tcp_clear_retrans_hints_partial(struct tcp_sock *tp)
    1527                 :            : {
    1528         [ #  # ]:          0 :         tp->lost_skb_hint = NULL;
    1529                 :            : }
    1530                 :            : 
    1531                 :          0 : static inline void tcp_clear_all_retrans_hints(struct tcp_sock *tp)
    1532                 :            : {
    1533                 :          0 :         tcp_clear_retrans_hints_partial(tp);
    1534                 :          0 :         tp->retransmit_skb_hint = NULL;
    1535                 :          0 : }
    1536                 :            : 
    1537                 :            : union tcp_md5_addr {
    1538                 :            :         struct in_addr  a4;
    1539                 :            : #if IS_ENABLED(CONFIG_IPV6)
    1540                 :            :         struct in6_addr a6;
    1541                 :            : #endif
    1542                 :            : };
    1543                 :            : 
    1544                 :            : /* - key database */
    1545                 :            : struct tcp_md5sig_key {
    1546                 :            :         struct hlist_node       node;
    1547                 :            :         u8                      keylen;
    1548                 :            :         u8                      family; /* AF_INET or AF_INET6 */
    1549                 :            :         u8                      prefixlen;
    1550                 :            :         union tcp_md5_addr      addr;
    1551                 :            :         int                     l3index; /* set if key added with L3 scope */
    1552                 :            :         u8                      key[TCP_MD5SIG_MAXKEYLEN];
    1553                 :            :         struct rcu_head         rcu;
    1554                 :            : };
    1555                 :            : 
    1556                 :            : /* - sock block */
    1557                 :            : struct tcp_md5sig_info {
    1558                 :            :         struct hlist_head       head;
    1559                 :            :         struct rcu_head         rcu;
    1560                 :            : };
    1561                 :            : 
    1562                 :            : /* - pseudo header */
    1563                 :            : struct tcp4_pseudohdr {
    1564                 :            :         __be32          saddr;
    1565                 :            :         __be32          daddr;
    1566                 :            :         __u8            pad;
    1567                 :            :         __u8            protocol;
    1568                 :            :         __be16          len;
    1569                 :            : };
    1570                 :            : 
    1571                 :            : struct tcp6_pseudohdr {
    1572                 :            :         struct in6_addr saddr;
    1573                 :            :         struct in6_addr daddr;
    1574                 :            :         __be32          len;
    1575                 :            :         __be32          protocol;       /* including padding */
    1576                 :            : };
    1577                 :            : 
    1578                 :            : union tcp_md5sum_block {
    1579                 :            :         struct tcp4_pseudohdr ip4;
    1580                 :            : #if IS_ENABLED(CONFIG_IPV6)
    1581                 :            :         struct tcp6_pseudohdr ip6;
    1582                 :            : #endif
    1583                 :            : };
    1584                 :            : 
    1585                 :            : /* - pool: digest algorithm, hash description and scratch buffer */
    1586                 :            : struct tcp_md5sig_pool {
    1587                 :            :         struct ahash_request    *md5_req;
    1588                 :            :         void                    *scratch;
    1589                 :            : };
    1590                 :            : 
    1591                 :            : /* - functions */
    1592                 :            : int tcp_v4_md5_hash_skb(char *md5_hash, const struct tcp_md5sig_key *key,
    1593                 :            :                         const struct sock *sk, const struct sk_buff *skb);
    1594                 :            : int tcp_md5_do_add(struct sock *sk, const union tcp_md5_addr *addr,
    1595                 :            :                    int family, u8 prefixlen, int l3index,
    1596                 :            :                    const u8 *newkey, u8 newkeylen, gfp_t gfp);
    1597                 :            : int tcp_md5_do_del(struct sock *sk, const union tcp_md5_addr *addr,
    1598                 :            :                    int family, u8 prefixlen, int l3index);
    1599                 :            : struct tcp_md5sig_key *tcp_v4_md5_lookup(const struct sock *sk,
    1600                 :            :                                          const struct sock *addr_sk);
    1601                 :            : 
    1602                 :            : #ifdef CONFIG_TCP_MD5SIG
    1603                 :            : #include <linux/jump_label.h>
    1604                 :            : extern struct static_key_false tcp_md5_needed;
    1605                 :            : struct tcp_md5sig_key *__tcp_md5_do_lookup(const struct sock *sk, int l3index,
    1606                 :            :                                            const union tcp_md5_addr *addr,
    1607                 :            :                                            int family);
    1608                 :            : static inline struct tcp_md5sig_key *
    1609                 :          0 : tcp_md5_do_lookup(const struct sock *sk, int l3index,
    1610                 :            :                   const union tcp_md5_addr *addr, int family)
    1611                 :            : {
    1612   [ #  #  #  # ]:          0 :         if (!static_branch_unlikely(&tcp_md5_needed))
    1613                 :            :                 return NULL;
    1614                 :          0 :         return __tcp_md5_do_lookup(sk, l3index, addr, family);
    1615                 :            : }
    1616                 :            : 
    1617                 :            : #define tcp_twsk_md5_key(twsk)  ((twsk)->tw_md5_key)
    1618                 :            : #else
    1619                 :            : static inline struct tcp_md5sig_key *
    1620                 :            : tcp_md5_do_lookup(const struct sock *sk, int l3index,
    1621                 :            :                   const union tcp_md5_addr *addr, int family)
    1622                 :            : {
    1623                 :            :         return NULL;
    1624                 :            : }
    1625                 :            : #define tcp_twsk_md5_key(twsk)  NULL
    1626                 :            : #endif
    1627                 :            : 
    1628                 :            : bool tcp_alloc_md5sig_pool(void);
    1629                 :            : 
    1630                 :            : struct tcp_md5sig_pool *tcp_get_md5sig_pool(void);
    1631                 :          0 : static inline void tcp_put_md5sig_pool(void)
    1632                 :            : {
    1633                 :          0 :         local_bh_enable();
    1634                 :          0 : }
    1635                 :            : 
    1636                 :            : int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *, const struct sk_buff *,
    1637                 :            :                           unsigned int header_len);
    1638                 :            : int tcp_md5_hash_key(struct tcp_md5sig_pool *hp,
    1639                 :            :                      const struct tcp_md5sig_key *key);
    1640                 :            : 
    1641                 :            : /* From tcp_fastopen.c */
    1642                 :            : void tcp_fastopen_cache_get(struct sock *sk, u16 *mss,
    1643                 :            :                             struct tcp_fastopen_cookie *cookie);
    1644                 :            : void tcp_fastopen_cache_set(struct sock *sk, u16 mss,
    1645                 :            :                             struct tcp_fastopen_cookie *cookie, bool syn_lost,
    1646                 :            :                             u16 try_exp);
    1647                 :            : struct tcp_fastopen_request {
    1648                 :            :         /* Fast Open cookie. Size 0 means a cookie request */
    1649                 :            :         struct tcp_fastopen_cookie      cookie;
    1650                 :            :         struct msghdr                   *data;  /* data in MSG_FASTOPEN */
    1651                 :            :         size_t                          size;
    1652                 :            :         int                             copied; /* queued in tcp_connect() */
    1653                 :            :         struct ubuf_info                *uarg;
    1654                 :            : };
    1655                 :            : void tcp_free_fastopen_req(struct tcp_sock *tp);
    1656                 :            : void tcp_fastopen_destroy_cipher(struct sock *sk);
    1657                 :            : void tcp_fastopen_ctx_destroy(struct net *net);
    1658                 :            : int tcp_fastopen_reset_cipher(struct net *net, struct sock *sk,
    1659                 :            :                               void *primary_key, void *backup_key);
    1660                 :            : void tcp_fastopen_add_skb(struct sock *sk, struct sk_buff *skb);
    1661                 :            : struct sock *tcp_try_fastopen(struct sock *sk, struct sk_buff *skb,
    1662                 :            :                               struct request_sock *req,
    1663                 :            :                               struct tcp_fastopen_cookie *foc,
    1664                 :            :                               const struct dst_entry *dst);
    1665                 :            : void tcp_fastopen_init_key_once(struct net *net);
    1666                 :            : bool tcp_fastopen_cookie_check(struct sock *sk, u16 *mss,
    1667                 :            :                              struct tcp_fastopen_cookie *cookie);
    1668                 :            : bool tcp_fastopen_defer_connect(struct sock *sk, int *err);
    1669                 :            : #define TCP_FASTOPEN_KEY_LENGTH sizeof(siphash_key_t)
    1670                 :            : #define TCP_FASTOPEN_KEY_MAX 2
    1671                 :            : #define TCP_FASTOPEN_KEY_BUF_LENGTH \
    1672                 :            :         (TCP_FASTOPEN_KEY_LENGTH * TCP_FASTOPEN_KEY_MAX)
    1673                 :            : 
    1674                 :            : /* Fastopen key context */
    1675                 :            : struct tcp_fastopen_context {
    1676                 :            :         siphash_key_t   key[TCP_FASTOPEN_KEY_MAX];
    1677                 :            :         int             num;
    1678                 :            :         struct rcu_head rcu;
    1679                 :            : };
    1680                 :            : 
    1681                 :            : extern unsigned int sysctl_tcp_fastopen_blackhole_timeout;
    1682                 :            : void tcp_fastopen_active_disable(struct sock *sk);
    1683                 :            : bool tcp_fastopen_active_should_disable(struct sock *sk);
    1684                 :            : void tcp_fastopen_active_disable_ofo_check(struct sock *sk);
    1685                 :            : void tcp_fastopen_active_detect_blackhole(struct sock *sk, bool expired);
    1686                 :            : 
    1687                 :            : /* Caller needs to wrap with rcu_read_(un)lock() */
    1688                 :            : static inline
    1689                 :          0 : struct tcp_fastopen_context *tcp_fastopen_get_ctx(const struct sock *sk)
    1690                 :            : {
    1691                 :          0 :         struct tcp_fastopen_context *ctx;
    1692                 :            : 
    1693   [ #  #  #  # ]:          0 :         ctx = rcu_dereference(inet_csk(sk)->icsk_accept_queue.fastopenq.ctx);
    1694   [ #  #  #  # ]:          0 :         if (!ctx)
    1695                 :          0 :                 ctx = rcu_dereference(sock_net(sk)->ipv4.tcp_fastopen_ctx);
    1696   [ #  #  #  # ]:          0 :         return ctx;
    1697                 :            : }
    1698                 :            : 
    1699                 :            : static inline
    1700                 :          0 : bool tcp_fastopen_cookie_match(const struct tcp_fastopen_cookie *foc,
    1701                 :            :                                const struct tcp_fastopen_cookie *orig)
    1702                 :            : {
    1703         [ #  # ]:          0 :         if (orig->len == TCP_FASTOPEN_COOKIE_SIZE &&
    1704         [ #  # ]:          0 :             orig->len == foc->len &&
    1705         [ #  # ]:          0 :             !memcmp(orig->val, foc->val, foc->len))
    1706                 :          0 :                 return true;
    1707                 :            :         return false;
    1708                 :            : }
    1709                 :            : 
    1710                 :            : static inline
    1711                 :          0 : int tcp_fastopen_context_len(const struct tcp_fastopen_context *ctx)
    1712                 :            : {
    1713         [ #  # ]:          0 :         return ctx->num;
    1714                 :            : }
    1715                 :            : 
    1716                 :            : /* Latencies incurred by various limits for a sender. They are
    1717                 :            :  * chronograph-like stats that are mutually exclusive.
    1718                 :            :  */
    1719                 :            : enum tcp_chrono {
    1720                 :            :         TCP_CHRONO_UNSPEC,
    1721                 :            :         TCP_CHRONO_BUSY, /* Actively sending data (non-empty write queue) */
    1722                 :            :         TCP_CHRONO_RWND_LIMITED, /* Stalled by insufficient receive window */
    1723                 :            :         TCP_CHRONO_SNDBUF_LIMITED, /* Stalled by insufficient send buffer */
    1724                 :            :         __TCP_CHRONO_MAX,
    1725                 :            : };
    1726                 :            : 
    1727                 :            : void tcp_chrono_start(struct sock *sk, const enum tcp_chrono type);
    1728                 :            : void tcp_chrono_stop(struct sock *sk, const enum tcp_chrono type);
    1729                 :            : 
    1730                 :            : /* This helper is needed, because skb->tcp_tsorted_anchor uses
    1731                 :            :  * the same memory storage than skb->destructor/_skb_refdst
    1732                 :            :  */
    1733                 :          0 : static inline void tcp_skb_tsorted_anchor_cleanup(struct sk_buff *skb)
    1734                 :            : {
    1735                 :          0 :         skb->destructor = NULL;
    1736                 :          0 :         skb->_skb_refdst = 0UL;
    1737                 :            : }
    1738                 :            : 
    1739                 :            : #define tcp_skb_tsorted_save(skb) {             \
    1740                 :            :         unsigned long _save = skb->_skb_refdst;      \
    1741                 :            :         skb->_skb_refdst = 0UL;
    1742                 :            : 
    1743                 :            : #define tcp_skb_tsorted_restore(skb)            \
    1744                 :            :         skb->_skb_refdst = _save;            \
    1745                 :            : }
    1746                 :            : 
    1747                 :            : void tcp_write_queue_purge(struct sock *sk);
    1748                 :            : 
    1749                 :          0 : static inline struct sk_buff *tcp_rtx_queue_head(const struct sock *sk)
    1750                 :            : {
    1751   [ #  #  #  #  :          0 :         return skb_rb_first(&sk->tcp_rtx_queue);
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1752                 :            : }
    1753                 :            : 
    1754                 :          0 : static inline struct sk_buff *tcp_rtx_queue_tail(const struct sock *sk)
    1755                 :            : {
    1756         [ #  # ]:          0 :         return skb_rb_last(&sk->tcp_rtx_queue);
    1757                 :            : }
    1758                 :            : 
    1759                 :            : static inline struct sk_buff *tcp_write_queue_head(const struct sock *sk)
    1760                 :            : {
    1761                 :            :         return skb_peek(&sk->sk_write_queue);
    1762                 :            : }
    1763                 :            : 
    1764                 :          0 : static inline struct sk_buff *tcp_write_queue_tail(const struct sock *sk)
    1765                 :            : {
    1766   [ #  #  #  #  :          0 :         return skb_peek_tail(&sk->sk_write_queue);
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1767                 :            : }
    1768                 :            : 
    1769                 :            : #define tcp_for_write_queue_from_safe(skb, tmp, sk)                     \
    1770                 :            :         skb_queue_walk_from_safe(&(sk)->sk_write_queue, skb, tmp)
    1771                 :            : 
    1772                 :          0 : static inline struct sk_buff *tcp_send_head(const struct sock *sk)
    1773                 :            : {
    1774   [ #  #  #  #  :          0 :         return skb_peek(&sk->sk_write_queue);
          #  #  #  #  #  
             #  #  #  #  
                      # ]
    1775                 :            : }
    1776                 :            : 
    1777                 :          0 : static inline bool tcp_skb_is_last(const struct sock *sk,
    1778                 :            :                                    const struct sk_buff *skb)
    1779                 :            : {
    1780         [ #  # ]:          0 :         return skb_queue_is_last(&sk->sk_write_queue, skb);
    1781                 :            : }
    1782                 :            : 
    1783                 :            : /**
    1784                 :            :  * tcp_write_queue_empty - test if any payload (or FIN) is available in write queue
    1785                 :            :  * @sk: socket
    1786                 :            :  *
    1787                 :            :  * Since the write queue can have a temporary empty skb in it,
    1788                 :            :  * we must not use "return skb_queue_empty(&sk->sk_write_queue)"
    1789                 :            :  */
    1790                 :          0 : static inline bool tcp_write_queue_empty(const struct sock *sk)
    1791                 :            : {
    1792   [ #  #  #  #  :          0 :         const struct tcp_sock *tp = tcp_sk(sk);
          #  #  #  #  #  
                      # ]
    1793                 :            : 
    1794   [ #  #  #  #  :          0 :         return tp->write_seq == tp->snd_nxt;
                   #  # ]
    1795                 :            : }
    1796                 :            : 
    1797                 :          0 : static inline bool tcp_rtx_queue_empty(const struct sock *sk)
    1798                 :            : {
    1799         [ #  # ]:          0 :         return RB_EMPTY_ROOT(&sk->tcp_rtx_queue);
    1800                 :            : }
    1801                 :            : 
    1802                 :          0 : static inline bool tcp_rtx_and_write_queues_empty(const struct sock *sk)
    1803                 :            : {
    1804   [ #  #  #  #  :          0 :         return tcp_rtx_queue_empty(sk) && tcp_write_queue_empty(sk);
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1805                 :            : }
    1806                 :            : 
    1807                 :          0 : static inline void tcp_add_write_queue_tail(struct sock *sk, struct sk_buff *skb)
    1808                 :            : {
    1809         [ #  # ]:          0 :         __skb_queue_tail(&sk->sk_write_queue, skb);
    1810                 :            : 
    1811                 :            :         /* Queue it, remembering where we must start sending. */
    1812         [ #  # ]:          0 :         if (sk->sk_write_queue.next == skb)
    1813         [ #  # ]:          0 :                 tcp_chrono_start(sk, TCP_CHRONO_BUSY);
    1814                 :          0 : }
    1815                 :            : 
    1816                 :            : /* Insert new before skb on the write queue of sk.  */
    1817                 :          0 : static inline void tcp_insert_write_queue_before(struct sk_buff *new,
    1818                 :            :                                                   struct sk_buff *skb,
    1819                 :            :                                                   struct sock *sk)
    1820                 :            : {
    1821         [ #  # ]:          0 :         __skb_queue_before(&sk->sk_write_queue, skb, new);
    1822                 :            : }
    1823                 :            : 
    1824                 :          0 : static inline void tcp_unlink_write_queue(struct sk_buff *skb, struct sock *sk)
    1825                 :            : {
    1826                 :          0 :         tcp_skb_tsorted_anchor_cleanup(skb);
    1827         [ #  # ]:          0 :         __skb_unlink(skb, &sk->sk_write_queue);
    1828                 :            : }
    1829                 :            : 
    1830                 :            : void tcp_rbtree_insert(struct rb_root *root, struct sk_buff *skb);
    1831                 :            : 
    1832                 :          0 : static inline void tcp_rtx_queue_unlink(struct sk_buff *skb, struct sock *sk)
    1833                 :            : {
    1834                 :          0 :         tcp_skb_tsorted_anchor_cleanup(skb);
    1835                 :          0 :         rb_erase(&skb->rbnode, &sk->tcp_rtx_queue);
    1836                 :            : }
    1837                 :            : 
    1838                 :          0 : static inline void tcp_rtx_queue_unlink_and_free(struct sk_buff *skb, struct sock *sk)
    1839                 :            : {
    1840                 :          0 :         list_del(&skb->tcp_tsorted_anchor);
    1841                 :          0 :         tcp_rtx_queue_unlink(skb, sk);
    1842                 :          0 :         sk_wmem_free_skb(sk, skb);
    1843                 :          0 : }
    1844                 :            : 
    1845                 :          0 : static inline void tcp_push_pending_frames(struct sock *sk)
    1846                 :            : {
    1847   [ #  #  #  # ]:          0 :         if (tcp_send_head(sk)) {
    1848                 :          0 :                 struct tcp_sock *tp = tcp_sk(sk);
    1849                 :            : 
    1850                 :          0 :                 __tcp_push_pending_frames(sk, tcp_current_mss(sk), tp->nonagle);
    1851                 :            :         }
    1852                 :          0 : }
    1853                 :            : 
    1854                 :            : /* Start sequence of the skb just after the highest skb with SACKed
    1855                 :            :  * bit, valid only if sacked_out > 0 or when the caller has ensured
    1856                 :            :  * validity by itself.
    1857                 :            :  */
    1858                 :          0 : static inline u32 tcp_highest_sack_seq(struct tcp_sock *tp)
    1859                 :            : {
    1860   [ #  #  #  #  :          0 :         if (!tp->sacked_out)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1861                 :          0 :                 return tp->snd_una;
    1862                 :            : 
    1863   [ #  #  #  #  :          0 :         if (tp->highest_sack == NULL)
          #  #  #  #  #  
          #  #  #  #  #  
                   #  # ]
    1864                 :          0 :                 return tp->snd_nxt;
    1865                 :            : 
    1866                 :          0 :         return TCP_SKB_CB(tp->highest_sack)->seq;
    1867                 :            : }
    1868                 :            : 
    1869                 :          0 : static inline void tcp_advance_highest_sack(struct sock *sk, struct sk_buff *skb)
    1870                 :            : {
    1871   [ #  #  #  # ]:          0 :         tcp_sk(sk)->highest_sack = skb_rb_next(skb);
    1872                 :          0 : }
    1873                 :            : 
    1874                 :          0 : static inline struct sk_buff *tcp_highest_sack(struct sock *sk)
    1875                 :            : {
    1876   [ #  #  #  #  :          0 :         return tcp_sk(sk)->highest_sack;
                   #  # ]
    1877                 :            : }
    1878                 :            : 
    1879                 :          0 : static inline void tcp_highest_sack_reset(struct sock *sk)
    1880                 :            : {
    1881                 :          0 :         tcp_sk(sk)->highest_sack = tcp_rtx_queue_head(sk);
    1882                 :          0 : }
    1883                 :            : 
    1884                 :            : /* Called when old skb is about to be deleted and replaced by new skb */
    1885                 :          0 : static inline void tcp_highest_sack_replace(struct sock *sk,
    1886                 :            :                                             struct sk_buff *old,
    1887                 :            :                                             struct sk_buff *new)
    1888                 :            : {
    1889   [ #  #  #  #  :          0 :         if (old == tcp_highest_sack(sk))
                   #  # ]
    1890                 :          0 :                 tcp_sk(sk)->highest_sack = new;
    1891                 :            : }
    1892                 :            : 
    1893                 :            : /* This helper checks if socket has IP_TRANSPARENT set */
    1894                 :          0 : static inline bool inet_sk_transparent(const struct sock *sk)
    1895                 :            : {
    1896      [ #  #  # ]:          0 :         switch (sk->sk_state) {
    1897                 :            :         case TCP_TIME_WAIT:
    1898                 :          0 :                 return inet_twsk(sk)->tw_transparent;
    1899                 :            :         case TCP_NEW_SYN_RECV:
    1900                 :          0 :                 return inet_rsk(inet_reqsk(sk))->no_srccheck;
    1901                 :            :         }
    1902                 :          0 :         return inet_sk(sk)->transparent;
    1903                 :            : }
    1904                 :            : 
    1905                 :            : /* Determines whether this is a thin stream (which may suffer from
    1906                 :            :  * increased latency). Used to trigger latency-reducing mechanisms.
    1907                 :            :  */
    1908                 :          0 : static inline bool tcp_stream_is_thin(struct tcp_sock *tp)
    1909                 :            : {
    1910   [ #  #  #  #  :          0 :         return tp->packets_out < 4 && !tcp_in_initial_slowstart(tp);
                   #  # ]
    1911                 :            : }
    1912                 :            : 
    1913                 :            : /* /proc */
    1914                 :            : enum tcp_seq_states {
    1915                 :            :         TCP_SEQ_STATE_LISTENING,
    1916                 :            :         TCP_SEQ_STATE_ESTABLISHED,
    1917                 :            : };
    1918                 :            : 
    1919                 :            : void *tcp_seq_start(struct seq_file *seq, loff_t *pos);
    1920                 :            : void *tcp_seq_next(struct seq_file *seq, void *v, loff_t *pos);
    1921                 :            : void tcp_seq_stop(struct seq_file *seq, void *v);
    1922                 :            : 
    1923                 :            : struct tcp_seq_afinfo {
    1924                 :            :         sa_family_t                     family;
    1925                 :            : };
    1926                 :            : 
    1927                 :            : struct tcp_iter_state {
    1928                 :            :         struct seq_net_private  p;
    1929                 :            :         enum tcp_seq_states     state;
    1930                 :            :         struct sock             *syn_wait_sk;
    1931                 :            :         int                     bucket, offset, sbucket, num;
    1932                 :            :         loff_t                  last_pos;
    1933                 :            : };
    1934                 :            : 
    1935                 :            : extern struct request_sock_ops tcp_request_sock_ops;
    1936                 :            : extern struct request_sock_ops tcp6_request_sock_ops;
    1937                 :            : 
    1938                 :            : void tcp_v4_destroy_sock(struct sock *sk);
    1939                 :            : 
    1940                 :            : struct sk_buff *tcp_gso_segment(struct sk_buff *skb,
    1941                 :            :                                 netdev_features_t features);
    1942                 :            : struct sk_buff *tcp_gro_receive(struct list_head *head, struct sk_buff *skb);
    1943                 :            : int tcp_gro_complete(struct sk_buff *skb);
    1944                 :            : 
    1945                 :            : void __tcp_v4_send_check(struct sk_buff *skb, __be32 saddr, __be32 daddr);
    1946                 :            : 
    1947                 :          0 : static inline u32 tcp_notsent_lowat(const struct tcp_sock *tp)
    1948                 :            : {
    1949                 :          0 :         struct net *net = sock_net((struct sock *)tp);
    1950         [ #  # ]:          0 :         return tp->notsent_lowat ?: net->ipv4.sysctl_tcp_notsent_lowat;
    1951                 :            : }
    1952                 :            : 
    1953                 :            : /* @wake is one when sk_stream_write_space() calls us.
    1954                 :            :  * This sends EPOLLOUT only if notsent_bytes is half the limit.
    1955                 :            :  * This mimics the strategy used in sock_def_write_space().
    1956                 :            :  */
    1957                 :          0 : static inline bool tcp_stream_memory_free(const struct sock *sk, int wake)
    1958                 :            : {
    1959         [ #  # ]:          0 :         const struct tcp_sock *tp = tcp_sk(sk);
    1960         [ #  # ]:          0 :         u32 notsent_bytes = READ_ONCE(tp->write_seq) -
    1961                 :          0 :                             READ_ONCE(tp->snd_nxt);
    1962                 :            : 
    1963         [ #  # ]:          0 :         return (notsent_bytes << wake) < tcp_notsent_lowat(tp);
    1964                 :            : }
    1965                 :            : 
    1966                 :            : #ifdef CONFIG_PROC_FS
    1967                 :            : int tcp4_proc_init(void);
    1968                 :            : void tcp4_proc_exit(void);
    1969                 :            : #endif
    1970                 :            : 
    1971                 :            : int tcp_rtx_synack(const struct sock *sk, struct request_sock *req);
    1972                 :            : int tcp_conn_request(struct request_sock_ops *rsk_ops,
    1973                 :            :                      const struct tcp_request_sock_ops *af_ops,
    1974                 :            :                      struct sock *sk, struct sk_buff *skb);
    1975                 :            : 
    1976                 :            : /* TCP af-specific functions */
    1977                 :            : struct tcp_sock_af_ops {
    1978                 :            : #ifdef CONFIG_TCP_MD5SIG
    1979                 :            :         struct tcp_md5sig_key   *(*md5_lookup) (const struct sock *sk,
    1980                 :            :                                                 const struct sock *addr_sk);
    1981                 :            :         int             (*calc_md5_hash)(char *location,
    1982                 :            :                                          const struct tcp_md5sig_key *md5,
    1983                 :            :                                          const struct sock *sk,
    1984                 :            :                                          const struct sk_buff *skb);
    1985                 :            :         int             (*md5_parse)(struct sock *sk,
    1986                 :            :                                      int optname,
    1987                 :            :                                      char __user *optval,
    1988                 :            :                                      int optlen);
    1989                 :            : #endif
    1990                 :            : };
    1991                 :            : 
    1992                 :            : struct tcp_request_sock_ops {
    1993                 :            :         u16 mss_clamp;
    1994                 :            : #ifdef CONFIG_TCP_MD5SIG
    1995                 :            :         struct tcp_md5sig_key *(*req_md5_lookup)(const struct sock *sk,
    1996                 :            :                                                  const struct sock *addr_sk);
    1997                 :            :         int             (*calc_md5_hash) (char *location,
    1998                 :            :                                           const struct tcp_md5sig_key *md5,
    1999                 :            :                                           const struct sock *sk,
    2000                 :            :                                           const struct sk_buff *skb);
    2001                 :            : #endif
    2002                 :            :         void (*init_req)(struct request_sock *req,
    2003                 :            :                          const struct sock *sk_listener,
    2004                 :            :                          struct sk_buff *skb);
    2005                 :            : #ifdef CONFIG_SYN_COOKIES
    2006                 :            :         __u32 (*cookie_init_seq)(const struct sk_buff *skb,
    2007                 :            :                                  __u16 *mss);
    2008                 :            : #endif
    2009                 :            :         struct dst_entry *(*route_req)(const struct sock *sk, struct flowi *fl,
    2010                 :            :                                        const struct request_sock *req);
    2011                 :            :         u32 (*init_seq)(const struct sk_buff *skb);
    2012                 :            :         u32 (*init_ts_off)(const struct net *net, const struct sk_buff *skb);
    2013                 :            :         int (*send_synack)(const struct sock *sk, struct dst_entry *dst,
    2014                 :            :                            struct flowi *fl, struct request_sock *req,
    2015                 :            :                            struct tcp_fastopen_cookie *foc,
    2016                 :            :                            enum tcp_synack_type synack_type);
    2017                 :            : };
    2018                 :            : 
    2019                 :            : extern const struct tcp_request_sock_ops tcp_request_sock_ipv4_ops;
    2020                 :            : #if IS_ENABLED(CONFIG_IPV6)
    2021                 :            : extern const struct tcp_request_sock_ops tcp_request_sock_ipv6_ops;
    2022                 :            : #endif
    2023                 :            : 
    2024                 :            : #ifdef CONFIG_SYN_COOKIES
    2025                 :            : static inline __u32 cookie_init_sequence(const struct tcp_request_sock_ops *ops,
    2026                 :            :                                          const struct sock *sk, struct sk_buff *skb,
    2027                 :            :                                          __u16 *mss)
    2028                 :            : {
    2029                 :            :         tcp_synq_overflow(sk);
    2030                 :            :         __NET_INC_STATS(sock_net(sk), LINUX_MIB_SYNCOOKIESSENT);
    2031                 :            :         return ops->cookie_init_seq(skb, mss);
    2032                 :            : }
    2033                 :            : #else
    2034                 :            : static inline __u32 cookie_init_sequence(const struct tcp_request_sock_ops *ops,
    2035                 :            :                                          const struct sock *sk, struct sk_buff *skb,
    2036                 :            :                                          __u16 *mss)
    2037                 :            : {
    2038                 :            :         return 0;
    2039                 :            : }
    2040                 :            : #endif
    2041                 :            : 
    2042                 :            : int tcpv4_offload_init(void);
    2043                 :            : 
    2044                 :            : void tcp_v4_init(void);
    2045                 :            : void tcp_init(void);
    2046                 :            : 
    2047                 :            : /* tcp_recovery.c */
    2048                 :            : void tcp_mark_skb_lost(struct sock *sk, struct sk_buff *skb);
    2049                 :            : void tcp_newreno_mark_lost(struct sock *sk, bool snd_una_advanced);
    2050                 :            : extern s32 tcp_rack_skb_timeout(struct tcp_sock *tp, struct sk_buff *skb,
    2051                 :            :                                 u32 reo_wnd);
    2052                 :            : extern void tcp_rack_mark_lost(struct sock *sk);
    2053                 :            : extern void tcp_rack_advance(struct tcp_sock *tp, u8 sacked, u32 end_seq,
    2054                 :            :                              u64 xmit_time);
    2055                 :            : extern void tcp_rack_reo_timeout(struct sock *sk);
    2056                 :            : extern void tcp_rack_update_reo_wnd(struct sock *sk, struct rate_sample *rs);
    2057                 :            : 
    2058                 :            : /* At how many usecs into the future should the RTO fire? */
    2059                 :          0 : static inline s64 tcp_rto_delta_us(const struct sock *sk)
    2060                 :            : {
    2061                 :          0 :         const struct sk_buff *skb = tcp_rtx_queue_head(sk);
    2062                 :          0 :         u32 rto = inet_csk(sk)->icsk_rto;
    2063                 :          0 :         u64 rto_time_stamp_us = tcp_skb_timestamp_us(skb) + jiffies_to_usecs(rto);
    2064                 :            : 
    2065                 :          0 :         return rto_time_stamp_us - tcp_sk(sk)->tcp_mstamp;
    2066                 :            : }
    2067                 :            : 
    2068                 :            : /*
    2069                 :            :  * Save and compile IPv4 options, return a pointer to it
    2070                 :            :  */
    2071                 :          0 : static inline struct ip_options_rcu *tcp_v4_save_options(struct net *net,
    2072                 :            :                                                          struct sk_buff *skb)
    2073                 :            : {
    2074                 :          0 :         const struct ip_options *opt = &TCP_SKB_CB(skb)->header.h4.opt;
    2075                 :          0 :         struct ip_options_rcu *dopt = NULL;
    2076                 :            : 
    2077         [ #  # ]:          0 :         if (opt->optlen) {
    2078                 :          0 :                 int opt_size = sizeof(*dopt) + opt->optlen;
    2079                 :            : 
    2080         [ #  # ]:          0 :                 dopt = kmalloc(opt_size, GFP_ATOMIC);
    2081   [ #  #  #  # ]:          0 :                 if (dopt && __ip_options_echo(net, &dopt->opt, skb, opt)) {
    2082                 :          0 :                         kfree(dopt);
    2083                 :          0 :                         dopt = NULL;
    2084                 :            :                 }
    2085                 :            :         }
    2086                 :          0 :         return dopt;
    2087                 :            : }
    2088                 :            : 
    2089                 :            : /* locally generated TCP pure ACKs have skb->truesize == 2
    2090                 :            :  * (check tcp_send_ack() in net/ipv4/tcp_output.c )
    2091                 :            :  * This is much faster than dissecting the packet to find out.
    2092                 :            :  * (Think of GRE encapsulations, IPv4, IPv6, ...)
    2093                 :            :  */
    2094                 :          0 : static inline bool skb_is_tcp_pure_ack(const struct sk_buff *skb)
    2095                 :            : {
    2096         [ #  # ]:          0 :         return skb->truesize == 2;
    2097                 :            : }
    2098                 :            : 
    2099                 :          0 : static inline void skb_set_tcp_pure_ack(struct sk_buff *skb)
    2100                 :            : {
    2101                 :          0 :         skb->truesize = 2;
    2102                 :            : }
    2103                 :            : 
    2104                 :          0 : static inline int tcp_inq(struct sock *sk)
    2105                 :            : {
    2106         [ #  # ]:          0 :         struct tcp_sock *tp = tcp_sk(sk);
    2107                 :          0 :         int answ;
    2108                 :            : 
    2109         [ #  # ]:          0 :         if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV)) {
    2110                 :            :                 answ = 0;
    2111         [ #  # ]:          0 :         } else if (sock_flag(sk, SOCK_URGINLINE) ||
    2112         [ #  # ]:          0 :                    !tp->urg_data ||
    2113         [ #  # ]:          0 :                    before(tp->urg_seq, tp->copied_seq) ||
    2114         [ #  # ]:          0 :                    !before(tp->urg_seq, tp->rcv_nxt)) {
    2115                 :            : 
    2116                 :          0 :                 answ = tp->rcv_nxt - tp->copied_seq;
    2117                 :            : 
    2118                 :            :                 /* Subtract 1, if FIN was received */
    2119   [ #  #  #  # ]:          0 :                 if (answ && sock_flag(sk, SOCK_DONE))
    2120                 :          0 :                         answ--;
    2121                 :            :         } else {
    2122                 :            :                 answ = tp->urg_seq - tp->copied_seq;
    2123                 :            :         }
    2124                 :            : 
    2125                 :          0 :         return answ;
    2126                 :            : }
    2127                 :            : 
    2128                 :            : int tcp_peek_len(struct socket *sock);
    2129                 :            : 
    2130                 :          0 : static inline void tcp_segs_in(struct tcp_sock *tp, const struct sk_buff *skb)
    2131                 :            : {
    2132                 :          0 :         u16 segs_in;
    2133                 :            : 
    2134         [ #  # ]:          0 :         segs_in = max_t(u16, 1, skb_shinfo(skb)->gso_segs);
    2135                 :          0 :         tp->segs_in += segs_in;
    2136         [ #  # ]:          0 :         if (skb->len > tcp_hdrlen(skb))
    2137                 :          0 :                 tp->data_segs_in += segs_in;
    2138                 :            : }
    2139                 :            : 
    2140                 :            : /*
    2141                 :            :  * TCP listen path runs lockless.
    2142                 :            :  * We forced "struct sock" to be const qualified to make sure
    2143                 :            :  * we don't modify one of its field by mistake.
    2144                 :            :  * Here, we increment sk_drops which is an atomic_t, so we can safely
    2145                 :            :  * make sock writable again.
    2146                 :            :  */
    2147                 :          0 : static inline void tcp_listendrop(const struct sock *sk)
    2148                 :            : {
    2149                 :          0 :         atomic_inc(&((struct sock *)sk)->sk_drops);
    2150                 :          0 :         __NET_INC_STATS(sock_net(sk), LINUX_MIB_LISTENDROPS);
    2151                 :          0 : }
    2152                 :            : 
    2153                 :            : enum hrtimer_restart tcp_pace_kick(struct hrtimer *timer);
    2154                 :            : 
    2155                 :            : /*
    2156                 :            :  * Interface for adding Upper Level Protocols over TCP
    2157                 :            :  */
    2158                 :            : 
    2159                 :            : #define TCP_ULP_NAME_MAX        16
    2160                 :            : #define TCP_ULP_MAX             128
    2161                 :            : #define TCP_ULP_BUF_MAX         (TCP_ULP_NAME_MAX*TCP_ULP_MAX)
    2162                 :            : 
    2163                 :            : struct tcp_ulp_ops {
    2164                 :            :         struct list_head        list;
    2165                 :            : 
    2166                 :            :         /* initialize ulp */
    2167                 :            :         int (*init)(struct sock *sk);
    2168                 :            :         /* update ulp */
    2169                 :            :         void (*update)(struct sock *sk, struct proto *p,
    2170                 :            :                        void (*write_space)(struct sock *sk));
    2171                 :            :         /* cleanup ulp */
    2172                 :            :         void (*release)(struct sock *sk);
    2173                 :            :         /* diagnostic */
    2174                 :            :         int (*get_info)(const struct sock *sk, struct sk_buff *skb);
    2175                 :            :         size_t (*get_info_size)(const struct sock *sk);
    2176                 :            :         /* clone ulp */
    2177                 :            :         void (*clone)(const struct request_sock *req, struct sock *newsk,
    2178                 :            :                       const gfp_t priority);
    2179                 :            : 
    2180                 :            :         char            name[TCP_ULP_NAME_MAX];
    2181                 :            :         struct module   *owner;
    2182                 :            : };
    2183                 :            : int tcp_register_ulp(struct tcp_ulp_ops *type);
    2184                 :            : void tcp_unregister_ulp(struct tcp_ulp_ops *type);
    2185                 :            : int tcp_set_ulp(struct sock *sk, const char *name);
    2186                 :            : void tcp_get_available_ulp(char *buf, size_t len);
    2187                 :            : void tcp_cleanup_ulp(struct sock *sk);
    2188                 :            : void tcp_update_ulp(struct sock *sk, struct proto *p,
    2189                 :            :                     void (*write_space)(struct sock *sk));
    2190                 :            : 
    2191                 :            : #define MODULE_ALIAS_TCP_ULP(name)                              \
    2192                 :            :         __MODULE_INFO(alias, alias_userspace, name);            \
    2193                 :            :         __MODULE_INFO(alias, alias_tcp_ulp, "tcp-ulp-" name)
    2194                 :            : 
    2195                 :            : struct sk_msg;
    2196                 :            : struct sk_psock;
    2197                 :            : 
    2198                 :            : int tcp_bpf_init(struct sock *sk);
    2199                 :            : void tcp_bpf_reinit(struct sock *sk);
    2200                 :            : int tcp_bpf_sendmsg_redir(struct sock *sk, struct sk_msg *msg, u32 bytes,
    2201                 :            :                           int flags);
    2202                 :            : int tcp_bpf_recvmsg(struct sock *sk, struct msghdr *msg, size_t len,
    2203                 :            :                     int nonblock, int flags, int *addr_len);
    2204                 :            : int __tcp_bpf_recvmsg(struct sock *sk, struct sk_psock *psock,
    2205                 :            :                       struct msghdr *msg, int len, int flags);
    2206                 :            : 
    2207                 :            : /* Call BPF_SOCK_OPS program that returns an int. If the return value
    2208                 :            :  * is < 0, then the BPF op failed (for example if the loaded BPF
    2209                 :            :  * program does not support the chosen operation or there is no BPF
    2210                 :            :  * program loaded).
    2211                 :            :  */
    2212                 :            : #ifdef CONFIG_BPF
    2213                 :          6 : static inline int tcp_call_bpf(struct sock *sk, int op, u32 nargs, u32 *args)
    2214                 :            : {
    2215                 :          6 :         struct bpf_sock_ops_kern sock_ops;
    2216                 :          6 :         int ret;
    2217                 :            : 
    2218                 :          6 :         memset(&sock_ops, 0, offsetof(struct bpf_sock_ops_kern, temp));
    2219                 :          6 :         if (sk_fullsock(sk)) {
    2220                 :            :                 sock_ops.is_fullsock = 1;
    2221                 :            :                 sock_owned_by_me(sk);
    2222                 :            :         }
    2223                 :            : 
    2224                 :          6 :         sock_ops.sk = sk;
    2225                 :          6 :         sock_ops.op = op;
    2226                 :          6 :         if (nargs > 0)
    2227                 :            :                 memcpy(sock_ops.args, args, nargs * sizeof(*args));
    2228                 :            : 
    2229                 :          6 :         ret = BPF_CGROUP_RUN_PROG_SOCK_OPS(&sock_ops);
    2230                 :          6 :         if (ret == 0)
    2231                 :          6 :                 ret = sock_ops.reply;
    2232                 :            :         else
    2233                 :            :                 ret = -1;
    2234         [ #  # ]:          6 :         return ret;
    2235                 :            : }
    2236                 :            : 
    2237                 :          0 : static inline int tcp_call_bpf_2arg(struct sock *sk, int op, u32 arg1, u32 arg2)
    2238                 :            : {
    2239                 :          0 :         u32 args[2] = {arg1, arg2};
    2240                 :            : 
    2241                 :          0 :         return tcp_call_bpf(sk, op, 2, args);
    2242                 :            : }
    2243                 :            : 
    2244                 :          0 : static inline int tcp_call_bpf_3arg(struct sock *sk, int op, u32 arg1, u32 arg2,
    2245                 :            :                                     u32 arg3)
    2246                 :            : {
    2247                 :          0 :         u32 args[3] = {arg1, arg2, arg3};
    2248                 :            : 
    2249                 :          0 :         return tcp_call_bpf(sk, op, 3, args);
    2250                 :            : }
    2251                 :            : 
    2252                 :            : #else
    2253                 :            : static inline int tcp_call_bpf(struct sock *sk, int op, u32 nargs, u32 *args)
    2254                 :            : {
    2255                 :            :         return -EPERM;
    2256                 :            : }
    2257                 :            : 
    2258                 :            : static inline int tcp_call_bpf_2arg(struct sock *sk, int op, u32 arg1, u32 arg2)
    2259                 :            : {
    2260                 :            :         return -EPERM;
    2261                 :            : }
    2262                 :            : 
    2263                 :            : static inline int tcp_call_bpf_3arg(struct sock *sk, int op, u32 arg1, u32 arg2,
    2264                 :            :                                     u32 arg3)
    2265                 :            : {
    2266                 :            :         return -EPERM;
    2267                 :            : }
    2268                 :            : 
    2269                 :            : #endif
    2270                 :            : 
    2271                 :          0 : static inline u32 tcp_timeout_init(struct sock *sk)
    2272                 :            : {
    2273                 :          0 :         int timeout;
    2274                 :            : 
    2275                 :          0 :         timeout = tcp_call_bpf(sk, BPF_SOCK_OPS_TIMEOUT_INIT, 0, NULL);
    2276                 :            : 
    2277                 :          0 :         if (timeout <= 0)
    2278                 :          0 :                 timeout = TCP_TIMEOUT_INIT;
    2279                 :          0 :         return timeout;
    2280                 :            : }
    2281                 :            : 
    2282                 :          0 : static inline u32 tcp_rwnd_init_bpf(struct sock *sk)
    2283                 :            : {
    2284                 :          0 :         int rwnd;
    2285                 :            : 
    2286         [ #  # ]:          0 :         rwnd = tcp_call_bpf(sk, BPF_SOCK_OPS_RWND_INIT, 0, NULL);
    2287                 :            : 
    2288                 :          0 :         if (rwnd < 0)
    2289                 :            :                 rwnd = 0;
    2290         [ #  # ]:          0 :         return rwnd;
    2291                 :            : }
    2292                 :            : 
    2293                 :          0 : static inline bool tcp_bpf_ca_needs_ecn(struct sock *sk)
    2294                 :            : {
    2295         [ #  # ]:          0 :         return (tcp_call_bpf(sk, BPF_SOCK_OPS_NEEDS_ECN, 0, NULL) == 1);
    2296                 :            : }
    2297                 :            : 
    2298                 :          0 : static inline void tcp_bpf_rtt(struct sock *sk)
    2299                 :            : {
    2300   [ #  #  #  # ]:          0 :         if (BPF_SOCK_OPS_TEST_FLAG(tcp_sk(sk), BPF_SOCK_OPS_RTT_CB_FLAG))
    2301                 :          0 :                 tcp_call_bpf(sk, BPF_SOCK_OPS_RTT_CB, 0, NULL);
    2302                 :            : }
    2303                 :            : 
    2304                 :            : #if IS_ENABLED(CONFIG_SMC)
    2305                 :            : extern struct static_key_false tcp_have_smc;
    2306                 :            : #endif
    2307                 :            : 
    2308                 :            : #if IS_ENABLED(CONFIG_TLS_DEVICE)
    2309                 :            : void clean_acked_data_enable(struct inet_connection_sock *icsk,
    2310                 :            :                              void (*cad)(struct sock *sk, u32 ack_seq));
    2311                 :            : void clean_acked_data_disable(struct inet_connection_sock *icsk);
    2312                 :            : void clean_acked_data_flush(void);
    2313                 :            : #endif
    2314                 :            : 
    2315                 :            : DECLARE_STATIC_KEY_FALSE(tcp_tx_delay_enabled);
    2316                 :          0 : static inline void tcp_add_tx_delay(struct sk_buff *skb,
    2317                 :            :                                     const struct tcp_sock *tp)
    2318                 :            : {
    2319   [ #  #  #  #  :          0 :         if (static_branch_unlikely(&tcp_tx_delay_enabled))
             #  #  #  # ]
    2320                 :          0 :                 skb->skb_mstamp_ns += (u64)tp->tcp_tx_delay * NSEC_PER_USEC;
    2321                 :            : }
    2322                 :            : 
    2323                 :            : /* Compute Earliest Departure Time for some control packets
    2324                 :            :  * like ACK or RST for TIME_WAIT or non ESTABLISHED sockets.
    2325                 :            :  */
    2326                 :          0 : static inline u64 tcp_transmit_time(const struct sock *sk)
    2327                 :            : {
    2328   [ #  #  #  # ]:          0 :         if (static_branch_unlikely(&tcp_tx_delay_enabled)) {
    2329                 :          0 :                 u32 delay = (sk->sk_state == TCP_TIME_WAIT) ?
    2330         [ #  # ]:          0 :                         tcp_twsk(sk)->tw_tx_delay : tcp_sk(sk)->tcp_tx_delay;
    2331                 :            : 
    2332                 :          0 :                 return tcp_clock_ns() + (u64)delay * NSEC_PER_USEC;
    2333                 :            :         }
    2334                 :            :         return 0;
    2335                 :            : }
    2336                 :            : 
    2337                 :            : #endif  /* _TCP_H */

Generated by: LCOV version 1.14