LCOV - code coverage report
Current view: top level - net/ipv4 - tcp.c (source / functions) Hit Total Coverage
Test: Real Lines: 499 1464 34.1 %
Date: 2020-10-17 15:46:43 Functions: 0 60 0.0 %
Legend: Neither, QEMU, Real, Both Branches: 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                 :            :  *              Implementation of the Transmission Control Protocol(TCP).
       8                 :            :  *
       9                 :            :  * Authors:     Ross Biro
      10                 :            :  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
      11                 :            :  *              Mark Evans, <evansmp@uhura.aston.ac.uk>
      12                 :            :  *              Corey Minyard <wf-rch!minyard@relay.EU.net>
      13                 :            :  *              Florian La Roche, <flla@stud.uni-sb.de>
      14                 :            :  *              Charles Hedrick, <hedrick@klinzhai.rutgers.edu>
      15                 :            :  *              Linus Torvalds, <torvalds@cs.helsinki.fi>
      16                 :            :  *              Alan Cox, <gw4pts@gw4pts.ampr.org>
      17                 :            :  *              Matthew Dillon, <dillon@apollo.west.oic.com>
      18                 :            :  *              Arnt Gulbrandsen, <agulbra@nvg.unit.no>
      19                 :            :  *              Jorge Cwik, <jorge@laser.satlink.net>
      20                 :            :  *
      21                 :            :  * Fixes:
      22                 :            :  *              Alan Cox        :       Numerous verify_area() calls
      23                 :            :  *              Alan Cox        :       Set the ACK bit on a reset
      24                 :            :  *              Alan Cox        :       Stopped it crashing if it closed while
      25                 :            :  *                                      sk->inuse=1 and was trying to connect
      26                 :            :  *                                      (tcp_err()).
      27                 :            :  *              Alan Cox        :       All icmp error handling was broken
      28                 :            :  *                                      pointers passed where wrong and the
      29                 :            :  *                                      socket was looked up backwards. Nobody
      30                 :            :  *                                      tested any icmp error code obviously.
      31                 :            :  *              Alan Cox        :       tcp_err() now handled properly. It
      32                 :            :  *                                      wakes people on errors. poll
      33                 :            :  *                                      behaves and the icmp error race
      34                 :            :  *                                      has gone by moving it into sock.c
      35                 :            :  *              Alan Cox        :       tcp_send_reset() fixed to work for
      36                 :            :  *                                      everything not just packets for
      37                 :            :  *                                      unknown sockets.
      38                 :            :  *              Alan Cox        :       tcp option processing.
      39                 :            :  *              Alan Cox        :       Reset tweaked (still not 100%) [Had
      40                 :            :  *                                      syn rule wrong]
      41                 :            :  *              Herp Rosmanith  :       More reset fixes
      42                 :            :  *              Alan Cox        :       No longer acks invalid rst frames.
      43                 :            :  *                                      Acking any kind of RST is right out.
      44                 :            :  *              Alan Cox        :       Sets an ignore me flag on an rst
      45                 :            :  *                                      receive otherwise odd bits of prattle
      46                 :            :  *                                      escape still
      47                 :            :  *              Alan Cox        :       Fixed another acking RST frame bug.
      48                 :            :  *                                      Should stop LAN workplace lockups.
      49                 :            :  *              Alan Cox        :       Some tidyups using the new skb list
      50                 :            :  *                                      facilities
      51                 :            :  *              Alan Cox        :       sk->keepopen now seems to work
      52                 :            :  *              Alan Cox        :       Pulls options out correctly on accepts
      53                 :            :  *              Alan Cox        :       Fixed assorted sk->rqueue->next errors
      54                 :            :  *              Alan Cox        :       PSH doesn't end a TCP read. Switched a
      55                 :            :  *                                      bit to skb ops.
      56                 :            :  *              Alan Cox        :       Tidied tcp_data to avoid a potential
      57                 :            :  *                                      nasty.
      58                 :            :  *              Alan Cox        :       Added some better commenting, as the
      59                 :            :  *                                      tcp is hard to follow
      60                 :            :  *              Alan Cox        :       Removed incorrect check for 20 * psh
      61                 :            :  *      Michael O'Reilly        :       ack < copied bug fix.
      62                 :            :  *      Johannes Stille         :       Misc tcp fixes (not all in yet).
      63                 :            :  *              Alan Cox        :       FIN with no memory -> CRASH
      64                 :            :  *              Alan Cox        :       Added socket option proto entries.
      65                 :            :  *                                      Also added awareness of them to accept.
      66                 :            :  *              Alan Cox        :       Added TCP options (SOL_TCP)
      67                 :            :  *              Alan Cox        :       Switched wakeup calls to callbacks,
      68                 :            :  *                                      so the kernel can layer network
      69                 :            :  *                                      sockets.
      70                 :            :  *              Alan Cox        :       Use ip_tos/ip_ttl settings.
      71                 :            :  *              Alan Cox        :       Handle FIN (more) properly (we hope).
      72                 :            :  *              Alan Cox        :       RST frames sent on unsynchronised
      73                 :            :  *                                      state ack error.
      74                 :            :  *              Alan Cox        :       Put in missing check for SYN bit.
      75                 :            :  *              Alan Cox        :       Added tcp_select_window() aka NET2E
      76                 :            :  *                                      window non shrink trick.
      77                 :            :  *              Alan Cox        :       Added a couple of small NET2E timer
      78                 :            :  *                                      fixes
      79                 :            :  *              Charles Hedrick :       TCP fixes
      80                 :            :  *              Toomas Tamm     :       TCP window fixes
      81                 :            :  *              Alan Cox        :       Small URG fix to rlogin ^C ack fight
      82                 :            :  *              Charles Hedrick :       Rewrote most of it to actually work
      83                 :            :  *              Linus           :       Rewrote tcp_read() and URG handling
      84                 :            :  *                                      completely
      85                 :            :  *              Gerhard Koerting:       Fixed some missing timer handling
      86                 :            :  *              Matthew Dillon  :       Reworked TCP machine states as per RFC
      87                 :            :  *              Gerhard Koerting:       PC/TCP workarounds
      88                 :            :  *              Adam Caldwell   :       Assorted timer/timing errors
      89                 :            :  *              Matthew Dillon  :       Fixed another RST bug
      90                 :            :  *              Alan Cox        :       Move to kernel side addressing changes.
      91                 :            :  *              Alan Cox        :       Beginning work on TCP fastpathing
      92                 :            :  *                                      (not yet usable)
      93                 :            :  *              Arnt Gulbrandsen:       Turbocharged tcp_check() routine.
      94                 :            :  *              Alan Cox        :       TCP fast path debugging
      95                 :            :  *              Alan Cox        :       Window clamping
      96                 :            :  *              Michael Riepe   :       Bug in tcp_check()
      97                 :            :  *              Matt Dillon     :       More TCP improvements and RST bug fixes
      98                 :            :  *              Matt Dillon     :       Yet more small nasties remove from the
      99                 :            :  *                                      TCP code (Be very nice to this man if
     100                 :            :  *                                      tcp finally works 100%) 8)
     101                 :            :  *              Alan Cox        :       BSD accept semantics.
     102                 :            :  *              Alan Cox        :       Reset on closedown bug.
     103                 :            :  *      Peter De Schrijver      :       ENOTCONN check missing in tcp_sendto().
     104                 :            :  *              Michael Pall    :       Handle poll() after URG properly in
     105                 :            :  *                                      all cases.
     106                 :            :  *              Michael Pall    :       Undo the last fix in tcp_read_urg()
     107                 :            :  *                                      (multi URG PUSH broke rlogin).
     108                 :            :  *              Michael Pall    :       Fix the multi URG PUSH problem in
     109                 :            :  *                                      tcp_readable(), poll() after URG
     110                 :            :  *                                      works now.
     111                 :            :  *              Michael Pall    :       recv(...,MSG_OOB) never blocks in the
     112                 :            :  *                                      BSD api.
     113                 :            :  *              Alan Cox        :       Changed the semantics of sk->socket to
     114                 :            :  *                                      fix a race and a signal problem with
     115                 :            :  *                                      accept() and async I/O.
     116                 :            :  *              Alan Cox        :       Relaxed the rules on tcp_sendto().
     117                 :            :  *              Yury Shevchuk   :       Really fixed accept() blocking problem.
     118                 :            :  *              Craig I. Hagan  :       Allow for BSD compatible TIME_WAIT for
     119                 :            :  *                                      clients/servers which listen in on
     120                 :            :  *                                      fixed ports.
     121                 :            :  *              Alan Cox        :       Cleaned the above up and shrank it to
     122                 :            :  *                                      a sensible code size.
     123                 :            :  *              Alan Cox        :       Self connect lockup fix.
     124                 :            :  *              Alan Cox        :       No connect to multicast.
     125                 :            :  *              Ross Biro       :       Close unaccepted children on master
     126                 :            :  *                                      socket close.
     127                 :            :  *              Alan Cox        :       Reset tracing code.
     128                 :            :  *              Alan Cox        :       Spurious resets on shutdown.
     129                 :            :  *              Alan Cox        :       Giant 15 minute/60 second timer error
     130                 :            :  *              Alan Cox        :       Small whoops in polling before an
     131                 :            :  *                                      accept.
     132                 :            :  *              Alan Cox        :       Kept the state trace facility since
     133                 :            :  *                                      it's handy for debugging.
     134                 :            :  *              Alan Cox        :       More reset handler fixes.
     135                 :            :  *              Alan Cox        :       Started rewriting the code based on
     136                 :            :  *                                      the RFC's for other useful protocol
     137                 :            :  *                                      references see: Comer, KA9Q NOS, and
     138                 :            :  *                                      for a reference on the difference
     139                 :            :  *                                      between specifications and how BSD
     140                 :            :  *                                      works see the 4.4lite source.
     141                 :            :  *              A.N.Kuznetsov   :       Don't time wait on completion of tidy
     142                 :            :  *                                      close.
     143                 :            :  *              Linus Torvalds  :       Fin/Shutdown & copied_seq changes.
     144                 :            :  *              Linus Torvalds  :       Fixed BSD port reuse to work first syn
     145                 :            :  *              Alan Cox        :       Reimplemented timers as per the RFC
     146                 :            :  *                                      and using multiple timers for sanity.
     147                 :            :  *              Alan Cox        :       Small bug fixes, and a lot of new
     148                 :            :  *                                      comments.
     149                 :            :  *              Alan Cox        :       Fixed dual reader crash by locking
     150                 :            :  *                                      the buffers (much like datagram.c)
     151                 :            :  *              Alan Cox        :       Fixed stuck sockets in probe. A probe
     152                 :            :  *                                      now gets fed up of retrying without
     153                 :            :  *                                      (even a no space) answer.
     154                 :            :  *              Alan Cox        :       Extracted closing code better
     155                 :            :  *              Alan Cox        :       Fixed the closing state machine to
     156                 :            :  *                                      resemble the RFC.
     157                 :            :  *              Alan Cox        :       More 'per spec' fixes.
     158                 :            :  *              Jorge Cwik      :       Even faster checksumming.
     159                 :            :  *              Alan Cox        :       tcp_data() doesn't ack illegal PSH
     160                 :            :  *                                      only frames. At least one pc tcp stack
     161                 :            :  *                                      generates them.
     162                 :            :  *              Alan Cox        :       Cache last socket.
     163                 :            :  *              Alan Cox        :       Per route irtt.
     164                 :            :  *              Matt Day        :       poll()->select() match BSD precisely on error
     165                 :            :  *              Alan Cox        :       New buffers
     166                 :            :  *              Marc Tamsky     :       Various sk->prot->retransmits and
     167                 :            :  *                                      sk->retransmits misupdating fixed.
     168                 :            :  *                                      Fixed tcp_write_timeout: stuck close,
     169                 :            :  *                                      and TCP syn retries gets used now.
     170                 :            :  *              Mark Yarvis     :       In tcp_read_wakeup(), don't send an
     171                 :            :  *                                      ack if state is TCP_CLOSED.
     172                 :            :  *              Alan Cox        :       Look up device on a retransmit - routes may
     173                 :            :  *                                      change. Doesn't yet cope with MSS shrink right
     174                 :            :  *                                      but it's a start!
     175                 :            :  *              Marc Tamsky     :       Closing in closing fixes.
     176                 :            :  *              Mike Shaver     :       RFC1122 verifications.
     177                 :            :  *              Alan Cox        :       rcv_saddr errors.
     178                 :            :  *              Alan Cox        :       Block double connect().
     179                 :            :  *              Alan Cox        :       Small hooks for enSKIP.
     180                 :            :  *              Alexey Kuznetsov:       Path MTU discovery.
     181                 :            :  *              Alan Cox        :       Support soft errors.
     182                 :            :  *              Alan Cox        :       Fix MTU discovery pathological case
     183                 :            :  *                                      when the remote claims no mtu!
     184                 :            :  *              Marc Tamsky     :       TCP_CLOSE fix.
     185                 :            :  *              Colin (G3TNE)   :       Send a reset on syn ack replies in
     186                 :            :  *                                      window but wrong (fixes NT lpd problems)
     187                 :            :  *              Pedro Roque     :       Better TCP window handling, delayed ack.
     188                 :            :  *              Joerg Reuter    :       No modification of locked buffers in
     189                 :            :  *                                      tcp_do_retransmit()
     190                 :            :  *              Eric Schenk     :       Changed receiver side silly window
     191                 :            :  *                                      avoidance algorithm to BSD style
     192                 :            :  *                                      algorithm. This doubles throughput
     193                 :            :  *                                      against machines running Solaris,
     194                 :            :  *                                      and seems to result in general
     195                 :            :  *                                      improvement.
     196                 :            :  *      Stefan Magdalinski      :       adjusted tcp_readable() to fix FIONREAD
     197                 :            :  *      Willy Konynenberg       :       Transparent proxying support.
     198                 :            :  *      Mike McLagan            :       Routing by source
     199                 :            :  *              Keith Owens     :       Do proper merging with partial SKB's in
     200                 :            :  *                                      tcp_do_sendmsg to avoid burstiness.
     201                 :            :  *              Eric Schenk     :       Fix fast close down bug with
     202                 :            :  *                                      shutdown() followed by close().
     203                 :            :  *              Andi Kleen      :       Make poll agree with SIGIO
     204                 :            :  *      Salvatore Sanfilippo    :       Support SO_LINGER with linger == 1 and
     205                 :            :  *                                      lingertime == 0 (RFC 793 ABORT Call)
     206                 :            :  *      Hirokazu Takahashi      :       Use copy_from_user() instead of
     207                 :            :  *                                      csum_and_copy_from_user() if possible.
     208                 :            :  *
     209                 :            :  * Description of States:
     210                 :            :  *
     211                 :            :  *      TCP_SYN_SENT            sent a connection request, waiting for ack
     212                 :            :  *
     213                 :            :  *      TCP_SYN_RECV            received a connection request, sent ack,
     214                 :            :  *                              waiting for final ack in three-way handshake.
     215                 :            :  *
     216                 :            :  *      TCP_ESTABLISHED         connection established
     217                 :            :  *
     218                 :            :  *      TCP_FIN_WAIT1           our side has shutdown, waiting to complete
     219                 :            :  *                              transmission of remaining buffered data
     220                 :            :  *
     221                 :            :  *      TCP_FIN_WAIT2           all buffered data sent, waiting for remote
     222                 :            :  *                              to shutdown
     223                 :            :  *
     224                 :            :  *      TCP_CLOSING             both sides have shutdown but we still have
     225                 :            :  *                              data we have to finish sending
     226                 :            :  *
     227                 :            :  *      TCP_TIME_WAIT           timeout to catch resent junk before entering
     228                 :            :  *                              closed, can only be entered from FIN_WAIT2
     229                 :            :  *                              or CLOSING.  Required because the other end
     230                 :            :  *                              may not have gotten our last ACK causing it
     231                 :            :  *                              to retransmit the data packet (which we ignore)
     232                 :            :  *
     233                 :            :  *      TCP_CLOSE_WAIT          remote side has shutdown and is waiting for
     234                 :            :  *                              us to finish writing our data and to shutdown
     235                 :            :  *                              (we have to close() to move on to LAST_ACK)
     236                 :            :  *
     237                 :            :  *      TCP_LAST_ACK            out side has shutdown after remote has
     238                 :            :  *                              shutdown.  There may still be data in our
     239                 :            :  *                              buffer that we have to finish sending
     240                 :            :  *
     241                 :            :  *      TCP_CLOSE               socket is finished
     242                 :            :  */
     243                 :            : 
     244                 :            : #define pr_fmt(fmt) "TCP: " fmt
     245                 :            : 
     246                 :            : #include <crypto/hash.h>
     247                 :            : #include <linux/kernel.h>
     248                 :            : #include <linux/module.h>
     249                 :            : #include <linux/types.h>
     250                 :            : #include <linux/fcntl.h>
     251                 :            : #include <linux/poll.h>
     252                 :            : #include <linux/inet_diag.h>
     253                 :            : #include <linux/init.h>
     254                 :            : #include <linux/fs.h>
     255                 :            : #include <linux/skbuff.h>
     256                 :            : #include <linux/scatterlist.h>
     257                 :            : #include <linux/splice.h>
     258                 :            : #include <linux/net.h>
     259                 :            : #include <linux/socket.h>
     260                 :            : #include <linux/random.h>
     261                 :            : #include <linux/memblock.h>
     262                 :            : #include <linux/highmem.h>
     263                 :            : #include <linux/swap.h>
     264                 :            : #include <linux/cache.h>
     265                 :            : #include <linux/err.h>
     266                 :            : #include <linux/time.h>
     267                 :            : #include <linux/slab.h>
     268                 :            : #include <linux/errqueue.h>
     269                 :            : #include <linux/static_key.h>
     270                 :            : 
     271                 :            : #include <net/icmp.h>
     272                 :            : #include <net/inet_common.h>
     273                 :            : #include <net/tcp.h>
     274                 :            : #include <net/xfrm.h>
     275                 :            : #include <net/ip.h>
     276                 :            : #include <net/sock.h>
     277                 :            : 
     278                 :            : #include <linux/uaccess.h>
     279                 :            : #include <asm/ioctls.h>
     280                 :            : #include <net/busy_poll.h>
     281                 :            : 
     282                 :            : struct percpu_counter tcp_orphan_count;
     283                 :            : EXPORT_SYMBOL_GPL(tcp_orphan_count);
     284                 :            : 
     285                 :            : long sysctl_tcp_mem[3] __read_mostly;
     286                 :            : EXPORT_SYMBOL(sysctl_tcp_mem);
     287                 :            : 
     288                 :            : atomic_long_t tcp_memory_allocated;     /* Current allocated memory. */
     289                 :            : EXPORT_SYMBOL(tcp_memory_allocated);
     290                 :            : 
     291                 :            : #if IS_ENABLED(CONFIG_SMC)
     292                 :            : DEFINE_STATIC_KEY_FALSE(tcp_have_smc);
     293                 :            : EXPORT_SYMBOL(tcp_have_smc);
     294                 :            : #endif
     295                 :            : 
     296                 :            : /*
     297                 :            :  * Current number of TCP sockets.
     298                 :            :  */
     299                 :            : struct percpu_counter tcp_sockets_allocated;
     300                 :            : EXPORT_SYMBOL(tcp_sockets_allocated);
     301                 :            : 
     302                 :            : /*
     303                 :            :  * TCP splice context
     304                 :            :  */
     305                 :            : struct tcp_splice_state {
     306                 :            :         struct pipe_inode_info *pipe;
     307                 :            :         size_t len;
     308                 :            :         unsigned int flags;
     309                 :            : };
     310                 :            : 
     311                 :            : /*
     312                 :            :  * Pressure flag: try to collapse.
     313                 :            :  * Technical note: it is used by multiple contexts non atomically.
     314                 :            :  * All the __sk_mem_schedule() is of this nature: accounting
     315                 :            :  * is strict, actions are advisory and have some latency.
     316                 :            :  */
     317                 :            : unsigned long tcp_memory_pressure __read_mostly;
     318                 :            : EXPORT_SYMBOL_GPL(tcp_memory_pressure);
     319                 :            : 
     320                 :            : DEFINE_STATIC_KEY_FALSE(tcp_rx_skb_cache_key);
     321                 :            : EXPORT_SYMBOL(tcp_rx_skb_cache_key);
     322                 :            : 
     323                 :            : DEFINE_STATIC_KEY_FALSE(tcp_tx_skb_cache_key);
     324                 :            : 
     325                 :          0 : void tcp_enter_memory_pressure(struct sock *sk)
     326                 :            : {
     327                 :            :         unsigned long val;
     328                 :            : 
     329                 :          0 :         if (READ_ONCE(tcp_memory_pressure))
     330                 :          0 :                 return;
     331                 :          0 :         val = jiffies;
     332                 :            : 
     333                 :          0 :         if (!val)
     334                 :          0 :                 val--;
     335                 :          0 :         if (!cmpxchg(&tcp_memory_pressure, 0, val))
     336                 :          0 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURES);
     337                 :            : }
     338                 :            : EXPORT_SYMBOL_GPL(tcp_enter_memory_pressure);
     339                 :            : 
     340                 :          1 : void tcp_leave_memory_pressure(struct sock *sk)
     341                 :            : {
     342                 :            :         unsigned long val;
     343                 :            : 
     344                 :          1 :         if (!READ_ONCE(tcp_memory_pressure))
     345                 :          1 :                 return;
     346                 :          0 :         val = xchg(&tcp_memory_pressure, 0);
     347                 :          0 :         if (val)
     348                 :          0 :                 NET_ADD_STATS(sock_net(sk), LINUX_MIB_TCPMEMORYPRESSURESCHRONO,
     349                 :            :                               jiffies_to_msecs(jiffies - val));
     350                 :            : }
     351                 :            : EXPORT_SYMBOL_GPL(tcp_leave_memory_pressure);
     352                 :            : 
     353                 :            : /* Convert seconds to retransmits based on initial and max timeout */
     354                 :            : static u8 secs_to_retrans(int seconds, int timeout, int rto_max)
     355                 :            : {
     356                 :            :         u8 res = 0;
     357                 :            : 
     358                 :          0 :         if (seconds > 0) {
     359                 :            :                 int period = timeout;
     360                 :            : 
     361                 :            :                 res = 1;
     362                 :          0 :                 while (seconds > period && res < 255) {
     363                 :          0 :                         res++;
     364                 :          0 :                         timeout <<= 1;
     365                 :          0 :                         if (timeout > rto_max)
     366                 :            :                                 timeout = rto_max;
     367                 :          0 :                         period += timeout;
     368                 :            :                 }
     369                 :            :         }
     370                 :            :         return res;
     371                 :            : }
     372                 :            : 
     373                 :            : /* Convert retransmits to seconds based on initial and max timeout */
     374                 :            : static int retrans_to_secs(u8 retrans, int timeout, int rto_max)
     375                 :            : {
     376                 :            :         int period = 0;
     377                 :            : 
     378                 :          0 :         if (retrans > 0) {
     379                 :            :                 period = timeout;
     380                 :          0 :                 while (--retrans) {
     381                 :          0 :                         timeout <<= 1;
     382                 :          0 :                         if (timeout > rto_max)
     383                 :            :                                 timeout = rto_max;
     384                 :          0 :                         period += timeout;
     385                 :            :                 }
     386                 :            :         }
     387                 :            :         return period;
     388                 :            : }
     389                 :            : 
     390                 :          1 : static u64 tcp_compute_delivery_rate(const struct tcp_sock *tp)
     391                 :            : {
     392                 :            :         u32 rate = READ_ONCE(tp->rate_delivered);
     393                 :            :         u32 intv = READ_ONCE(tp->rate_interval_us);
     394                 :          1 :         u64 rate64 = 0;
     395                 :            : 
     396                 :          1 :         if (rate && intv) {
     397                 :          1 :                 rate64 = (u64)rate * tp->mss_cache * USEC_PER_SEC;
     398                 :          1 :                 do_div(rate64, intv);
     399                 :            :         }
     400                 :          1 :         return rate64;
     401                 :            : }
     402                 :            : 
     403                 :            : /* Address-family independent initialization for a tcp_sock.
     404                 :            :  *
     405                 :            :  * NOTE: A lot of things set to zero explicitly by call to
     406                 :            :  *       sk_alloc() so need not be done here.
     407                 :            :  */
     408                 :          1 : void tcp_init_sock(struct sock *sk)
     409                 :            : {
     410                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
     411                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     412                 :            : 
     413                 :          1 :         tp->out_of_order_queue = RB_ROOT;
     414                 :          1 :         sk->tcp_rtx_queue = RB_ROOT;
     415                 :          1 :         tcp_init_xmit_timers(sk);
     416                 :          1 :         INIT_LIST_HEAD(&tp->tsq_node);
     417                 :          1 :         INIT_LIST_HEAD(&tp->tsorted_sent_queue);
     418                 :            : 
     419                 :          1 :         icsk->icsk_rto = TCP_TIMEOUT_INIT;
     420                 :          1 :         tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
     421                 :          1 :         minmax_reset(&tp->rtt_min, tcp_jiffies32, ~0U);
     422                 :            : 
     423                 :            :         /* So many TCP implementations out there (incorrectly) count the
     424                 :            :          * initial SYN frame in their delayed-ACK and congestion control
     425                 :            :          * algorithms that we must have the following bandaid to talk
     426                 :            :          * efficiently to them.  -DaveM
     427                 :            :          */
     428                 :          1 :         tp->snd_cwnd = TCP_INIT_CWND;
     429                 :            : 
     430                 :            :         /* There's a bubble in the pipe until at least the first ACK. */
     431                 :          1 :         tp->app_limited = ~0U;
     432                 :            : 
     433                 :            :         /* See draft-stevens-tcpca-spec-01 for discussion of the
     434                 :            :          * initialization of these values.
     435                 :            :          */
     436                 :          1 :         tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
     437                 :          1 :         tp->snd_cwnd_clamp = ~0;
     438                 :          1 :         tp->mss_cache = TCP_MSS_DEFAULT;
     439                 :            : 
     440                 :          1 :         tp->reordering = sock_net(sk)->ipv4.sysctl_tcp_reordering;
     441                 :          1 :         tcp_assign_congestion_control(sk);
     442                 :            : 
     443                 :          1 :         tp->tsoffset = 0;
     444                 :          1 :         tp->rack.reo_wnd_steps = 1;
     445                 :            : 
     446                 :          1 :         sk->sk_state = TCP_CLOSE;
     447                 :            : 
     448                 :          1 :         sk->sk_write_space = sk_stream_write_space;
     449                 :            :         sock_set_flag(sk, SOCK_USE_WRITE_QUEUE);
     450                 :            : 
     451                 :          1 :         icsk->icsk_sync_mss = tcp_sync_mss;
     452                 :            : 
     453                 :          1 :         WRITE_ONCE(sk->sk_sndbuf, sock_net(sk)->ipv4.sysctl_tcp_wmem[1]);
     454                 :          1 :         WRITE_ONCE(sk->sk_rcvbuf, sock_net(sk)->ipv4.sysctl_tcp_rmem[1]);
     455                 :            : 
     456                 :          1 :         sk_sockets_allocated_inc(sk);
     457                 :          1 :         sk->sk_route_forced_caps = NETIF_F_GSO;
     458                 :          1 : }
     459                 :            : EXPORT_SYMBOL(tcp_init_sock);
     460                 :            : 
     461                 :          1 : static void tcp_tx_timestamp(struct sock *sk, u16 tsflags)
     462                 :            : {
     463                 :            :         struct sk_buff *skb = tcp_write_queue_tail(sk);
     464                 :            : 
     465                 :          1 :         if (tsflags && skb) {
     466                 :            :                 struct skb_shared_info *shinfo = skb_shinfo(skb);
     467                 :            :                 struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
     468                 :            : 
     469                 :          0 :                 sock_tx_timestamp(sk, tsflags, &shinfo->tx_flags);
     470                 :          0 :                 if (tsflags & SOF_TIMESTAMPING_TX_ACK)
     471                 :          0 :                         tcb->txstamp_ack = 1;
     472                 :          0 :                 if (tsflags & SOF_TIMESTAMPING_TX_RECORD_MASK)
     473                 :          0 :                         shinfo->tskey = TCP_SKB_CB(skb)->seq + skb->len - 1;
     474                 :            :         }
     475                 :          1 : }
     476                 :            : 
     477                 :          1 : static inline bool tcp_stream_is_readable(const struct tcp_sock *tp,
     478                 :            :                                           int target, struct sock *sk)
     479                 :            : {
     480                 :          1 :         int avail = READ_ONCE(tp->rcv_nxt) - READ_ONCE(tp->copied_seq);
     481                 :            : 
     482                 :          1 :         if (avail > 0) {
     483                 :          1 :                 if (avail >= target)
     484                 :            :                         return true;
     485                 :          0 :                 if (tcp_rmem_pressure(sk))
     486                 :            :                         return true;
     487                 :            :         }
     488                 :          1 :         if (sk->sk_prot->stream_memory_read)
     489                 :          0 :                 return sk->sk_prot->stream_memory_read(sk);
     490                 :            :         return false;
     491                 :            : }
     492                 :            : 
     493                 :            : /*
     494                 :            :  *      Wait for a TCP event.
     495                 :            :  *
     496                 :            :  *      Note that we don't need to lock the socket, as the upper poll layers
     497                 :            :  *      take care of normal races (between the test and the event) and we don't
     498                 :            :  *      go look at any of the socket buffers directly.
     499                 :            :  */
     500                 :          1 : __poll_t tcp_poll(struct file *file, struct socket *sock, poll_table *wait)
     501                 :            : {
     502                 :            :         __poll_t mask;
     503                 :          1 :         struct sock *sk = sock->sk;
     504                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
     505                 :            :         int state;
     506                 :            : 
     507                 :          1 :         sock_poll_wait(file, sock, wait);
     508                 :            : 
     509                 :            :         state = inet_sk_state_load(sk);
     510                 :          1 :         if (state == TCP_LISTEN)
     511                 :          0 :                 return inet_csk_listen_poll(sk);
     512                 :            : 
     513                 :            :         /* Socket is not locked. We are protected from async events
     514                 :            :          * by poll logic and correct handling of state changes
     515                 :            :          * made by other threads is impossible in any case.
     516                 :            :          */
     517                 :            : 
     518                 :            :         mask = 0;
     519                 :            : 
     520                 :            :         /*
     521                 :            :          * EPOLLHUP is certainly not done right. But poll() doesn't
     522                 :            :          * have a notion of HUP in just one direction, and for a
     523                 :            :          * socket the read side is more interesting.
     524                 :            :          *
     525                 :            :          * Some poll() documentation says that EPOLLHUP is incompatible
     526                 :            :          * with the EPOLLOUT/POLLWR flags, so somebody should check this
     527                 :            :          * all. But careful, it tends to be safer to return too many
     528                 :            :          * bits than too few, and you can easily break real applications
     529                 :            :          * if you don't tell them that something has hung up!
     530                 :            :          *
     531                 :            :          * Check-me.
     532                 :            :          *
     533                 :            :          * Check number 1. EPOLLHUP is _UNMASKABLE_ event (see UNIX98 and
     534                 :            :          * our fs/select.c). It means that after we received EOF,
     535                 :            :          * poll always returns immediately, making impossible poll() on write()
     536                 :            :          * in state CLOSE_WAIT. One solution is evident --- to set EPOLLHUP
     537                 :            :          * if and only if shutdown has been made in both directions.
     538                 :            :          * Actually, it is interesting to look how Solaris and DUX
     539                 :            :          * solve this dilemma. I would prefer, if EPOLLHUP were maskable,
     540                 :            :          * then we could set it on SND_SHUTDOWN. BTW examples given
     541                 :            :          * in Stevens' books assume exactly this behaviour, it explains
     542                 :            :          * why EPOLLHUP is incompatible with EPOLLOUT.  --ANK
     543                 :            :          *
     544                 :            :          * NOTE. Check for TCP_CLOSE is added. The goal is to prevent
     545                 :            :          * blocking on fresh not-connected or disconnected socket. --ANK
     546                 :            :          */
     547                 :          1 :         if (sk->sk_shutdown == SHUTDOWN_MASK || state == TCP_CLOSE)
     548                 :            :                 mask |= EPOLLHUP;
     549                 :          1 :         if (sk->sk_shutdown & RCV_SHUTDOWN)
     550                 :          1 :                 mask |= EPOLLIN | EPOLLRDNORM | EPOLLRDHUP;
     551                 :            : 
     552                 :            :         /* Connected or passive Fast Open socket? */
     553                 :          1 :         if (state != TCP_SYN_SENT &&
     554                 :          0 :             (state != TCP_SYN_RECV || rcu_access_pointer(tp->fastopen_rsk))) {
     555                 :            :                 int target = sock_rcvlowat(sk, 0, INT_MAX);
     556                 :            : 
     557                 :          1 :                 if (READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq) &&
     558                 :          0 :                     !sock_flag(sk, SOCK_URGINLINE) &&
     559                 :          0 :                     tp->urg_data)
     560                 :          0 :                         target++;
     561                 :            : 
     562                 :          1 :                 if (tcp_stream_is_readable(tp, target, sk))
     563                 :          1 :                         mask |= EPOLLIN | EPOLLRDNORM;
     564                 :            : 
     565                 :          1 :                 if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
     566                 :          1 :                         if (sk_stream_is_writeable(sk)) {
     567                 :          1 :                                 mask |= EPOLLOUT | EPOLLWRNORM;
     568                 :            :                         } else {  /* send SIGIO later */
     569                 :          0 :                                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
     570                 :          0 :                                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
     571                 :            : 
     572                 :            :                                 /* Race breaker. If space is freed after
     573                 :            :                                  * wspace test but before the flags are set,
     574                 :            :                                  * IO signal will be lost. Memory barrier
     575                 :            :                                  * pairs with the input side.
     576                 :            :                                  */
     577                 :          0 :                                 smp_mb__after_atomic();
     578                 :          0 :                                 if (sk_stream_is_writeable(sk))
     579                 :          0 :                                         mask |= EPOLLOUT | EPOLLWRNORM;
     580                 :            :                         }
     581                 :            :                 } else
     582                 :          0 :                         mask |= EPOLLOUT | EPOLLWRNORM;
     583                 :            : 
     584                 :          1 :                 if (tp->urg_data & TCP_URG_VALID)
     585                 :          0 :                         mask |= EPOLLPRI;
     586                 :          1 :         } else if (state == TCP_SYN_SENT && inet_sk(sk)->defer_connect) {
     587                 :            :                 /* Active TCP fastopen socket with defer_connect
     588                 :            :                  * Return EPOLLOUT so application can call write()
     589                 :            :                  * in order for kernel to generate SYN+data
     590                 :            :                  */
     591                 :          0 :                 mask |= EPOLLOUT | EPOLLWRNORM;
     592                 :            :         }
     593                 :            :         /* This barrier is coupled with smp_wmb() in tcp_reset() */
     594                 :          1 :         smp_rmb();
     595                 :          1 :         if (sk->sk_err || !skb_queue_empty_lockless(&sk->sk_error_queue))
     596                 :          0 :                 mask |= EPOLLERR;
     597                 :            : 
     598                 :          1 :         return mask;
     599                 :            : }
     600                 :            : EXPORT_SYMBOL(tcp_poll);
     601                 :            : 
     602                 :          0 : int tcp_ioctl(struct sock *sk, int cmd, unsigned long arg)
     603                 :            : {
     604                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     605                 :            :         int answ;
     606                 :            :         bool slow;
     607                 :            : 
     608                 :          0 :         switch (cmd) {
     609                 :            :         case SIOCINQ:
     610                 :          0 :                 if (sk->sk_state == TCP_LISTEN)
     611                 :            :                         return -EINVAL;
     612                 :            : 
     613                 :          0 :                 slow = lock_sock_fast(sk);
     614                 :          0 :                 answ = tcp_inq(sk);
     615                 :            :                 unlock_sock_fast(sk, slow);
     616                 :            :                 break;
     617                 :            :         case SIOCATMARK:
     618                 :          0 :                 answ = tp->urg_data &&
     619                 :            :                        READ_ONCE(tp->urg_seq) == READ_ONCE(tp->copied_seq);
     620                 :          0 :                 break;
     621                 :            :         case SIOCOUTQ:
     622                 :          0 :                 if (sk->sk_state == TCP_LISTEN)
     623                 :            :                         return -EINVAL;
     624                 :            : 
     625                 :          0 :                 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
     626                 :            :                         answ = 0;
     627                 :            :                 else
     628                 :          0 :                         answ = READ_ONCE(tp->write_seq) - tp->snd_una;
     629                 :            :                 break;
     630                 :            :         case SIOCOUTQNSD:
     631                 :          0 :                 if (sk->sk_state == TCP_LISTEN)
     632                 :            :                         return -EINVAL;
     633                 :            : 
     634                 :          0 :                 if ((1 << sk->sk_state) & (TCPF_SYN_SENT | TCPF_SYN_RECV))
     635                 :            :                         answ = 0;
     636                 :            :                 else
     637                 :          0 :                         answ = READ_ONCE(tp->write_seq) -
     638                 :            :                                READ_ONCE(tp->snd_nxt);
     639                 :            :                 break;
     640                 :            :         default:
     641                 :            :                 return -ENOIOCTLCMD;
     642                 :            :         }
     643                 :            : 
     644                 :          0 :         return put_user(answ, (int __user *)arg);
     645                 :            : }
     646                 :            : EXPORT_SYMBOL(tcp_ioctl);
     647                 :            : 
     648                 :            : static inline void tcp_mark_push(struct tcp_sock *tp, struct sk_buff *skb)
     649                 :            : {
     650                 :          1 :         TCP_SKB_CB(skb)->tcp_flags |= TCPHDR_PSH;
     651                 :          1 :         tp->pushed_seq = tp->write_seq;
     652                 :            : }
     653                 :            : 
     654                 :            : static inline bool forced_push(const struct tcp_sock *tp)
     655                 :            : {
     656                 :          0 :         return after(tp->write_seq, tp->pushed_seq + (tp->max_window >> 1));
     657                 :            : }
     658                 :            : 
     659                 :          1 : static void skb_entail(struct sock *sk, struct sk_buff *skb)
     660                 :            : {
     661                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     662                 :            :         struct tcp_skb_cb *tcb = TCP_SKB_CB(skb);
     663                 :            : 
     664                 :          1 :         skb->csum    = 0;
     665                 :          1 :         tcb->seq     = tcb->end_seq = tp->write_seq;
     666                 :          1 :         tcb->tcp_flags = TCPHDR_ACK;
     667                 :          1 :         tcb->sacked  = 0;
     668                 :            :         __skb_header_release(skb);
     669                 :          1 :         tcp_add_write_queue_tail(sk, skb);
     670                 :          1 :         sk_wmem_queued_add(sk, skb->truesize);
     671                 :          1 :         sk_mem_charge(sk, skb->truesize);
     672                 :          1 :         if (tp->nonagle & TCP_NAGLE_PUSH)
     673                 :          1 :                 tp->nonagle &= ~TCP_NAGLE_PUSH;
     674                 :            : 
     675                 :          1 :         tcp_slow_start_after_idle_check(sk);
     676                 :          1 : }
     677                 :            : 
     678                 :            : static inline void tcp_mark_urg(struct tcp_sock *tp, int flags)
     679                 :            : {
     680                 :          1 :         if (flags & MSG_OOB)
     681                 :          0 :                 tp->snd_up = tp->write_seq;
     682                 :            : }
     683                 :            : 
     684                 :            : /* If a not yet filled skb is pushed, do not send it if
     685                 :            :  * we have data packets in Qdisc or NIC queues :
     686                 :            :  * Because TX completion will happen shortly, it gives a chance
     687                 :            :  * to coalesce future sendmsg() payload into this skb, without
     688                 :            :  * need for a timer, and with no latency trade off.
     689                 :            :  * As packets containing data payload have a bigger truesize
     690                 :            :  * than pure acks (dataless) packets, the last checks prevent
     691                 :            :  * autocorking if we only have an ACK in Qdisc/NIC queues,
     692                 :            :  * or if TX completion was delayed after we processed ACK packet.
     693                 :            :  */
     694                 :            : static bool tcp_should_autocork(struct sock *sk, struct sk_buff *skb,
     695                 :            :                                 int size_goal)
     696                 :            : {
     697                 :          1 :         return skb->len < size_goal &&
     698                 :          1 :                sock_net(sk)->ipv4.sysctl_tcp_autocorking &&
     699                 :          1 :                !tcp_rtx_queue_empty(sk) &&
     700                 :          1 :                refcount_read(&sk->sk_wmem_alloc) > skb->truesize;
     701                 :            : }
     702                 :            : 
     703                 :          1 : static void tcp_push(struct sock *sk, int flags, int mss_now,
     704                 :            :                      int nonagle, int size_goal)
     705                 :            : {
     706                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     707                 :            :         struct sk_buff *skb;
     708                 :            : 
     709                 :            :         skb = tcp_write_queue_tail(sk);
     710                 :          1 :         if (!skb)
     711                 :            :                 return;
     712                 :          1 :         if (!(flags & MSG_MORE) || forced_push(tp))
     713                 :            :                 tcp_mark_push(tp, skb);
     714                 :            : 
     715                 :            :         tcp_mark_urg(tp, flags);
     716                 :            : 
     717                 :          1 :         if (tcp_should_autocork(sk, skb, size_goal)) {
     718                 :            : 
     719                 :            :                 /* avoid atomic op if TSQ_THROTTLED bit is already set */
     720                 :          1 :                 if (!test_bit(TSQ_THROTTLED, &sk->sk_tsq_flags)) {
     721                 :          1 :                         NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPAUTOCORKING);
     722                 :          1 :                         set_bit(TSQ_THROTTLED, &sk->sk_tsq_flags);
     723                 :            :                 }
     724                 :            :                 /* It is possible TX completion already happened
     725                 :            :                  * before we set TSQ_THROTTLED.
     726                 :            :                  */
     727                 :          1 :                 if (refcount_read(&sk->sk_wmem_alloc) > skb->truesize)
     728                 :            :                         return;
     729                 :            :         }
     730                 :            : 
     731                 :          1 :         if (flags & MSG_MORE)
     732                 :            :                 nonagle = TCP_NAGLE_CORK;
     733                 :            : 
     734                 :          1 :         __tcp_push_pending_frames(sk, mss_now, nonagle);
     735                 :            : }
     736                 :            : 
     737                 :          0 : static int tcp_splice_data_recv(read_descriptor_t *rd_desc, struct sk_buff *skb,
     738                 :            :                                 unsigned int offset, size_t len)
     739                 :            : {
     740                 :          0 :         struct tcp_splice_state *tss = rd_desc->arg.data;
     741                 :            :         int ret;
     742                 :            : 
     743                 :          0 :         ret = skb_splice_bits(skb, skb->sk, offset, tss->pipe,
     744                 :          0 :                               min(rd_desc->count, len), tss->flags);
     745                 :          0 :         if (ret > 0)
     746                 :          0 :                 rd_desc->count -= ret;
     747                 :          0 :         return ret;
     748                 :            : }
     749                 :            : 
     750                 :          0 : static int __tcp_splice_read(struct sock *sk, struct tcp_splice_state *tss)
     751                 :            : {
     752                 :            :         /* Store TCP splice context information in read_descriptor_t. */
     753                 :          0 :         read_descriptor_t rd_desc = {
     754                 :            :                 .arg.data = tss,
     755                 :          0 :                 .count    = tss->len,
     756                 :            :         };
     757                 :            : 
     758                 :          0 :         return tcp_read_sock(sk, &rd_desc, tcp_splice_data_recv);
     759                 :            : }
     760                 :            : 
     761                 :            : /**
     762                 :            :  *  tcp_splice_read - splice data from TCP socket to a pipe
     763                 :            :  * @sock:       socket to splice from
     764                 :            :  * @ppos:       position (not valid)
     765                 :            :  * @pipe:       pipe to splice to
     766                 :            :  * @len:        number of bytes to splice
     767                 :            :  * @flags:      splice modifier flags
     768                 :            :  *
     769                 :            :  * Description:
     770                 :            :  *    Will read pages from given socket and fill them into a pipe.
     771                 :            :  *
     772                 :            :  **/
     773                 :          0 : ssize_t tcp_splice_read(struct socket *sock, loff_t *ppos,
     774                 :            :                         struct pipe_inode_info *pipe, size_t len,
     775                 :            :                         unsigned int flags)
     776                 :            : {
     777                 :          0 :         struct sock *sk = sock->sk;
     778                 :          0 :         struct tcp_splice_state tss = {
     779                 :            :                 .pipe = pipe,
     780                 :            :                 .len = len,
     781                 :            :                 .flags = flags,
     782                 :            :         };
     783                 :            :         long timeo;
     784                 :            :         ssize_t spliced;
     785                 :            :         int ret;
     786                 :            : 
     787                 :          0 :         sock_rps_record_flow(sk);
     788                 :            :         /*
     789                 :            :          * We can't seek on a socket input
     790                 :            :          */
     791                 :          0 :         if (unlikely(*ppos))
     792                 :            :                 return -ESPIPE;
     793                 :            : 
     794                 :            :         ret = spliced = 0;
     795                 :            : 
     796                 :            :         lock_sock(sk);
     797                 :            : 
     798                 :          0 :         timeo = sock_rcvtimeo(sk, sock->file->f_flags & O_NONBLOCK);
     799                 :          0 :         while (tss.len) {
     800                 :          0 :                 ret = __tcp_splice_read(sk, &tss);
     801                 :          0 :                 if (ret < 0)
     802                 :            :                         break;
     803                 :          0 :                 else if (!ret) {
     804                 :          0 :                         if (spliced)
     805                 :            :                                 break;
     806                 :          0 :                         if (sock_flag(sk, SOCK_DONE))
     807                 :            :                                 break;
     808                 :          0 :                         if (sk->sk_err) {
     809                 :          0 :                                 ret = sock_error(sk);
     810                 :          0 :                                 break;
     811                 :            :                         }
     812                 :          0 :                         if (sk->sk_shutdown & RCV_SHUTDOWN)
     813                 :            :                                 break;
     814                 :          0 :                         if (sk->sk_state == TCP_CLOSE) {
     815                 :            :                                 /*
     816                 :            :                                  * This occurs when user tries to read
     817                 :            :                                  * from never connected socket.
     818                 :            :                                  */
     819                 :            :                                 ret = -ENOTCONN;
     820                 :            :                                 break;
     821                 :            :                         }
     822                 :          0 :                         if (!timeo) {
     823                 :            :                                 ret = -EAGAIN;
     824                 :            :                                 break;
     825                 :            :                         }
     826                 :            :                         /* if __tcp_splice_read() got nothing while we have
     827                 :            :                          * an skb in receive queue, we do not want to loop.
     828                 :            :                          * This might happen with URG data.
     829                 :            :                          */
     830                 :          0 :                         if (!skb_queue_empty(&sk->sk_receive_queue))
     831                 :            :                                 break;
     832                 :          0 :                         sk_wait_data(sk, &timeo, NULL);
     833                 :          0 :                         if (signal_pending(current)) {
     834                 :          0 :                                 ret = sock_intr_errno(timeo);
     835                 :          0 :                                 break;
     836                 :            :                         }
     837                 :          0 :                         continue;
     838                 :            :                 }
     839                 :          0 :                 tss.len -= ret;
     840                 :          0 :                 spliced += ret;
     841                 :            : 
     842                 :          0 :                 if (!timeo)
     843                 :            :                         break;
     844                 :          0 :                 release_sock(sk);
     845                 :            :                 lock_sock(sk);
     846                 :            : 
     847                 :          0 :                 if (sk->sk_err || sk->sk_state == TCP_CLOSE ||
     848                 :          0 :                     (sk->sk_shutdown & RCV_SHUTDOWN) ||
     849                 :          0 :                     signal_pending(current))
     850                 :            :                         break;
     851                 :            :         }
     852                 :            : 
     853                 :          0 :         release_sock(sk);
     854                 :            : 
     855                 :          0 :         if (spliced)
     856                 :            :                 return spliced;
     857                 :            : 
     858                 :          0 :         return ret;
     859                 :            : }
     860                 :            : EXPORT_SYMBOL(tcp_splice_read);
     861                 :            : 
     862                 :          1 : struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp,
     863                 :            :                                     bool force_schedule)
     864                 :            : {
     865                 :            :         struct sk_buff *skb;
     866                 :            : 
     867                 :          1 :         if (likely(!size)) {
     868                 :          1 :                 skb = sk->sk_tx_skb_cache;
     869                 :          1 :                 if (skb) {
     870                 :          0 :                         skb->truesize = SKB_TRUESIZE(skb_end_offset(skb));
     871                 :          0 :                         sk->sk_tx_skb_cache = NULL;
     872                 :            :                         pskb_trim(skb, 0);
     873                 :          0 :                         INIT_LIST_HEAD(&skb->tcp_tsorted_anchor);
     874                 :          0 :                         skb_shinfo(skb)->tx_flags = 0;
     875                 :          0 :                         memset(TCP_SKB_CB(skb), 0, sizeof(struct tcp_skb_cb));
     876                 :          0 :                         return skb;
     877                 :            :                 }
     878                 :            :         }
     879                 :            :         /* The TCP header must be at least 32-bit aligned.  */
     880                 :          1 :         size = ALIGN(size, 4);
     881                 :            : 
     882                 :          1 :         if (unlikely(tcp_under_memory_pressure(sk)))
     883                 :          0 :                 sk_mem_reclaim_partial(sk);
     884                 :            : 
     885                 :          1 :         skb = alloc_skb_fclone(size + sk->sk_prot->max_header, gfp);
     886                 :          1 :         if (likely(skb)) {
     887                 :            :                 bool mem_scheduled;
     888                 :            : 
     889                 :          1 :                 if (force_schedule) {
     890                 :            :                         mem_scheduled = true;
     891                 :          1 :                         sk_forced_mem_schedule(sk, skb->truesize);
     892                 :            :                 } else {
     893                 :          1 :                         mem_scheduled = sk_wmem_schedule(sk, skb->truesize);
     894                 :            :                 }
     895                 :          1 :                 if (likely(mem_scheduled)) {
     896                 :          1 :                         skb_reserve(skb, sk->sk_prot->max_header);
     897                 :            :                         /*
     898                 :            :                          * Make sure that we have exactly size bytes
     899                 :            :                          * available to the caller, no more, no less.
     900                 :            :                          */
     901                 :          1 :                         skb->reserved_tailroom = skb->end - skb->tail - size;
     902                 :          1 :                         INIT_LIST_HEAD(&skb->tcp_tsorted_anchor);
     903                 :          1 :                         return skb;
     904                 :            :                 }
     905                 :          0 :                 __kfree_skb(skb);
     906                 :            :         } else {
     907                 :          0 :                 sk->sk_prot->enter_memory_pressure(sk);
     908                 :            :                 sk_stream_moderate_sndbuf(sk);
     909                 :            :         }
     910                 :            :         return NULL;
     911                 :            : }
     912                 :            : 
     913                 :          1 : static unsigned int tcp_xmit_size_goal(struct sock *sk, u32 mss_now,
     914                 :            :                                        int large_allowed)
     915                 :            : {
     916                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     917                 :            :         u32 new_size_goal, size_goal;
     918                 :            : 
     919                 :          1 :         if (!large_allowed)
     920                 :            :                 return mss_now;
     921                 :            : 
     922                 :            :         /* Note : tcp_tso_autosize() will eventually split this later */
     923                 :          1 :         new_size_goal = sk->sk_gso_max_size - 1 - MAX_TCP_HEADER;
     924                 :          1 :         new_size_goal = tcp_bound_to_half_wnd(tp, new_size_goal);
     925                 :            : 
     926                 :            :         /* We try hard to avoid divides here */
     927                 :          1 :         size_goal = tp->gso_segs * mss_now;
     928                 :          1 :         if (unlikely(new_size_goal < size_goal ||
     929                 :            :                      new_size_goal >= size_goal + mss_now)) {
     930                 :          1 :                 tp->gso_segs = min_t(u16, new_size_goal / mss_now,
     931                 :            :                                      sk->sk_gso_max_segs);
     932                 :          1 :                 size_goal = tp->gso_segs * mss_now;
     933                 :            :         }
     934                 :            : 
     935                 :          1 :         return max(size_goal, mss_now);
     936                 :            : }
     937                 :            : 
     938                 :          1 : static int tcp_send_mss(struct sock *sk, int *size_goal, int flags)
     939                 :            : {
     940                 :            :         int mss_now;
     941                 :            : 
     942                 :          1 :         mss_now = tcp_current_mss(sk);
     943                 :          1 :         *size_goal = tcp_xmit_size_goal(sk, mss_now, !(flags & MSG_OOB));
     944                 :            : 
     945                 :          1 :         return mss_now;
     946                 :            : }
     947                 :            : 
     948                 :            : /* In some cases, both sendpage() and sendmsg() could have added
     949                 :            :  * an skb to the write queue, but failed adding payload on it.
     950                 :            :  * We need to remove it to consume less memory, but more
     951                 :            :  * importantly be able to generate EPOLLOUT for Edge Trigger epoll()
     952                 :            :  * users.
     953                 :            :  */
     954                 :          0 : static void tcp_remove_empty_skb(struct sock *sk, struct sk_buff *skb)
     955                 :            : {
     956                 :          0 :         if (skb && !skb->len) {
     957                 :            :                 tcp_unlink_write_queue(skb, sk);
     958                 :          0 :                 if (tcp_write_queue_empty(sk))
     959                 :          0 :                         tcp_chrono_stop(sk, TCP_CHRONO_BUSY);
     960                 :          0 :                 sk_wmem_free_skb(sk, skb);
     961                 :            :         }
     962                 :          0 : }
     963                 :            : 
     964                 :          0 : ssize_t do_tcp_sendpages(struct sock *sk, struct page *page, int offset,
     965                 :            :                          size_t size, int flags)
     966                 :            : {
     967                 :            :         struct tcp_sock *tp = tcp_sk(sk);
     968                 :            :         int mss_now, size_goal;
     969                 :            :         int err;
     970                 :            :         ssize_t copied;
     971                 :          0 :         long timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
     972                 :            : 
     973                 :            :         if (IS_ENABLED(CONFIG_DEBUG_VM) &&
     974                 :            :             WARN_ONCE(PageSlab(page), "page must not be a Slab one"))
     975                 :            :                 return -EINVAL;
     976                 :            : 
     977                 :            :         /* Wait for a connection to finish. One exception is TCP Fast Open
     978                 :            :          * (passive side) where data is allowed to be sent before a connection
     979                 :            :          * is fully established.
     980                 :            :          */
     981                 :          0 :         if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
     982                 :            :             !tcp_passive_fastopen(sk)) {
     983                 :          0 :                 err = sk_stream_wait_connect(sk, &timeo);
     984                 :          0 :                 if (err != 0)
     985                 :            :                         goto out_err;
     986                 :            :         }
     987                 :            : 
     988                 :          0 :         sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
     989                 :            : 
     990                 :          0 :         mss_now = tcp_send_mss(sk, &size_goal, flags);
     991                 :            :         copied = 0;
     992                 :            : 
     993                 :            :         err = -EPIPE;
     994                 :          0 :         if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
     995                 :            :                 goto out_err;
     996                 :            : 
     997                 :          0 :         while (size > 0) {
     998                 :            :                 struct sk_buff *skb = tcp_write_queue_tail(sk);
     999                 :            :                 int copy, i;
    1000                 :            :                 bool can_coalesce;
    1001                 :            : 
    1002                 :          0 :                 if (!skb || (copy = size_goal - skb->len) <= 0 ||
    1003                 :            :                     !tcp_skb_can_collapse_to(skb)) {
    1004                 :            : new_segment:
    1005                 :          0 :                         if (!sk_stream_memory_free(sk))
    1006                 :            :                                 goto wait_for_sndbuf;
    1007                 :            : 
    1008                 :          0 :                         skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation,
    1009                 :            :                                         tcp_rtx_and_write_queues_empty(sk));
    1010                 :          0 :                         if (!skb)
    1011                 :            :                                 goto wait_for_memory;
    1012                 :            : 
    1013                 :            : #ifdef CONFIG_TLS_DEVICE
    1014                 :            :                         skb->decrypted = !!(flags & MSG_SENDPAGE_DECRYPTED);
    1015                 :            : #endif
    1016                 :          0 :                         skb_entail(sk, skb);
    1017                 :          0 :                         copy = size_goal;
    1018                 :            :                 }
    1019                 :            : 
    1020                 :          0 :                 if (copy > size)
    1021                 :          0 :                         copy = size;
    1022                 :            : 
    1023                 :          0 :                 i = skb_shinfo(skb)->nr_frags;
    1024                 :          0 :                 can_coalesce = skb_can_coalesce(skb, i, page, offset);
    1025                 :          0 :                 if (!can_coalesce && i >= sysctl_max_skb_frags) {
    1026                 :            :                         tcp_mark_push(tp, skb);
    1027                 :            :                         goto new_segment;
    1028                 :            :                 }
    1029                 :          0 :                 if (!sk_wmem_schedule(sk, copy))
    1030                 :            :                         goto wait_for_memory;
    1031                 :            : 
    1032                 :          0 :                 if (can_coalesce) {
    1033                 :          0 :                         skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
    1034                 :            :                 } else {
    1035                 :          0 :                         get_page(page);
    1036                 :            :                         skb_fill_page_desc(skb, i, page, offset, copy);
    1037                 :            :                 }
    1038                 :            : 
    1039                 :          0 :                 if (!(flags & MSG_NO_SHARED_FRAGS))
    1040                 :          0 :                         skb_shinfo(skb)->tx_flags |= SKBTX_SHARED_FRAG;
    1041                 :            : 
    1042                 :          0 :                 skb->len += copy;
    1043                 :          0 :                 skb->data_len += copy;
    1044                 :          0 :                 skb->truesize += copy;
    1045                 :            :                 sk_wmem_queued_add(sk, copy);
    1046                 :            :                 sk_mem_charge(sk, copy);
    1047                 :          0 :                 skb->ip_summed = CHECKSUM_PARTIAL;
    1048                 :          0 :                 WRITE_ONCE(tp->write_seq, tp->write_seq + copy);
    1049                 :          0 :                 TCP_SKB_CB(skb)->end_seq += copy;
    1050                 :            :                 tcp_skb_pcount_set(skb, 0);
    1051                 :            : 
    1052                 :          0 :                 if (!copied)
    1053                 :          0 :                         TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
    1054                 :            : 
    1055                 :          0 :                 copied += copy;
    1056                 :          0 :                 offset += copy;
    1057                 :          0 :                 size -= copy;
    1058                 :          0 :                 if (!size)
    1059                 :            :                         goto out;
    1060                 :            : 
    1061                 :          0 :                 if (skb->len < size_goal || (flags & MSG_OOB))
    1062                 :          0 :                         continue;
    1063                 :            : 
    1064                 :          0 :                 if (forced_push(tp)) {
    1065                 :            :                         tcp_mark_push(tp, skb);
    1066                 :          0 :                         __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
    1067                 :          0 :                 } else if (skb == tcp_send_head(sk))
    1068                 :          0 :                         tcp_push_one(sk, mss_now);
    1069                 :          0 :                 continue;
    1070                 :            : 
    1071                 :            : wait_for_sndbuf:
    1072                 :          0 :                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
    1073                 :            : wait_for_memory:
    1074                 :          0 :                 tcp_push(sk, flags & ~MSG_MORE, mss_now,
    1075                 :            :                          TCP_NAGLE_PUSH, size_goal);
    1076                 :            : 
    1077                 :          0 :                 err = sk_stream_wait_memory(sk, &timeo);
    1078                 :          0 :                 if (err != 0)
    1079                 :            :                         goto do_error;
    1080                 :            : 
    1081                 :          0 :                 mss_now = tcp_send_mss(sk, &size_goal, flags);
    1082                 :            :         }
    1083                 :            : 
    1084                 :            : out:
    1085                 :          0 :         if (copied) {
    1086                 :          0 :                 tcp_tx_timestamp(sk, sk->sk_tsflags);
    1087                 :          0 :                 if (!(flags & MSG_SENDPAGE_NOTLAST))
    1088                 :          0 :                         tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
    1089                 :            :         }
    1090                 :          0 :         return copied;
    1091                 :            : 
    1092                 :            : do_error:
    1093                 :          0 :         tcp_remove_empty_skb(sk, tcp_write_queue_tail(sk));
    1094                 :          0 :         if (copied)
    1095                 :            :                 goto out;
    1096                 :            : out_err:
    1097                 :            :         /* make sure we wake any epoll edge trigger waiter */
    1098                 :          0 :         if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) {
    1099                 :          0 :                 sk->sk_write_space(sk);
    1100                 :          0 :                 tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
    1101                 :            :         }
    1102                 :          0 :         return sk_stream_error(sk, flags, err);
    1103                 :            : }
    1104                 :            : EXPORT_SYMBOL_GPL(do_tcp_sendpages);
    1105                 :            : 
    1106                 :          0 : int tcp_sendpage_locked(struct sock *sk, struct page *page, int offset,
    1107                 :            :                         size_t size, int flags)
    1108                 :            : {
    1109                 :          0 :         if (!(sk->sk_route_caps & NETIF_F_SG))
    1110                 :          0 :                 return sock_no_sendpage_locked(sk, page, offset, size, flags);
    1111                 :            : 
    1112                 :          0 :         tcp_rate_check_app_limited(sk);  /* is sending application-limited? */
    1113                 :            : 
    1114                 :          0 :         return do_tcp_sendpages(sk, page, offset, size, flags);
    1115                 :            : }
    1116                 :            : EXPORT_SYMBOL_GPL(tcp_sendpage_locked);
    1117                 :            : 
    1118                 :          0 : int tcp_sendpage(struct sock *sk, struct page *page, int offset,
    1119                 :            :                  size_t size, int flags)
    1120                 :            : {
    1121                 :            :         int ret;
    1122                 :            : 
    1123                 :            :         lock_sock(sk);
    1124                 :          0 :         ret = tcp_sendpage_locked(sk, page, offset, size, flags);
    1125                 :          0 :         release_sock(sk);
    1126                 :            : 
    1127                 :          0 :         return ret;
    1128                 :            : }
    1129                 :            : EXPORT_SYMBOL(tcp_sendpage);
    1130                 :            : 
    1131                 :          1 : void tcp_free_fastopen_req(struct tcp_sock *tp)
    1132                 :            : {
    1133                 :          1 :         if (tp->fastopen_req) {
    1134                 :          0 :                 kfree(tp->fastopen_req);
    1135                 :          0 :                 tp->fastopen_req = NULL;
    1136                 :            :         }
    1137                 :          1 : }
    1138                 :            : 
    1139                 :          0 : static int tcp_sendmsg_fastopen(struct sock *sk, struct msghdr *msg,
    1140                 :            :                                 int *copied, size_t size,
    1141                 :            :                                 struct ubuf_info *uarg)
    1142                 :            : {
    1143                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1144                 :            :         struct inet_sock *inet = inet_sk(sk);
    1145                 :          0 :         struct sockaddr *uaddr = msg->msg_name;
    1146                 :            :         int err, flags;
    1147                 :            : 
    1148                 :          0 :         if (!(sock_net(sk)->ipv4.sysctl_tcp_fastopen & TFO_CLIENT_ENABLE) ||
    1149                 :          0 :             (uaddr && msg->msg_namelen >= sizeof(uaddr->sa_family) &&
    1150                 :          0 :              uaddr->sa_family == AF_UNSPEC))
    1151                 :            :                 return -EOPNOTSUPP;
    1152                 :          0 :         if (tp->fastopen_req)
    1153                 :            :                 return -EALREADY; /* Another Fast Open is in progress */
    1154                 :            : 
    1155                 :          0 :         tp->fastopen_req = kzalloc(sizeof(struct tcp_fastopen_request),
    1156                 :            :                                    sk->sk_allocation);
    1157                 :          0 :         if (unlikely(!tp->fastopen_req))
    1158                 :            :                 return -ENOBUFS;
    1159                 :          0 :         tp->fastopen_req->data = msg;
    1160                 :          0 :         tp->fastopen_req->size = size;
    1161                 :          0 :         tp->fastopen_req->uarg = uarg;
    1162                 :            : 
    1163                 :          0 :         if (inet->defer_connect) {
    1164                 :          0 :                 err = tcp_connect(sk);
    1165                 :            :                 /* Same failure procedure as in tcp_v4/6_connect */
    1166                 :          0 :                 if (err) {
    1167                 :          0 :                         tcp_set_state(sk, TCP_CLOSE);
    1168                 :          0 :                         inet->inet_dport = 0;
    1169                 :          0 :                         sk->sk_route_caps = 0;
    1170                 :            :                 }
    1171                 :            :         }
    1172                 :          0 :         flags = (msg->msg_flags & MSG_DONTWAIT) ? O_NONBLOCK : 0;
    1173                 :          0 :         err = __inet_stream_connect(sk->sk_socket, uaddr,
    1174                 :            :                                     msg->msg_namelen, flags, 1);
    1175                 :            :         /* fastopen_req could already be freed in __inet_stream_connect
    1176                 :            :          * if the connection times out or gets rst
    1177                 :            :          */
    1178                 :          0 :         if (tp->fastopen_req) {
    1179                 :          0 :                 *copied = tp->fastopen_req->copied;
    1180                 :            :                 tcp_free_fastopen_req(tp);
    1181                 :          0 :                 inet->defer_connect = 0;
    1182                 :            :         }
    1183                 :          0 :         return err;
    1184                 :            : }
    1185                 :            : 
    1186                 :          1 : int tcp_sendmsg_locked(struct sock *sk, struct msghdr *msg, size_t size)
    1187                 :            : {
    1188                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1189                 :            :         struct ubuf_info *uarg = NULL;
    1190                 :            :         struct sk_buff *skb;
    1191                 :            :         struct sockcm_cookie sockc;
    1192                 :            :         int flags, err, copied = 0;
    1193                 :          1 :         int mss_now = 0, size_goal, copied_syn = 0;
    1194                 :            :         int process_backlog = 0;
    1195                 :            :         bool zc = false;
    1196                 :            :         long timeo;
    1197                 :            : 
    1198                 :          1 :         flags = msg->msg_flags;
    1199                 :            : 
    1200                 :          1 :         if (flags & MSG_ZEROCOPY && size && sock_flag(sk, SOCK_ZEROCOPY)) {
    1201                 :            :                 skb = tcp_write_queue_tail(sk);
    1202                 :          0 :                 uarg = sock_zerocopy_realloc(sk, size, skb_zcopy(skb));
    1203                 :          0 :                 if (!uarg) {
    1204                 :            :                         err = -ENOBUFS;
    1205                 :            :                         goto out_err;
    1206                 :            :                 }
    1207                 :            : 
    1208                 :          0 :                 zc = sk->sk_route_caps & NETIF_F_SG;
    1209                 :          0 :                 if (!zc)
    1210                 :          0 :                         uarg->zerocopy = 0;
    1211                 :            :         }
    1212                 :            : 
    1213                 :          1 :         if (unlikely(flags & MSG_FASTOPEN || inet_sk(sk)->defer_connect) &&
    1214                 :          0 :             !tp->repair) {
    1215                 :          0 :                 err = tcp_sendmsg_fastopen(sk, msg, &copied_syn, size, uarg);
    1216                 :          0 :                 if (err == -EINPROGRESS && copied_syn > 0)
    1217                 :            :                         goto out;
    1218                 :          0 :                 else if (err)
    1219                 :            :                         goto out_err;
    1220                 :            :         }
    1221                 :            : 
    1222                 :          1 :         timeo = sock_sndtimeo(sk, flags & MSG_DONTWAIT);
    1223                 :            : 
    1224                 :          1 :         tcp_rate_check_app_limited(sk);  /* is sending application-limited? */
    1225                 :            : 
    1226                 :            :         /* Wait for a connection to finish. One exception is TCP Fast Open
    1227                 :            :          * (passive side) where data is allowed to be sent before a connection
    1228                 :            :          * is fully established.
    1229                 :            :          */
    1230                 :          1 :         if (((1 << sk->sk_state) & ~(TCPF_ESTABLISHED | TCPF_CLOSE_WAIT)) &&
    1231                 :            :             !tcp_passive_fastopen(sk)) {
    1232                 :          0 :                 err = sk_stream_wait_connect(sk, &timeo);
    1233                 :          0 :                 if (err != 0)
    1234                 :            :                         goto do_error;
    1235                 :            :         }
    1236                 :            : 
    1237                 :          1 :         if (unlikely(tp->repair)) {
    1238                 :          0 :                 if (tp->repair_queue == TCP_RECV_QUEUE) {
    1239                 :          0 :                         copied = tcp_send_rcvq(sk, msg, size);
    1240                 :          0 :                         goto out_nopush;
    1241                 :            :                 }
    1242                 :            : 
    1243                 :            :                 err = -EINVAL;
    1244                 :          0 :                 if (tp->repair_queue == TCP_NO_QUEUE)
    1245                 :            :                         goto out_err;
    1246                 :            : 
    1247                 :            :                 /* 'common' sending to sendq */
    1248                 :            :         }
    1249                 :            : 
    1250                 :            :         sockcm_init(&sockc, sk);
    1251                 :          1 :         if (msg->msg_controllen) {
    1252                 :          0 :                 err = sock_cmsg_send(sk, msg, &sockc);
    1253                 :          0 :                 if (unlikely(err)) {
    1254                 :            :                         err = -EINVAL;
    1255                 :            :                         goto out_err;
    1256                 :            :                 }
    1257                 :            :         }
    1258                 :            : 
    1259                 :            :         /* This should be in poll */
    1260                 :          1 :         sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
    1261                 :            : 
    1262                 :            :         /* Ok commence sending. */
    1263                 :            :         copied = 0;
    1264                 :            : 
    1265                 :            : restart:
    1266                 :          1 :         mss_now = tcp_send_mss(sk, &size_goal, flags);
    1267                 :            : 
    1268                 :            :         err = -EPIPE;
    1269                 :          1 :         if (sk->sk_err || (sk->sk_shutdown & SEND_SHUTDOWN))
    1270                 :            :                 goto do_error;
    1271                 :            : 
    1272                 :          1 :         while (msg_data_left(msg)) {
    1273                 :            :                 int copy = 0;
    1274                 :            : 
    1275                 :            :                 skb = tcp_write_queue_tail(sk);
    1276                 :          1 :                 if (skb)
    1277                 :          1 :                         copy = size_goal - skb->len;
    1278                 :            : 
    1279                 :          1 :                 if (copy <= 0 || !tcp_skb_can_collapse_to(skb)) {
    1280                 :            :                         bool first_skb;
    1281                 :            : 
    1282                 :            : new_segment:
    1283                 :          1 :                         if (!sk_stream_memory_free(sk))
    1284                 :            :                                 goto wait_for_sndbuf;
    1285                 :            : 
    1286                 :          1 :                         if (unlikely(process_backlog >= 16)) {
    1287                 :            :                                 process_backlog = 0;
    1288                 :          0 :                                 if (sk_flush_backlog(sk))
    1289                 :            :                                         goto restart;
    1290                 :            :                         }
    1291                 :            :                         first_skb = tcp_rtx_and_write_queues_empty(sk);
    1292                 :          1 :                         skb = sk_stream_alloc_skb(sk, 0, sk->sk_allocation,
    1293                 :            :                                                   first_skb);
    1294                 :          1 :                         if (!skb)
    1295                 :            :                                 goto wait_for_memory;
    1296                 :            : 
    1297                 :          1 :                         process_backlog++;
    1298                 :          1 :                         skb->ip_summed = CHECKSUM_PARTIAL;
    1299                 :            : 
    1300                 :          1 :                         skb_entail(sk, skb);
    1301                 :          1 :                         copy = size_goal;
    1302                 :            : 
    1303                 :            :                         /* All packets are restored as if they have
    1304                 :            :                          * already been sent. skb_mstamp_ns isn't set to
    1305                 :            :                          * avoid wrong rtt estimation.
    1306                 :            :                          */
    1307                 :          1 :                         if (tp->repair)
    1308                 :          0 :                                 TCP_SKB_CB(skb)->sacked |= TCPCB_REPAIRED;
    1309                 :            :                 }
    1310                 :            : 
    1311                 :            :                 /* Try to append data to the end of skb. */
    1312                 :          1 :                 if (copy > msg_data_left(msg))
    1313                 :          1 :                         copy = msg_data_left(msg);
    1314                 :            : 
    1315                 :            :                 /* Where to copy to? */
    1316                 :          1 :                 if (skb_availroom(skb) > 0 && !zc) {
    1317                 :            :                         /* We have some space in skb head. Superb! */
    1318                 :          0 :                         copy = min_t(int, copy, skb_availroom(skb));
    1319                 :          0 :                         err = skb_add_data_nocache(sk, skb, &msg->msg_iter, copy);
    1320                 :          0 :                         if (err)
    1321                 :            :                                 goto do_fault;
    1322                 :          1 :                 } else if (!zc) {
    1323                 :            :                         bool merge = true;
    1324                 :          1 :                         int i = skb_shinfo(skb)->nr_frags;
    1325                 :            :                         struct page_frag *pfrag = sk_page_frag(sk);
    1326                 :            : 
    1327                 :          1 :                         if (!sk_page_frag_refill(sk, pfrag))
    1328                 :            :                                 goto wait_for_memory;
    1329                 :            : 
    1330                 :          1 :                         if (!skb_can_coalesce(skb, i, pfrag->page,
    1331                 :          1 :                                               pfrag->offset)) {
    1332                 :          1 :                                 if (i >= sysctl_max_skb_frags) {
    1333                 :            :                                         tcp_mark_push(tp, skb);
    1334                 :            :                                         goto new_segment;
    1335                 :            :                                 }
    1336                 :            :                                 merge = false;
    1337                 :            :                         }
    1338                 :            : 
    1339                 :          1 :                         copy = min_t(int, copy, pfrag->size - pfrag->offset);
    1340                 :            : 
    1341                 :          1 :                         if (!sk_wmem_schedule(sk, copy))
    1342                 :            :                                 goto wait_for_memory;
    1343                 :            : 
    1344                 :          1 :                         err = skb_copy_to_page_nocache(sk, &msg->msg_iter, skb,
    1345                 :            :                                                        pfrag->page,
    1346                 :          1 :                                                        pfrag->offset,
    1347                 :            :                                                        copy);
    1348                 :          1 :                         if (err)
    1349                 :            :                                 goto do_error;
    1350                 :            : 
    1351                 :            :                         /* Update the skb. */
    1352                 :          1 :                         if (merge) {
    1353                 :          1 :                                 skb_frag_size_add(&skb_shinfo(skb)->frags[i - 1], copy);
    1354                 :            :                         } else {
    1355                 :          1 :                                 skb_fill_page_desc(skb, i, pfrag->page,
    1356                 :          1 :                                                    pfrag->offset, copy);
    1357                 :          1 :                                 page_ref_inc(pfrag->page);
    1358                 :            :                         }
    1359                 :          1 :                         pfrag->offset += copy;
    1360                 :            :                 } else {
    1361                 :          0 :                         err = skb_zerocopy_iter_stream(sk, skb, msg, copy, uarg);
    1362                 :          0 :                         if (err == -EMSGSIZE || err == -EEXIST) {
    1363                 :            :                                 tcp_mark_push(tp, skb);
    1364                 :            :                                 goto new_segment;
    1365                 :            :                         }
    1366                 :          0 :                         if (err < 0)
    1367                 :            :                                 goto do_error;
    1368                 :            :                         copy = err;
    1369                 :            :                 }
    1370                 :            : 
    1371                 :          1 :                 if (!copied)
    1372                 :          1 :                         TCP_SKB_CB(skb)->tcp_flags &= ~TCPHDR_PSH;
    1373                 :            : 
    1374                 :          1 :                 WRITE_ONCE(tp->write_seq, tp->write_seq + copy);
    1375                 :          1 :                 TCP_SKB_CB(skb)->end_seq += copy;
    1376                 :            :                 tcp_skb_pcount_set(skb, 0);
    1377                 :            : 
    1378                 :          1 :                 copied += copy;
    1379                 :          1 :                 if (!msg_data_left(msg)) {
    1380                 :          1 :                         if (unlikely(flags & MSG_EOR))
    1381                 :          0 :                                 TCP_SKB_CB(skb)->eor = 1;
    1382                 :            :                         goto out;
    1383                 :            :                 }
    1384                 :            : 
    1385                 :          0 :                 if (skb->len < size_goal || (flags & MSG_OOB) || unlikely(tp->repair))
    1386                 :          0 :                         continue;
    1387                 :            : 
    1388                 :          0 :                 if (forced_push(tp)) {
    1389                 :            :                         tcp_mark_push(tp, skb);
    1390                 :          0 :                         __tcp_push_pending_frames(sk, mss_now, TCP_NAGLE_PUSH);
    1391                 :          0 :                 } else if (skb == tcp_send_head(sk))
    1392                 :          0 :                         tcp_push_one(sk, mss_now);
    1393                 :          0 :                 continue;
    1394                 :            : 
    1395                 :            : wait_for_sndbuf:
    1396                 :          0 :                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
    1397                 :            : wait_for_memory:
    1398                 :          0 :                 if (copied)
    1399                 :          0 :                         tcp_push(sk, flags & ~MSG_MORE, mss_now,
    1400                 :            :                                  TCP_NAGLE_PUSH, size_goal);
    1401                 :            : 
    1402                 :          0 :                 err = sk_stream_wait_memory(sk, &timeo);
    1403                 :          0 :                 if (err != 0)
    1404                 :            :                         goto do_error;
    1405                 :            : 
    1406                 :          0 :                 mss_now = tcp_send_mss(sk, &size_goal, flags);
    1407                 :            :         }
    1408                 :            : 
    1409                 :            : out:
    1410                 :          1 :         if (copied) {
    1411                 :          1 :                 tcp_tx_timestamp(sk, sockc.tsflags);
    1412                 :          1 :                 tcp_push(sk, flags, mss_now, tp->nonagle, size_goal);
    1413                 :            :         }
    1414                 :            : out_nopush:
    1415                 :          1 :         sock_zerocopy_put(uarg);
    1416                 :          1 :         return copied + copied_syn;
    1417                 :            : 
    1418                 :            : do_error:
    1419                 :            :         skb = tcp_write_queue_tail(sk);
    1420                 :            : do_fault:
    1421                 :          0 :         tcp_remove_empty_skb(sk, skb);
    1422                 :            : 
    1423                 :          0 :         if (copied + copied_syn)
    1424                 :            :                 goto out;
    1425                 :            : out_err:
    1426                 :          0 :         sock_zerocopy_put_abort(uarg, true);
    1427                 :          0 :         err = sk_stream_error(sk, flags, err);
    1428                 :            :         /* make sure we wake any epoll edge trigger waiter */
    1429                 :          0 :         if (unlikely(tcp_rtx_and_write_queues_empty(sk) && err == -EAGAIN)) {
    1430                 :          0 :                 sk->sk_write_space(sk);
    1431                 :          0 :                 tcp_chrono_stop(sk, TCP_CHRONO_SNDBUF_LIMITED);
    1432                 :            :         }
    1433                 :          0 :         return err;
    1434                 :            : }
    1435                 :            : EXPORT_SYMBOL_GPL(tcp_sendmsg_locked);
    1436                 :            : 
    1437                 :          1 : int tcp_sendmsg(struct sock *sk, struct msghdr *msg, size_t size)
    1438                 :            : {
    1439                 :            :         int ret;
    1440                 :            : 
    1441                 :            :         lock_sock(sk);
    1442                 :          1 :         ret = tcp_sendmsg_locked(sk, msg, size);
    1443                 :          1 :         release_sock(sk);
    1444                 :            : 
    1445                 :          1 :         return ret;
    1446                 :            : }
    1447                 :            : EXPORT_SYMBOL(tcp_sendmsg);
    1448                 :            : 
    1449                 :            : /*
    1450                 :            :  *      Handle reading urgent data. BSD has very simple semantics for
    1451                 :            :  *      this, no blocking and very strange errors 8)
    1452                 :            :  */
    1453                 :            : 
    1454                 :          0 : static int tcp_recv_urg(struct sock *sk, struct msghdr *msg, int len, int flags)
    1455                 :            : {
    1456                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1457                 :            : 
    1458                 :            :         /* No URG data to read. */
    1459                 :          0 :         if (sock_flag(sk, SOCK_URGINLINE) || !tp->urg_data ||
    1460                 :            :             tp->urg_data == TCP_URG_READ)
    1461                 :            :                 return -EINVAL; /* Yes this is right ! */
    1462                 :            : 
    1463                 :          0 :         if (sk->sk_state == TCP_CLOSE && !sock_flag(sk, SOCK_DONE))
    1464                 :            :                 return -ENOTCONN;
    1465                 :            : 
    1466                 :          0 :         if (tp->urg_data & TCP_URG_VALID) {
    1467                 :            :                 int err = 0;
    1468                 :          0 :                 char c = tp->urg_data;
    1469                 :            : 
    1470                 :          0 :                 if (!(flags & MSG_PEEK))
    1471                 :          0 :                         tp->urg_data = TCP_URG_READ;
    1472                 :            : 
    1473                 :            :                 /* Read urgent data. */
    1474                 :          0 :                 msg->msg_flags |= MSG_OOB;
    1475                 :            : 
    1476                 :          0 :                 if (len > 0) {
    1477                 :          0 :                         if (!(flags & MSG_TRUNC))
    1478                 :          0 :                                 err = memcpy_to_msg(msg, &c, 1);
    1479                 :            :                         len = 1;
    1480                 :            :                 } else
    1481                 :          0 :                         msg->msg_flags |= MSG_TRUNC;
    1482                 :            : 
    1483                 :          0 :                 return err ? -EFAULT : len;
    1484                 :            :         }
    1485                 :            : 
    1486                 :          0 :         if (sk->sk_state == TCP_CLOSE || (sk->sk_shutdown & RCV_SHUTDOWN))
    1487                 :            :                 return 0;
    1488                 :            : 
    1489                 :            :         /* Fixed the recv(..., MSG_OOB) behaviour.  BSD docs and
    1490                 :            :          * the available implementations agree in this case:
    1491                 :            :          * this call should never block, independent of the
    1492                 :            :          * blocking state of the socket.
    1493                 :            :          * Mike <pall@rz.uni-karlsruhe.de>
    1494                 :            :          */
    1495                 :          0 :         return -EAGAIN;
    1496                 :            : }
    1497                 :            : 
    1498                 :          0 : static int tcp_peek_sndq(struct sock *sk, struct msghdr *msg, int len)
    1499                 :            : {
    1500                 :            :         struct sk_buff *skb;
    1501                 :            :         int copied = 0, err = 0;
    1502                 :            : 
    1503                 :            :         /* XXX -- need to support SO_PEEK_OFF */
    1504                 :            : 
    1505                 :          0 :         skb_rbtree_walk(skb, &sk->tcp_rtx_queue) {
    1506                 :          0 :                 err = skb_copy_datagram_msg(skb, 0, msg, skb->len);
    1507                 :          0 :                 if (err)
    1508                 :          0 :                         return err;
    1509                 :          0 :                 copied += skb->len;
    1510                 :            :         }
    1511                 :            : 
    1512                 :          0 :         skb_queue_walk(&sk->sk_write_queue, skb) {
    1513                 :          0 :                 err = skb_copy_datagram_msg(skb, 0, msg, skb->len);
    1514                 :          0 :                 if (err)
    1515                 :            :                         break;
    1516                 :            : 
    1517                 :          0 :                 copied += skb->len;
    1518                 :            :         }
    1519                 :            : 
    1520                 :          0 :         return err ?: copied;
    1521                 :            : }
    1522                 :            : 
    1523                 :            : /* Clean up the receive buffer for full frames taken by the user,
    1524                 :            :  * then send an ACK if necessary.  COPIED is the number of bytes
    1525                 :            :  * tcp_recvmsg has given to the user so far, it speeds up the
    1526                 :            :  * calculation of whether or not we must ACK for the sake of
    1527                 :            :  * a window update.
    1528                 :            :  */
    1529                 :          1 : static void tcp_cleanup_rbuf(struct sock *sk, int copied)
    1530                 :            : {
    1531                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1532                 :            :         bool time_to_ack = false;
    1533                 :            : 
    1534                 :          1 :         struct sk_buff *skb = skb_peek(&sk->sk_receive_queue);
    1535                 :            : 
    1536                 :          1 :         WARN(skb && !before(tp->copied_seq, TCP_SKB_CB(skb)->end_seq),
    1537                 :            :              "cleanup rbuf bug: copied %X seq %X rcvnxt %X\n",
    1538                 :            :              tp->copied_seq, TCP_SKB_CB(skb)->end_seq, tp->rcv_nxt);
    1539                 :            : 
    1540                 :          1 :         if (inet_csk_ack_scheduled(sk)) {
    1541                 :            :                 const struct inet_connection_sock *icsk = inet_csk(sk);
    1542                 :            :                    /* Delayed ACKs frequently hit locked sockets during bulk
    1543                 :            :                     * receive. */
    1544                 :          1 :                 if (icsk->icsk_ack.blocked ||
    1545                 :            :                     /* Once-per-two-segments ACK was not sent by tcp_input.c */
    1546                 :          1 :                     tp->rcv_nxt - tp->rcv_wup > icsk->icsk_ack.rcv_mss ||
    1547                 :            :                     /*
    1548                 :            :                      * If this read emptied read buffer, we send ACK, if
    1549                 :            :                      * connection is not bidirectional, user drained
    1550                 :            :                      * receive buffer and there was a small segment
    1551                 :            :                      * in queue.
    1552                 :            :                      */
    1553                 :          1 :                     (copied > 0 &&
    1554                 :          1 :                      ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED2) ||
    1555                 :          1 :                       ((icsk->icsk_ack.pending & ICSK_ACK_PUSHED) &&
    1556                 :          1 :                        !inet_csk_in_pingpong_mode(sk))) &&
    1557                 :          1 :                       !atomic_read(&sk->sk_rmem_alloc)))
    1558                 :            :                         time_to_ack = true;
    1559                 :            :         }
    1560                 :            : 
    1561                 :            :         /* We send an ACK if we can now advertise a non-zero window
    1562                 :            :          * which has been raised "significantly".
    1563                 :            :          *
    1564                 :            :          * Even if window raised up to infinity, do not send window open ACK
    1565                 :            :          * in states, where we will not receive more. It is useless.
    1566                 :            :          */
    1567                 :          1 :         if (copied > 0 && !time_to_ack && !(sk->sk_shutdown & RCV_SHUTDOWN)) {
    1568                 :            :                 __u32 rcv_window_now = tcp_receive_window(tp);
    1569                 :            : 
    1570                 :            :                 /* Optimize, __tcp_select_window() is not cheap. */
    1571                 :          1 :                 if (2*rcv_window_now <= tp->window_clamp) {
    1572                 :          1 :                         __u32 new_window = __tcp_select_window(sk);
    1573                 :            : 
    1574                 :            :                         /* Send ACK now, if this read freed lots of space
    1575                 :            :                          * in our buffer. Certainly, new_window is new window.
    1576                 :            :                          * We can advertise it now, if it is not less than current one.
    1577                 :            :                          * "Lots" means "at least twice" here.
    1578                 :            :                          */
    1579                 :          1 :                         if (new_window && new_window >= 2 * rcv_window_now)
    1580                 :            :                                 time_to_ack = true;
    1581                 :            :                 }
    1582                 :            :         }
    1583                 :          1 :         if (time_to_ack)
    1584                 :          1 :                 tcp_send_ack(sk);
    1585                 :          1 : }
    1586                 :            : 
    1587                 :          0 : static struct sk_buff *tcp_recv_skb(struct sock *sk, u32 seq, u32 *off)
    1588                 :            : {
    1589                 :            :         struct sk_buff *skb;
    1590                 :            :         u32 offset;
    1591                 :            : 
    1592                 :          0 :         while ((skb = skb_peek(&sk->sk_receive_queue)) != NULL) {
    1593                 :          0 :                 offset = seq - TCP_SKB_CB(skb)->seq;
    1594                 :          0 :                 if (unlikely(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
    1595                 :          0 :                         pr_err_once("%s: found a SYN, please report !\n", __func__);
    1596                 :          0 :                         offset--;
    1597                 :            :                 }
    1598                 :          0 :                 if (offset < skb->len || (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)) {
    1599                 :          0 :                         *off = offset;
    1600                 :          0 :                         return skb;
    1601                 :            :                 }
    1602                 :            :                 /* This looks weird, but this can happen if TCP collapsing
    1603                 :            :                  * splitted a fat GRO packet, while we released socket lock
    1604                 :            :                  * in skb_splice_bits()
    1605                 :            :                  */
    1606                 :          0 :                 sk_eat_skb(sk, skb);
    1607                 :            :         }
    1608                 :            :         return NULL;
    1609                 :            : }
    1610                 :            : 
    1611                 :            : /*
    1612                 :            :  * This routine provides an alternative to tcp_recvmsg() for routines
    1613                 :            :  * that would like to handle copying from skbuffs directly in 'sendfile'
    1614                 :            :  * fashion.
    1615                 :            :  * Note:
    1616                 :            :  *      - It is assumed that the socket was locked by the caller.
    1617                 :            :  *      - The routine does not block.
    1618                 :            :  *      - At present, there is no support for reading OOB data
    1619                 :            :  *        or for 'peeking' the socket using this routine
    1620                 :            :  *        (although both would be easy to implement).
    1621                 :            :  */
    1622                 :          0 : int tcp_read_sock(struct sock *sk, read_descriptor_t *desc,
    1623                 :            :                   sk_read_actor_t recv_actor)
    1624                 :            : {
    1625                 :            :         struct sk_buff *skb;
    1626                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1627                 :          0 :         u32 seq = tp->copied_seq;
    1628                 :            :         u32 offset;
    1629                 :            :         int copied = 0;
    1630                 :            : 
    1631                 :          0 :         if (sk->sk_state == TCP_LISTEN)
    1632                 :            :                 return -ENOTCONN;
    1633                 :          0 :         while ((skb = tcp_recv_skb(sk, seq, &offset)) != NULL) {
    1634                 :          0 :                 if (offset < skb->len) {
    1635                 :            :                         int used;
    1636                 :            :                         size_t len;
    1637                 :            : 
    1638                 :          0 :                         len = skb->len - offset;
    1639                 :            :                         /* Stop reading if we hit a patch of urgent data */
    1640                 :          0 :                         if (tp->urg_data) {
    1641                 :          0 :                                 u32 urg_offset = tp->urg_seq - seq;
    1642                 :          0 :                                 if (urg_offset < len)
    1643                 :            :                                         len = urg_offset;
    1644                 :          0 :                                 if (!len)
    1645                 :            :                                         break;
    1646                 :            :                         }
    1647                 :          0 :                         used = recv_actor(desc, skb, offset, len);
    1648                 :          0 :                         if (used <= 0) {
    1649                 :          0 :                                 if (!copied)
    1650                 :          0 :                                         copied = used;
    1651                 :            :                                 break;
    1652                 :          0 :                         } else if (used <= len) {
    1653                 :          0 :                                 seq += used;
    1654                 :          0 :                                 copied += used;
    1655                 :          0 :                                 offset += used;
    1656                 :            :                         }
    1657                 :            :                         /* If recv_actor drops the lock (e.g. TCP splice
    1658                 :            :                          * receive) the skb pointer might be invalid when
    1659                 :            :                          * getting here: tcp_collapse might have deleted it
    1660                 :            :                          * while aggregating skbs from the socket queue.
    1661                 :            :                          */
    1662                 :          0 :                         skb = tcp_recv_skb(sk, seq - 1, &offset);
    1663                 :          0 :                         if (!skb)
    1664                 :            :                                 break;
    1665                 :            :                         /* TCP coalescing might have appended data to the skb.
    1666                 :            :                          * Try to splice more frags
    1667                 :            :                          */
    1668                 :          0 :                         if (offset + 1 != skb->len)
    1669                 :          0 :                                 continue;
    1670                 :            :                 }
    1671                 :          0 :                 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN) {
    1672                 :          0 :                         sk_eat_skb(sk, skb);
    1673                 :          0 :                         ++seq;
    1674                 :          0 :                         break;
    1675                 :            :                 }
    1676                 :          0 :                 sk_eat_skb(sk, skb);
    1677                 :          0 :                 if (!desc->count)
    1678                 :            :                         break;
    1679                 :            :                 WRITE_ONCE(tp->copied_seq, seq);
    1680                 :            :         }
    1681                 :            :         WRITE_ONCE(tp->copied_seq, seq);
    1682                 :            : 
    1683                 :          0 :         tcp_rcv_space_adjust(sk);
    1684                 :            : 
    1685                 :            :         /* Clean up data we have read: This will do ACK frames. */
    1686                 :          0 :         if (copied > 0) {
    1687                 :          0 :                 tcp_recv_skb(sk, seq, &offset);
    1688                 :          0 :                 tcp_cleanup_rbuf(sk, copied);
    1689                 :            :         }
    1690                 :          0 :         return copied;
    1691                 :            : }
    1692                 :            : EXPORT_SYMBOL(tcp_read_sock);
    1693                 :            : 
    1694                 :          0 : int tcp_peek_len(struct socket *sock)
    1695                 :            : {
    1696                 :          0 :         return tcp_inq(sock->sk);
    1697                 :            : }
    1698                 :            : EXPORT_SYMBOL(tcp_peek_len);
    1699                 :            : 
    1700                 :            : /* Make sure sk_rcvbuf is big enough to satisfy SO_RCVLOWAT hint */
    1701                 :          0 : int tcp_set_rcvlowat(struct sock *sk, int val)
    1702                 :            : {
    1703                 :            :         int cap;
    1704                 :            : 
    1705                 :          0 :         if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
    1706                 :          0 :                 cap = sk->sk_rcvbuf >> 1;
    1707                 :            :         else
    1708                 :          0 :                 cap = sock_net(sk)->ipv4.sysctl_tcp_rmem[2] >> 1;
    1709                 :          0 :         val = min(val, cap);
    1710                 :          0 :         WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
    1711                 :            : 
    1712                 :            :         /* Check if we need to signal EPOLLIN right now */
    1713                 :          0 :         tcp_data_ready(sk);
    1714                 :            : 
    1715                 :          0 :         if (sk->sk_userlocks & SOCK_RCVBUF_LOCK)
    1716                 :            :                 return 0;
    1717                 :            : 
    1718                 :          0 :         val <<= 1;
    1719                 :          0 :         if (val > sk->sk_rcvbuf) {
    1720                 :            :                 WRITE_ONCE(sk->sk_rcvbuf, val);
    1721                 :          0 :                 tcp_sk(sk)->window_clamp = tcp_win_from_space(sk, val);
    1722                 :            :         }
    1723                 :            :         return 0;
    1724                 :            : }
    1725                 :            : EXPORT_SYMBOL(tcp_set_rcvlowat);
    1726                 :            : 
    1727                 :            : #ifdef CONFIG_MMU
    1728                 :            : static const struct vm_operations_struct tcp_vm_ops = {
    1729                 :            : };
    1730                 :            : 
    1731                 :          0 : int tcp_mmap(struct file *file, struct socket *sock,
    1732                 :            :              struct vm_area_struct *vma)
    1733                 :            : {
    1734                 :          0 :         if (vma->vm_flags & (VM_WRITE | VM_EXEC))
    1735                 :            :                 return -EPERM;
    1736                 :          0 :         vma->vm_flags &= ~(VM_MAYWRITE | VM_MAYEXEC);
    1737                 :            : 
    1738                 :            :         /* Instruct vm_insert_page() to not down_read(mmap_sem) */
    1739                 :          0 :         vma->vm_flags |= VM_MIXEDMAP;
    1740                 :            : 
    1741                 :          0 :         vma->vm_ops = &tcp_vm_ops;
    1742                 :          0 :         return 0;
    1743                 :            : }
    1744                 :            : EXPORT_SYMBOL(tcp_mmap);
    1745                 :            : 
    1746                 :          0 : static int tcp_zerocopy_receive(struct sock *sk,
    1747                 :            :                                 struct tcp_zerocopy_receive *zc)
    1748                 :            : {
    1749                 :          0 :         unsigned long address = (unsigned long)zc->address;
    1750                 :            :         const skb_frag_t *frags = NULL;
    1751                 :            :         u32 length = 0, seq, offset;
    1752                 :            :         struct vm_area_struct *vma;
    1753                 :            :         struct sk_buff *skb = NULL;
    1754                 :            :         struct tcp_sock *tp;
    1755                 :            :         int inq;
    1756                 :            :         int ret;
    1757                 :            : 
    1758                 :          0 :         if (address & (PAGE_SIZE - 1) || address != zc->address)
    1759                 :            :                 return -EINVAL;
    1760                 :            : 
    1761                 :          0 :         if (sk->sk_state == TCP_LISTEN)
    1762                 :            :                 return -ENOTCONN;
    1763                 :            : 
    1764                 :          0 :         sock_rps_record_flow(sk);
    1765                 :            : 
    1766                 :          0 :         down_read(&current->mm->mmap_sem);
    1767                 :            : 
    1768                 :          0 :         vma = find_vma(current->mm, address);
    1769                 :          0 :         if (!vma || vma->vm_start > address || vma->vm_ops != &tcp_vm_ops) {
    1770                 :          0 :                 up_read(&current->mm->mmap_sem);
    1771                 :          0 :                 return -EINVAL;
    1772                 :            :         }
    1773                 :          0 :         zc->length = min_t(unsigned long, zc->length, vma->vm_end - address);
    1774                 :            : 
    1775                 :            :         tp = tcp_sk(sk);
    1776                 :          0 :         seq = tp->copied_seq;
    1777                 :          0 :         inq = tcp_inq(sk);
    1778                 :          0 :         zc->length = min_t(u32, zc->length, inq);
    1779                 :          0 :         zc->length &= ~(PAGE_SIZE - 1);
    1780                 :          0 :         if (zc->length) {
    1781                 :          0 :                 zap_page_range(vma, address, zc->length);
    1782                 :          0 :                 zc->recv_skip_hint = 0;
    1783                 :            :         } else {
    1784                 :          0 :                 zc->recv_skip_hint = inq;
    1785                 :            :         }
    1786                 :            :         ret = 0;
    1787                 :          0 :         while (length + PAGE_SIZE <= zc->length) {
    1788                 :          0 :                 if (zc->recv_skip_hint < PAGE_SIZE) {
    1789                 :          0 :                         if (skb) {
    1790                 :          0 :                                 skb = skb->next;
    1791                 :          0 :                                 offset = seq - TCP_SKB_CB(skb)->seq;
    1792                 :            :                         } else {
    1793                 :          0 :                                 skb = tcp_recv_skb(sk, seq, &offset);
    1794                 :            :                         }
    1795                 :            : 
    1796                 :          0 :                         zc->recv_skip_hint = skb->len - offset;
    1797                 :          0 :                         offset -= skb_headlen(skb);
    1798                 :          0 :                         if ((int)offset < 0 || skb_has_frag_list(skb))
    1799                 :            :                                 break;
    1800                 :          0 :                         frags = skb_shinfo(skb)->frags;
    1801                 :          0 :                         while (offset) {
    1802                 :          0 :                                 if (skb_frag_size(frags) > offset)
    1803                 :            :                                         goto out;
    1804                 :          0 :                                 offset -= skb_frag_size(frags);
    1805                 :          0 :                                 frags++;
    1806                 :            :                         }
    1807                 :            :                 }
    1808                 :          0 :                 if (skb_frag_size(frags) != PAGE_SIZE || skb_frag_off(frags)) {
    1809                 :          0 :                         int remaining = zc->recv_skip_hint;
    1810                 :            : 
    1811                 :          0 :                         while (remaining && (skb_frag_size(frags) != PAGE_SIZE ||
    1812                 :            :                                              skb_frag_off(frags))) {
    1813                 :          0 :                                 remaining -= skb_frag_size(frags);
    1814                 :          0 :                                 frags++;
    1815                 :            :                         }
    1816                 :          0 :                         zc->recv_skip_hint -= remaining;
    1817                 :          0 :                         break;
    1818                 :            :                 }
    1819                 :          0 :                 ret = vm_insert_page(vma, address + length,
    1820                 :            :                                      skb_frag_page(frags));
    1821                 :          0 :                 if (ret)
    1822                 :            :                         break;
    1823                 :            :                 length += PAGE_SIZE;
    1824                 :          0 :                 seq += PAGE_SIZE;
    1825                 :          0 :                 zc->recv_skip_hint -= PAGE_SIZE;
    1826                 :          0 :                 frags++;
    1827                 :            :         }
    1828                 :            : out:
    1829                 :          0 :         up_read(&current->mm->mmap_sem);
    1830                 :          0 :         if (length) {
    1831                 :          0 :                 WRITE_ONCE(tp->copied_seq, seq);
    1832                 :          0 :                 tcp_rcv_space_adjust(sk);
    1833                 :            : 
    1834                 :            :                 /* Clean up data we have read: This will do ACK frames. */
    1835                 :          0 :                 tcp_recv_skb(sk, seq, &offset);
    1836                 :          0 :                 tcp_cleanup_rbuf(sk, length);
    1837                 :            :                 ret = 0;
    1838                 :          0 :                 if (length == zc->length)
    1839                 :          0 :                         zc->recv_skip_hint = 0;
    1840                 :            :         } else {
    1841                 :          0 :                 if (!zc->recv_skip_hint && sock_flag(sk, SOCK_DONE))
    1842                 :            :                         ret = -EIO;
    1843                 :            :         }
    1844                 :          0 :         zc->length = length;
    1845                 :          0 :         return ret;
    1846                 :            : }
    1847                 :            : #endif
    1848                 :            : 
    1849                 :          0 : static void tcp_update_recv_tstamps(struct sk_buff *skb,
    1850                 :            :                                     struct scm_timestamping_internal *tss)
    1851                 :            : {
    1852                 :          0 :         if (skb->tstamp)
    1853                 :          0 :                 tss->ts[0] = ktime_to_timespec64(skb->tstamp);
    1854                 :            :         else
    1855                 :          0 :                 tss->ts[0] = (struct timespec64) {0};
    1856                 :            : 
    1857                 :          0 :         if (skb_hwtstamps(skb)->hwtstamp)
    1858                 :          0 :                 tss->ts[2] = ktime_to_timespec64(skb_hwtstamps(skb)->hwtstamp);
    1859                 :            :         else
    1860                 :          0 :                 tss->ts[2] = (struct timespec64) {0};
    1861                 :          0 : }
    1862                 :            : 
    1863                 :            : /* Similar to __sock_recv_timestamp, but does not require an skb */
    1864                 :          0 : static void tcp_recv_timestamp(struct msghdr *msg, const struct sock *sk,
    1865                 :            :                                struct scm_timestamping_internal *tss)
    1866                 :            : {
    1867                 :          0 :         int new_tstamp = sock_flag(sk, SOCK_TSTAMP_NEW);
    1868                 :            :         bool has_timestamping = false;
    1869                 :            : 
    1870                 :          0 :         if (tss->ts[0].tv_sec || tss->ts[0].tv_nsec) {
    1871                 :          0 :                 if (sock_flag(sk, SOCK_RCVTSTAMP)) {
    1872                 :          0 :                         if (sock_flag(sk, SOCK_RCVTSTAMPNS)) {
    1873                 :          0 :                                 if (new_tstamp) {
    1874                 :          0 :                                         struct __kernel_timespec kts = {tss->ts[0].tv_sec, tss->ts[0].tv_nsec};
    1875                 :            : 
    1876                 :          0 :                                         put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_NEW,
    1877                 :            :                                                  sizeof(kts), &kts);
    1878                 :            :                                 } else {
    1879                 :            :                                         struct timespec ts_old = timespec64_to_timespec(tss->ts[0]);
    1880                 :            : 
    1881                 :          0 :                                         put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMPNS_OLD,
    1882                 :            :                                                  sizeof(ts_old), &ts_old);
    1883                 :            :                                 }
    1884                 :            :                         } else {
    1885                 :          0 :                                 if (new_tstamp) {
    1886                 :            :                                         struct __kernel_sock_timeval stv;
    1887                 :            : 
    1888                 :          0 :                                         stv.tv_sec = tss->ts[0].tv_sec;
    1889                 :          0 :                                         stv.tv_usec = tss->ts[0].tv_nsec / 1000;
    1890                 :          0 :                                         put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_NEW,
    1891                 :            :                                                  sizeof(stv), &stv);
    1892                 :            :                                 } else {
    1893                 :            :                                         struct __kernel_old_timeval tv;
    1894                 :            : 
    1895                 :          0 :                                         tv.tv_sec = tss->ts[0].tv_sec;
    1896                 :          0 :                                         tv.tv_usec = tss->ts[0].tv_nsec / 1000;
    1897                 :          0 :                                         put_cmsg(msg, SOL_SOCKET, SO_TIMESTAMP_OLD,
    1898                 :            :                                                  sizeof(tv), &tv);
    1899                 :            :                                 }
    1900                 :            :                         }
    1901                 :            :                 }
    1902                 :            : 
    1903                 :          0 :                 if (sk->sk_tsflags & SOF_TIMESTAMPING_SOFTWARE)
    1904                 :            :                         has_timestamping = true;
    1905                 :            :                 else
    1906                 :          0 :                         tss->ts[0] = (struct timespec64) {0};
    1907                 :            :         }
    1908                 :            : 
    1909                 :          0 :         if (tss->ts[2].tv_sec || tss->ts[2].tv_nsec) {
    1910                 :          0 :                 if (sk->sk_tsflags & SOF_TIMESTAMPING_RAW_HARDWARE)
    1911                 :            :                         has_timestamping = true;
    1912                 :            :                 else
    1913                 :          0 :                         tss->ts[2] = (struct timespec64) {0};
    1914                 :            :         }
    1915                 :            : 
    1916                 :          0 :         if (has_timestamping) {
    1917                 :          0 :                 tss->ts[1] = (struct timespec64) {0};
    1918                 :          0 :                 if (sock_flag(sk, SOCK_TSTAMP_NEW))
    1919                 :          0 :                         put_cmsg_scm_timestamping64(msg, tss);
    1920                 :            :                 else
    1921                 :          0 :                         put_cmsg_scm_timestamping(msg, tss);
    1922                 :            :         }
    1923                 :          0 : }
    1924                 :            : 
    1925                 :          0 : static int tcp_inq_hint(struct sock *sk)
    1926                 :            : {
    1927                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
    1928                 :            :         u32 copied_seq = READ_ONCE(tp->copied_seq);
    1929                 :            :         u32 rcv_nxt = READ_ONCE(tp->rcv_nxt);
    1930                 :            :         int inq;
    1931                 :            : 
    1932                 :          0 :         inq = rcv_nxt - copied_seq;
    1933                 :          0 :         if (unlikely(inq < 0 || copied_seq != READ_ONCE(tp->copied_seq))) {
    1934                 :            :                 lock_sock(sk);
    1935                 :          0 :                 inq = tp->rcv_nxt - tp->copied_seq;
    1936                 :          0 :                 release_sock(sk);
    1937                 :            :         }
    1938                 :            :         /* After receiving a FIN, tell the user-space to continue reading
    1939                 :            :          * by returning a non-zero inq.
    1940                 :            :          */
    1941                 :          0 :         if (inq == 0 && sock_flag(sk, SOCK_DONE))
    1942                 :            :                 inq = 1;
    1943                 :          0 :         return inq;
    1944                 :            : }
    1945                 :            : 
    1946                 :            : /*
    1947                 :            :  *      This routine copies from a sock struct into the user buffer.
    1948                 :            :  *
    1949                 :            :  *      Technical note: in 2.3 we work on _locked_ socket, so that
    1950                 :            :  *      tricks with *seq access order and skb->users are not required.
    1951                 :            :  *      Probably, code can be easily improved even more.
    1952                 :            :  */
    1953                 :            : 
    1954                 :          1 : int tcp_recvmsg(struct sock *sk, struct msghdr *msg, size_t len, int nonblock,
    1955                 :            :                 int flags, int *addr_len)
    1956                 :            : {
    1957                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    1958                 :            :         int copied = 0;
    1959                 :            :         u32 peek_seq;
    1960                 :            :         u32 *seq;
    1961                 :            :         unsigned long used;
    1962                 :            :         int err, inq;
    1963                 :            :         int target;             /* Read at least this many bytes */
    1964                 :            :         long timeo;
    1965                 :            :         struct sk_buff *skb, *last;
    1966                 :            :         u32 urg_hole = 0;
    1967                 :            :         struct scm_timestamping_internal tss;
    1968                 :            :         int cmsg_flags;
    1969                 :            : 
    1970                 :          1 :         if (unlikely(flags & MSG_ERRQUEUE))
    1971                 :          0 :                 return inet_recv_error(sk, msg, len, addr_len);
    1972                 :            : 
    1973                 :          1 :         if (sk_can_busy_loop(sk) && skb_queue_empty_lockless(&sk->sk_receive_queue) &&
    1974                 :          0 :             (sk->sk_state == TCP_ESTABLISHED))
    1975                 :          0 :                 sk_busy_loop(sk, nonblock);
    1976                 :            : 
    1977                 :            :         lock_sock(sk);
    1978                 :            : 
    1979                 :            :         err = -ENOTCONN;
    1980                 :          1 :         if (sk->sk_state == TCP_LISTEN)
    1981                 :            :                 goto out;
    1982                 :            : 
    1983                 :          1 :         cmsg_flags = tp->recvmsg_inq ? 1 : 0;
    1984                 :          1 :         timeo = sock_rcvtimeo(sk, nonblock);
    1985                 :            : 
    1986                 :            :         /* Urgent data needs to be handled specially. */
    1987                 :          1 :         if (flags & MSG_OOB)
    1988                 :            :                 goto recv_urg;
    1989                 :            : 
    1990                 :          1 :         if (unlikely(tp->repair)) {
    1991                 :            :                 err = -EPERM;
    1992                 :          0 :                 if (!(flags & MSG_PEEK))
    1993                 :            :                         goto out;
    1994                 :            : 
    1995                 :          0 :                 if (tp->repair_queue == TCP_SEND_QUEUE)
    1996                 :            :                         goto recv_sndq;
    1997                 :            : 
    1998                 :            :                 err = -EINVAL;
    1999                 :          0 :                 if (tp->repair_queue == TCP_NO_QUEUE)
    2000                 :            :                         goto out;
    2001                 :            : 
    2002                 :            :                 /* 'common' recv queue MSG_PEEK-ing */
    2003                 :            :         }
    2004                 :            : 
    2005                 :          1 :         seq = &tp->copied_seq;
    2006                 :          1 :         if (flags & MSG_PEEK) {
    2007                 :          1 :                 peek_seq = tp->copied_seq;
    2008                 :            :                 seq = &peek_seq;
    2009                 :            :         }
    2010                 :            : 
    2011                 :          1 :         target = sock_rcvlowat(sk, flags & MSG_WAITALL, len);
    2012                 :            : 
    2013                 :            :         do {
    2014                 :            :                 u32 offset;
    2015                 :            : 
    2016                 :            :                 /* Are we at urgent data? Stop if we have read anything or have SIGURG pending. */
    2017                 :          1 :                 if (tp->urg_data && tp->urg_seq == *seq) {
    2018                 :          0 :                         if (copied)
    2019                 :            :                                 break;
    2020                 :          0 :                         if (signal_pending(current)) {
    2021                 :          0 :                                 copied = timeo ? sock_intr_errno(timeo) : -EAGAIN;
    2022                 :          0 :                                 break;
    2023                 :            :                         }
    2024                 :            :                 }
    2025                 :            : 
    2026                 :            :                 /* Next get a buffer. */
    2027                 :            : 
    2028                 :          1 :                 last = skb_peek_tail(&sk->sk_receive_queue);
    2029                 :          1 :                 skb_queue_walk(&sk->sk_receive_queue, skb) {
    2030                 :            :                         last = skb;
    2031                 :            :                         /* Now that we have two receive queues this
    2032                 :            :                          * shouldn't happen.
    2033                 :            :                          */
    2034                 :          1 :                         if (WARN(before(*seq, TCP_SKB_CB(skb)->seq),
    2035                 :            :                                  "TCP recvmsg seq # bug: copied %X, seq %X, rcvnxt %X, fl %X\n",
    2036                 :            :                                  *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt,
    2037                 :            :                                  flags))
    2038                 :            :                                 break;
    2039                 :            : 
    2040                 :          1 :                         offset = *seq - TCP_SKB_CB(skb)->seq;
    2041                 :          1 :                         if (unlikely(TCP_SKB_CB(skb)->tcp_flags & TCPHDR_SYN)) {
    2042                 :          0 :                                 pr_err_once("%s: found a SYN, please report !\n", __func__);
    2043                 :          0 :                                 offset--;
    2044                 :            :                         }
    2045                 :          1 :                         if (offset < skb->len)
    2046                 :            :                                 goto found_ok_skb;
    2047                 :          0 :                         if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
    2048                 :            :                                 goto found_fin_ok;
    2049                 :          0 :                         WARN(!(flags & MSG_PEEK),
    2050                 :            :                              "TCP recvmsg seq # bug 2: copied %X, seq %X, rcvnxt %X, fl %X\n",
    2051                 :            :                              *seq, TCP_SKB_CB(skb)->seq, tp->rcv_nxt, flags);
    2052                 :            :                 }
    2053                 :            : 
    2054                 :            :                 /* Well, if we have backlog, try to process it now yet. */
    2055                 :            : 
    2056                 :          1 :                 if (copied >= target && !sk->sk_backlog.tail)
    2057                 :            :                         break;
    2058                 :            : 
    2059                 :          1 :                 if (copied) {
    2060                 :          1 :                         if (sk->sk_err ||
    2061                 :          1 :                             sk->sk_state == TCP_CLOSE ||
    2062                 :          1 :                             (sk->sk_shutdown & RCV_SHUTDOWN) ||
    2063                 :          1 :                             !timeo ||
    2064                 :          0 :                             signal_pending(current))
    2065                 :            :                                 break;
    2066                 :            :                 } else {
    2067                 :          1 :                         if (sock_flag(sk, SOCK_DONE))
    2068                 :            :                                 break;
    2069                 :            : 
    2070                 :          1 :                         if (sk->sk_err) {
    2071                 :          0 :                                 copied = sock_error(sk);
    2072                 :          0 :                                 break;
    2073                 :            :                         }
    2074                 :            : 
    2075                 :          1 :                         if (sk->sk_shutdown & RCV_SHUTDOWN)
    2076                 :            :                                 break;
    2077                 :            : 
    2078                 :          1 :                         if (sk->sk_state == TCP_CLOSE) {
    2079                 :            :                                 /* This occurs when user tries to read
    2080                 :            :                                  * from never connected socket.
    2081                 :            :                                  */
    2082                 :            :                                 copied = -ENOTCONN;
    2083                 :            :                                 break;
    2084                 :            :                         }
    2085                 :            : 
    2086                 :          1 :                         if (!timeo) {
    2087                 :            :                                 copied = -EAGAIN;
    2088                 :            :                                 break;
    2089                 :            :                         }
    2090                 :            : 
    2091                 :          0 :                         if (signal_pending(current)) {
    2092                 :          0 :                                 copied = sock_intr_errno(timeo);
    2093                 :          0 :                                 break;
    2094                 :            :                         }
    2095                 :            :                 }
    2096                 :            : 
    2097                 :          0 :                 tcp_cleanup_rbuf(sk, copied);
    2098                 :            : 
    2099                 :          0 :                 if (copied >= target) {
    2100                 :            :                         /* Do not sleep, just process backlog. */
    2101                 :          0 :                         release_sock(sk);
    2102                 :            :                         lock_sock(sk);
    2103                 :            :                 } else {
    2104                 :          0 :                         sk_wait_data(sk, &timeo, last);
    2105                 :            :                 }
    2106                 :            : 
    2107                 :          0 :                 if ((flags & MSG_PEEK) &&
    2108                 :          0 :                     (peek_seq - copied - urg_hole != tp->copied_seq)) {
    2109                 :            :                         net_dbg_ratelimited("TCP(%s:%d): Application bug, race in MSG_PEEK\n",
    2110                 :            :                                             current->comm,
    2111                 :            :                                             task_pid_nr(current));
    2112                 :          0 :                         peek_seq = tp->copied_seq;
    2113                 :            :                 }
    2114                 :          0 :                 continue;
    2115                 :            : 
    2116                 :            : found_ok_skb:
    2117                 :            :                 /* Ok so how much can we use? */
    2118                 :          1 :                 used = skb->len - offset;
    2119                 :          1 :                 if (len < used)
    2120                 :            :                         used = len;
    2121                 :            : 
    2122                 :            :                 /* Do we have urgent data here? */
    2123                 :          1 :                 if (tp->urg_data) {
    2124                 :          0 :                         u32 urg_offset = tp->urg_seq - *seq;
    2125                 :          0 :                         if (urg_offset < used) {
    2126                 :          0 :                                 if (!urg_offset) {
    2127                 :          0 :                                         if (!sock_flag(sk, SOCK_URGINLINE)) {
    2128                 :          0 :                                                 WRITE_ONCE(*seq, *seq + 1);
    2129                 :          0 :                                                 urg_hole++;
    2130                 :          0 :                                                 offset++;
    2131                 :          0 :                                                 used--;
    2132                 :          0 :                                                 if (!used)
    2133                 :            :                                                         goto skip_copy;
    2134                 :            :                                         }
    2135                 :            :                                 } else
    2136                 :            :                                         used = urg_offset;
    2137                 :            :                         }
    2138                 :            :                 }
    2139                 :            : 
    2140                 :          1 :                 if (!(flags & MSG_TRUNC)) {
    2141                 :          1 :                         err = skb_copy_datagram_msg(skb, offset, msg, used);
    2142                 :          1 :                         if (err) {
    2143                 :            :                                 /* Exception. Bailout! */
    2144                 :          0 :                                 if (!copied)
    2145                 :            :                                         copied = -EFAULT;
    2146                 :            :                                 break;
    2147                 :            :                         }
    2148                 :            :                 }
    2149                 :            : 
    2150                 :          1 :                 WRITE_ONCE(*seq, *seq + used);
    2151                 :          1 :                 copied += used;
    2152                 :          1 :                 len -= used;
    2153                 :            : 
    2154                 :          1 :                 tcp_rcv_space_adjust(sk);
    2155                 :            : 
    2156                 :            : skip_copy:
    2157                 :          1 :                 if (tp->urg_data && after(tp->copied_seq, tp->urg_seq)) {
    2158                 :          0 :                         tp->urg_data = 0;
    2159                 :          0 :                         tcp_fast_path_check(sk);
    2160                 :            :                 }
    2161                 :            : 
    2162                 :          1 :                 if (TCP_SKB_CB(skb)->has_rxtstamp) {
    2163                 :          0 :                         tcp_update_recv_tstamps(skb, &tss);
    2164                 :          0 :                         cmsg_flags |= 2;
    2165                 :            :                 }
    2166                 :            : 
    2167                 :          1 :                 if (used + offset < skb->len)
    2168                 :          1 :                         continue;
    2169                 :            : 
    2170                 :          1 :                 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
    2171                 :            :                         goto found_fin_ok;
    2172                 :          1 :                 if (!(flags & MSG_PEEK))
    2173                 :          1 :                         sk_eat_skb(sk, skb);
    2174                 :          1 :                 continue;
    2175                 :            : 
    2176                 :            : found_fin_ok:
    2177                 :            :                 /* Process the FIN. */
    2178                 :          1 :                 WRITE_ONCE(*seq, *seq + 1);
    2179                 :          1 :                 if (!(flags & MSG_PEEK))
    2180                 :          1 :                         sk_eat_skb(sk, skb);
    2181                 :            :                 break;
    2182                 :          1 :         } while (len > 0);
    2183                 :            : 
    2184                 :            :         /* According to UNIX98, msg_name/msg_namelen are ignored
    2185                 :            :          * on connected socket. I was just happy when found this 8) --ANK
    2186                 :            :          */
    2187                 :            : 
    2188                 :            :         /* Clean up data we have read: This will do ACK frames. */
    2189                 :          1 :         tcp_cleanup_rbuf(sk, copied);
    2190                 :            : 
    2191                 :          1 :         release_sock(sk);
    2192                 :            : 
    2193                 :          1 :         if (cmsg_flags) {
    2194                 :          0 :                 if (cmsg_flags & 2)
    2195                 :          0 :                         tcp_recv_timestamp(msg, sk, &tss);
    2196                 :          0 :                 if (cmsg_flags & 1) {
    2197                 :          0 :                         inq = tcp_inq_hint(sk);
    2198                 :          0 :                         put_cmsg(msg, SOL_TCP, TCP_CM_INQ, sizeof(inq), &inq);
    2199                 :            :                 }
    2200                 :            :         }
    2201                 :            : 
    2202                 :          1 :         return copied;
    2203                 :            : 
    2204                 :            : out:
    2205                 :          0 :         release_sock(sk);
    2206                 :          0 :         return err;
    2207                 :            : 
    2208                 :            : recv_urg:
    2209                 :          0 :         err = tcp_recv_urg(sk, msg, len, flags);
    2210                 :          0 :         goto out;
    2211                 :            : 
    2212                 :            : recv_sndq:
    2213                 :          0 :         err = tcp_peek_sndq(sk, msg, len);
    2214                 :          0 :         goto out;
    2215                 :            : }
    2216                 :            : EXPORT_SYMBOL(tcp_recvmsg);
    2217                 :            : 
    2218                 :          1 : void tcp_set_state(struct sock *sk, int state)
    2219                 :            : {
    2220                 :          1 :         int oldstate = sk->sk_state;
    2221                 :            : 
    2222                 :            :         /* We defined a new enum for TCP states that are exported in BPF
    2223                 :            :          * so as not force the internal TCP states to be frozen. The
    2224                 :            :          * following checks will detect if an internal state value ever
    2225                 :            :          * differs from the BPF value. If this ever happens, then we will
    2226                 :            :          * need to remap the internal value to the BPF value before calling
    2227                 :            :          * tcp_call_bpf_2arg.
    2228                 :            :          */
    2229                 :            :         BUILD_BUG_ON((int)BPF_TCP_ESTABLISHED != (int)TCP_ESTABLISHED);
    2230                 :            :         BUILD_BUG_ON((int)BPF_TCP_SYN_SENT != (int)TCP_SYN_SENT);
    2231                 :            :         BUILD_BUG_ON((int)BPF_TCP_SYN_RECV != (int)TCP_SYN_RECV);
    2232                 :            :         BUILD_BUG_ON((int)BPF_TCP_FIN_WAIT1 != (int)TCP_FIN_WAIT1);
    2233                 :            :         BUILD_BUG_ON((int)BPF_TCP_FIN_WAIT2 != (int)TCP_FIN_WAIT2);
    2234                 :            :         BUILD_BUG_ON((int)BPF_TCP_TIME_WAIT != (int)TCP_TIME_WAIT);
    2235                 :            :         BUILD_BUG_ON((int)BPF_TCP_CLOSE != (int)TCP_CLOSE);
    2236                 :            :         BUILD_BUG_ON((int)BPF_TCP_CLOSE_WAIT != (int)TCP_CLOSE_WAIT);
    2237                 :            :         BUILD_BUG_ON((int)BPF_TCP_LAST_ACK != (int)TCP_LAST_ACK);
    2238                 :            :         BUILD_BUG_ON((int)BPF_TCP_LISTEN != (int)TCP_LISTEN);
    2239                 :            :         BUILD_BUG_ON((int)BPF_TCP_CLOSING != (int)TCP_CLOSING);
    2240                 :            :         BUILD_BUG_ON((int)BPF_TCP_NEW_SYN_RECV != (int)TCP_NEW_SYN_RECV);
    2241                 :            :         BUILD_BUG_ON((int)BPF_TCP_MAX_STATES != (int)TCP_MAX_STATES);
    2242                 :            : 
    2243                 :          1 :         if (BPF_SOCK_OPS_TEST_FLAG(tcp_sk(sk), BPF_SOCK_OPS_STATE_CB_FLAG))
    2244                 :          0 :                 tcp_call_bpf_2arg(sk, BPF_SOCK_OPS_STATE_CB, oldstate, state);
    2245                 :            : 
    2246                 :          1 :         switch (state) {
    2247                 :            :         case TCP_ESTABLISHED:
    2248                 :          1 :                 if (oldstate != TCP_ESTABLISHED)
    2249                 :          1 :                         TCP_INC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
    2250                 :            :                 break;
    2251                 :            : 
    2252                 :            :         case TCP_CLOSE:
    2253                 :          1 :                 if (oldstate == TCP_CLOSE_WAIT || oldstate == TCP_ESTABLISHED)
    2254                 :          1 :                         TCP_INC_STATS(sock_net(sk), TCP_MIB_ESTABRESETS);
    2255                 :            : 
    2256                 :          1 :                 sk->sk_prot->unhash(sk);
    2257                 :          1 :                 if (inet_csk(sk)->icsk_bind_hash &&
    2258                 :          1 :                     !(sk->sk_userlocks & SOCK_BINDPORT_LOCK))
    2259                 :          1 :                         inet_put_port(sk);
    2260                 :            :                 /* fall through */
    2261                 :            :         default:
    2262                 :          1 :                 if (oldstate == TCP_ESTABLISHED)
    2263                 :          1 :                         TCP_DEC_STATS(sock_net(sk), TCP_MIB_CURRESTAB);
    2264                 :            :         }
    2265                 :            : 
    2266                 :            :         /* Change state AFTER socket is unhashed to avoid closed
    2267                 :            :          * socket sitting in hash tables.
    2268                 :            :          */
    2269                 :          1 :         inet_sk_state_store(sk, state);
    2270                 :          1 : }
    2271                 :            : EXPORT_SYMBOL_GPL(tcp_set_state);
    2272                 :            : 
    2273                 :            : /*
    2274                 :            :  *      State processing on a close. This implements the state shift for
    2275                 :            :  *      sending our FIN frame. Note that we only send a FIN for some
    2276                 :            :  *      states. A shutdown() may have already sent the FIN, or we may be
    2277                 :            :  *      closed.
    2278                 :            :  */
    2279                 :            : 
    2280                 :            : static const unsigned char new_state[16] = {
    2281                 :            :   /* current state:        new state:      action:      */
    2282                 :            :   [0 /* (Invalid) */]   = TCP_CLOSE,
    2283                 :            :   [TCP_ESTABLISHED]     = TCP_FIN_WAIT1 | TCP_ACTION_FIN,
    2284                 :            :   [TCP_SYN_SENT]        = TCP_CLOSE,
    2285                 :            :   [TCP_SYN_RECV]        = TCP_FIN_WAIT1 | TCP_ACTION_FIN,
    2286                 :            :   [TCP_FIN_WAIT1]       = TCP_FIN_WAIT1,
    2287                 :            :   [TCP_FIN_WAIT2]       = TCP_FIN_WAIT2,
    2288                 :            :   [TCP_TIME_WAIT]       = TCP_CLOSE,
    2289                 :            :   [TCP_CLOSE]           = TCP_CLOSE,
    2290                 :            :   [TCP_CLOSE_WAIT]      = TCP_LAST_ACK  | TCP_ACTION_FIN,
    2291                 :            :   [TCP_LAST_ACK]        = TCP_LAST_ACK,
    2292                 :            :   [TCP_LISTEN]          = TCP_CLOSE,
    2293                 :            :   [TCP_CLOSING]         = TCP_CLOSING,
    2294                 :            :   [TCP_NEW_SYN_RECV]    = TCP_CLOSE,    /* should not happen ! */
    2295                 :            : };
    2296                 :            : 
    2297                 :            : static int tcp_close_state(struct sock *sk)
    2298                 :            : {
    2299                 :          1 :         int next = (int)new_state[sk->sk_state];
    2300                 :          1 :         int ns = next & TCP_STATE_MASK;
    2301                 :            : 
    2302                 :          1 :         tcp_set_state(sk, ns);
    2303                 :            : 
    2304                 :          1 :         return next & TCP_ACTION_FIN;
    2305                 :            : }
    2306                 :            : 
    2307                 :            : /*
    2308                 :            :  *      Shutdown the sending side of a connection. Much like close except
    2309                 :            :  *      that we don't receive shut down or sock_set_flag(sk, SOCK_DEAD).
    2310                 :            :  */
    2311                 :            : 
    2312                 :          0 : void tcp_shutdown(struct sock *sk, int how)
    2313                 :            : {
    2314                 :            :         /*      We need to grab some memory, and put together a FIN,
    2315                 :            :          *      and then put it into the queue to be sent.
    2316                 :            :          *              Tim MacKenzie(tym@dibbler.cs.monash.edu.au) 4 Dec '92.
    2317                 :            :          */
    2318                 :          0 :         if (!(how & SEND_SHUTDOWN))
    2319                 :          0 :                 return;
    2320                 :            : 
    2321                 :            :         /* If we've already sent a FIN, or it's a closed state, skip this. */
    2322                 :          0 :         if ((1 << sk->sk_state) &
    2323                 :            :             (TCPF_ESTABLISHED | TCPF_SYN_SENT |
    2324                 :            :              TCPF_SYN_RECV | TCPF_CLOSE_WAIT)) {
    2325                 :            :                 /* Clear out any half completed packets.  FIN if needed. */
    2326                 :          0 :                 if (tcp_close_state(sk))
    2327                 :          0 :                         tcp_send_fin(sk);
    2328                 :            :         }
    2329                 :            : }
    2330                 :            : EXPORT_SYMBOL(tcp_shutdown);
    2331                 :            : 
    2332                 :          1 : bool tcp_check_oom(struct sock *sk, int shift)
    2333                 :            : {
    2334                 :            :         bool too_many_orphans, out_of_socket_memory;
    2335                 :            : 
    2336                 :          1 :         too_many_orphans = tcp_too_many_orphans(sk, shift);
    2337                 :            :         out_of_socket_memory = tcp_out_of_memory(sk);
    2338                 :            : 
    2339                 :          1 :         if (too_many_orphans)
    2340                 :          0 :                 net_info_ratelimited("too many orphaned sockets\n");
    2341                 :          1 :         if (out_of_socket_memory)
    2342                 :          0 :                 net_info_ratelimited("out of memory -- consider tuning tcp_mem\n");
    2343                 :          1 :         return too_many_orphans || out_of_socket_memory;
    2344                 :            : }
    2345                 :            : 
    2346                 :          1 : void tcp_close(struct sock *sk, long timeout)
    2347                 :            : {
    2348                 :            :         struct sk_buff *skb;
    2349                 :            :         int data_was_unread = 0;
    2350                 :            :         int state;
    2351                 :            : 
    2352                 :            :         lock_sock(sk);
    2353                 :          1 :         sk->sk_shutdown = SHUTDOWN_MASK;
    2354                 :            : 
    2355                 :          1 :         if (sk->sk_state == TCP_LISTEN) {
    2356                 :          0 :                 tcp_set_state(sk, TCP_CLOSE);
    2357                 :            : 
    2358                 :            :                 /* Special case. */
    2359                 :          0 :                 inet_csk_listen_stop(sk);
    2360                 :            : 
    2361                 :          0 :                 goto adjudge_to_death;
    2362                 :            :         }
    2363                 :            : 
    2364                 :            :         /*  We need to flush the recv. buffs.  We do this only on the
    2365                 :            :          *  descriptor close, not protocol-sourced closes, because the
    2366                 :            :          *  reader process may not have drained the data yet!
    2367                 :            :          */
    2368                 :          1 :         while ((skb = __skb_dequeue(&sk->sk_receive_queue)) != NULL) {
    2369                 :          1 :                 u32 len = TCP_SKB_CB(skb)->end_seq - TCP_SKB_CB(skb)->seq;
    2370                 :            : 
    2371                 :          1 :                 if (TCP_SKB_CB(skb)->tcp_flags & TCPHDR_FIN)
    2372                 :          0 :                         len--;
    2373                 :          1 :                 data_was_unread += len;
    2374                 :          1 :                 __kfree_skb(skb);
    2375                 :            :         }
    2376                 :            : 
    2377                 :          1 :         sk_mem_reclaim(sk);
    2378                 :            : 
    2379                 :            :         /* If socket has been already reset (e.g. in tcp_reset()) - kill it. */
    2380                 :          1 :         if (sk->sk_state == TCP_CLOSE)
    2381                 :            :                 goto adjudge_to_death;
    2382                 :            : 
    2383                 :            :         /* As outlined in RFC 2525, section 2.17, we send a RST here because
    2384                 :            :          * data was lost. To witness the awful effects of the old behavior of
    2385                 :            :          * always doing a FIN, run an older 2.1.x kernel or 2.0.x, start a bulk
    2386                 :            :          * GET in an FTP client, suspend the process, wait for the client to
    2387                 :            :          * advertise a zero window, then kill -9 the FTP client, wheee...
    2388                 :            :          * Note: timeout is always zero in such a case.
    2389                 :            :          */
    2390                 :          1 :         if (unlikely(tcp_sk(sk)->repair)) {
    2391                 :          0 :                 sk->sk_prot->disconnect(sk, 0);
    2392                 :          1 :         } else if (data_was_unread) {
    2393                 :            :                 /* Unread data was tossed, zap the connection. */
    2394                 :          1 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONCLOSE);
    2395                 :          1 :                 tcp_set_state(sk, TCP_CLOSE);
    2396                 :          1 :                 tcp_send_active_reset(sk, sk->sk_allocation);
    2397                 :          1 :         } else if (sock_flag(sk, SOCK_LINGER) && !sk->sk_lingertime) {
    2398                 :            :                 /* Check zero linger _after_ checking for unread data. */
    2399                 :          0 :                 sk->sk_prot->disconnect(sk, 0);
    2400                 :          0 :                 NET_INC_STATS(sock_net(sk), LINUX_MIB_TCPABORTONDATA);
    2401                 :          1 :         } else if (tcp_close_state(sk)) {
    2402                 :            :                 /* We FIN if the application ate all the data before
    2403                 :            :                  * zapping the connection.
    2404                 :            :                  */
    2405                 :            : 
    2406                 :            :                 /* RED-PEN. Formally speaking, we have broken TCP state
    2407                 :            :                  * machine. State transitions:
    2408                 :            :                  *
    2409                 :            :                  * TCP_ESTABLISHED -> TCP_FIN_WAIT1
    2410                 :            :                  * TCP_SYN_RECV -> TCP_FIN_WAIT1 (forget it, it's impossible)
    2411                 :            :                  * TCP_CLOSE_WAIT -> TCP_LAST_ACK
    2412                 :            :                  *
    2413                 :            :                  * are legal only when FIN has been sent (i.e. in window),
    2414                 :            :                  * rather than queued out of window. Purists blame.
    2415                 :            :                  *
    2416                 :            :                  * F.e. "RFC state" is ESTABLISHED,
    2417                 :            :                  * if Linux state is FIN-WAIT-1, but FIN is still not sent.
    2418                 :            :                  *
    2419                 :            :                  * The visible declinations are that sometimes
    2420                 :            :                  * we enter time-wait state, when it is not required really
    2421                 :            :                  * (harmless), do not send active resets, when they are
    2422                 :            :                  * required by specs (TCP_ESTABLISHED, TCP_CLOSE_WAIT, when
    2423                 :            :                  * they look as CLOSING or LAST_ACK for Linux)
    2424                 :            :                  * Probably, I missed some more holelets.
    2425                 :            :                  *                                              --ANK
    2426                 :            :                  * XXX (TFO) - To start off we don't support SYN+ACK+FIN
    2427                 :            :                  * in a single packet! (May consider it later but will
    2428                 :            :                  * probably need API support or TCP_CORK SYN-ACK until
    2429                 :            :                  * data is written and socket is closed.)
    2430                 :            :                  */
    2431                 :          1 :                 tcp_send_fin(sk);
    2432                 :            :         }
    2433                 :            : 
    2434                 :          1 :         sk_stream_wait_close(sk, timeout);
    2435                 :            : 
    2436                 :            : adjudge_to_death:
    2437                 :          1 :         state = sk->sk_state;
    2438                 :            :         sock_hold(sk);
    2439                 :          1 :         sock_orphan(sk);
    2440                 :            : 
    2441                 :            :         local_bh_disable();
    2442                 :            :         bh_lock_sock(sk);
    2443                 :            :         /* remove backlog if any, without releasing ownership. */
    2444                 :          1 :         __release_sock(sk);
    2445                 :            : 
    2446                 :          1 :         percpu_counter_inc(sk->sk_prot->orphan_count);
    2447                 :            : 
    2448                 :            :         /* Have we already been destroyed by a softirq or backlog? */
    2449                 :          1 :         if (state != TCP_CLOSE && sk->sk_state == TCP_CLOSE)
    2450                 :            :                 goto out;
    2451                 :            : 
    2452                 :            :         /*      This is a (useful) BSD violating of the RFC. There is a
    2453                 :            :          *      problem with TCP as specified in that the other end could
    2454                 :            :          *      keep a socket open forever with no application left this end.
    2455                 :            :          *      We use a 1 minute timeout (about the same as BSD) then kill
    2456                 :            :          *      our end. If they send after that then tough - BUT: long enough
    2457                 :            :          *      that we won't make the old 4*rto = almost no time - whoops
    2458                 :            :          *      reset mistake.
    2459                 :            :          *
    2460                 :            :          *      Nope, it was not mistake. It is really desired behaviour
    2461                 :            :          *      f.e. on http servers, when such sockets are useless, but
    2462                 :            :          *      consume significant resources. Let's do it with special
    2463                 :            :          *      linger2 option.                                 --ANK
    2464                 :            :          */
    2465                 :            : 
    2466                 :          1 :         if (sk->sk_state == TCP_FIN_WAIT2) {
    2467                 :            :                 struct tcp_sock *tp = tcp_sk(sk);
    2468                 :          0 :                 if (tp->linger2 < 0) {
    2469                 :          0 :                         tcp_set_state(sk, TCP_CLOSE);
    2470                 :          0 :                         tcp_send_active_reset(sk, GFP_ATOMIC);
    2471                 :          0 :                         __NET_INC_STATS(sock_net(sk),
    2472                 :            :                                         LINUX_MIB_TCPABORTONLINGER);
    2473                 :            :                 } else {
    2474                 :            :                         const int tmo = tcp_fin_time(sk);
    2475                 :            : 
    2476                 :          0 :                         if (tmo > TCP_TIMEWAIT_LEN) {
    2477                 :          0 :                                 inet_csk_reset_keepalive_timer(sk,
    2478                 :          0 :                                                 tmo - TCP_TIMEWAIT_LEN);
    2479                 :            :                         } else {
    2480                 :          0 :                                 tcp_time_wait(sk, TCP_FIN_WAIT2, tmo);
    2481                 :          0 :                                 goto out;
    2482                 :            :                         }
    2483                 :            :                 }
    2484                 :            :         }
    2485                 :          1 :         if (sk->sk_state != TCP_CLOSE) {
    2486                 :          1 :                 sk_mem_reclaim(sk);
    2487                 :          1 :                 if (tcp_check_oom(sk, 0)) {
    2488                 :          0 :                         tcp_set_state(sk, TCP_CLOSE);
    2489                 :          0 :                         tcp_send_active_reset(sk, GFP_ATOMIC);
    2490                 :          0 :                         __NET_INC_STATS(sock_net(sk),
    2491                 :            :                                         LINUX_MIB_TCPABORTONMEMORY);
    2492                 :          1 :                 } else if (!check_net(sock_net(sk))) {
    2493                 :            :                         /* Not possible to send reset; just close */
    2494                 :          0 :                         tcp_set_state(sk, TCP_CLOSE);
    2495                 :            :                 }
    2496                 :            :         }
    2497                 :            : 
    2498                 :          1 :         if (sk->sk_state == TCP_CLOSE) {
    2499                 :            :                 struct request_sock *req;
    2500                 :            : 
    2501                 :          1 :                 req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk,
    2502                 :            :                                                 lockdep_sock_is_held(sk));
    2503                 :            :                 /* We could get here with a non-NULL req if the socket is
    2504                 :            :                  * aborted (e.g., closed with unread data) before 3WHS
    2505                 :            :                  * finishes.
    2506                 :            :                  */
    2507                 :          1 :                 if (req)
    2508                 :          0 :                         reqsk_fastopen_remove(sk, req, false);
    2509                 :          1 :                 inet_csk_destroy_sock(sk);
    2510                 :            :         }
    2511                 :            :         /* Otherwise, socket is reprieved until protocol close. */
    2512                 :            : 
    2513                 :            : out:
    2514                 :            :         bh_unlock_sock(sk);
    2515                 :            :         local_bh_enable();
    2516                 :          1 :         release_sock(sk);
    2517                 :          1 :         sock_put(sk);
    2518                 :          1 : }
    2519                 :            : EXPORT_SYMBOL(tcp_close);
    2520                 :            : 
    2521                 :            : /* These states need RST on ABORT according to RFC793 */
    2522                 :            : 
    2523                 :            : static inline bool tcp_need_reset(int state)
    2524                 :            : {
    2525                 :          0 :         return (1 << state) &
    2526                 :            :                (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT | TCPF_FIN_WAIT1 |
    2527                 :            :                 TCPF_FIN_WAIT2 | TCPF_SYN_RECV);
    2528                 :            : }
    2529                 :            : 
    2530                 :          1 : static void tcp_rtx_queue_purge(struct sock *sk)
    2531                 :            : {
    2532                 :          1 :         struct rb_node *p = rb_first(&sk->tcp_rtx_queue);
    2533                 :            : 
    2534                 :          1 :         tcp_sk(sk)->highest_sack = NULL;
    2535                 :          1 :         while (p) {
    2536                 :          0 :                 struct sk_buff *skb = rb_to_skb(p);
    2537                 :            : 
    2538                 :          0 :                 p = rb_next(p);
    2539                 :            :                 /* Since we are deleting whole queue, no need to
    2540                 :            :                  * list_del(&skb->tcp_tsorted_anchor)
    2541                 :            :                  */
    2542                 :            :                 tcp_rtx_queue_unlink(skb, sk);
    2543                 :          0 :                 sk_wmem_free_skb(sk, skb);
    2544                 :            :         }
    2545                 :          1 : }
    2546                 :            : 
    2547                 :          1 : void tcp_write_queue_purge(struct sock *sk)
    2548                 :            : {
    2549                 :            :         struct sk_buff *skb;
    2550                 :            : 
    2551                 :          1 :         tcp_chrono_stop(sk, TCP_CHRONO_BUSY);
    2552                 :          1 :         while ((skb = __skb_dequeue(&sk->sk_write_queue)) != NULL) {
    2553                 :            :                 tcp_skb_tsorted_anchor_cleanup(skb);
    2554                 :          0 :                 sk_wmem_free_skb(sk, skb);
    2555                 :            :         }
    2556                 :          1 :         tcp_rtx_queue_purge(sk);
    2557                 :          1 :         skb = sk->sk_tx_skb_cache;
    2558                 :          1 :         if (skb) {
    2559                 :          0 :                 __kfree_skb(skb);
    2560                 :          0 :                 sk->sk_tx_skb_cache = NULL;
    2561                 :            :         }
    2562                 :          1 :         INIT_LIST_HEAD(&tcp_sk(sk)->tsorted_sent_queue);
    2563                 :          1 :         sk_mem_reclaim(sk);
    2564                 :            :         tcp_clear_all_retrans_hints(tcp_sk(sk));
    2565                 :          1 :         tcp_sk(sk)->packets_out = 0;
    2566                 :          1 :         inet_csk(sk)->icsk_backoff = 0;
    2567                 :          1 : }
    2568                 :            : 
    2569                 :          0 : int tcp_disconnect(struct sock *sk, int flags)
    2570                 :            : {
    2571                 :            :         struct inet_sock *inet = inet_sk(sk);
    2572                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    2573                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2574                 :          0 :         int old_state = sk->sk_state;
    2575                 :            :         u32 seq;
    2576                 :            : 
    2577                 :          0 :         if (old_state != TCP_CLOSE)
    2578                 :          0 :                 tcp_set_state(sk, TCP_CLOSE);
    2579                 :            : 
    2580                 :            :         /* ABORT function of RFC793 */
    2581                 :          0 :         if (old_state == TCP_LISTEN) {
    2582                 :          0 :                 inet_csk_listen_stop(sk);
    2583                 :          0 :         } else if (unlikely(tp->repair)) {
    2584                 :          0 :                 sk->sk_err = ECONNABORTED;
    2585                 :          0 :         } else if (tcp_need_reset(old_state) ||
    2586                 :          0 :                    (tp->snd_nxt != tp->write_seq &&
    2587                 :            :                     (1 << old_state) & (TCPF_CLOSING | TCPF_LAST_ACK))) {
    2588                 :            :                 /* The last check adjusts for discrepancy of Linux wrt. RFC
    2589                 :            :                  * states
    2590                 :            :                  */
    2591                 :          0 :                 tcp_send_active_reset(sk, gfp_any());
    2592                 :          0 :                 sk->sk_err = ECONNRESET;
    2593                 :          0 :         } else if (old_state == TCP_SYN_SENT)
    2594                 :          0 :                 sk->sk_err = ECONNRESET;
    2595                 :            : 
    2596                 :          0 :         tcp_clear_xmit_timers(sk);
    2597                 :          0 :         __skb_queue_purge(&sk->sk_receive_queue);
    2598                 :          0 :         if (sk->sk_rx_skb_cache) {
    2599                 :          0 :                 __kfree_skb(sk->sk_rx_skb_cache);
    2600                 :          0 :                 sk->sk_rx_skb_cache = NULL;
    2601                 :            :         }
    2602                 :          0 :         WRITE_ONCE(tp->copied_seq, tp->rcv_nxt);
    2603                 :          0 :         tp->urg_data = 0;
    2604                 :          0 :         tcp_write_queue_purge(sk);
    2605                 :          0 :         tcp_fastopen_active_disable_ofo_check(sk);
    2606                 :          0 :         skb_rbtree_purge(&tp->out_of_order_queue);
    2607                 :            : 
    2608                 :          0 :         inet->inet_dport = 0;
    2609                 :            : 
    2610                 :          0 :         if (!(sk->sk_userlocks & SOCK_BINDADDR_LOCK))
    2611                 :          0 :                 inet_reset_saddr(sk);
    2612                 :            : 
    2613                 :          0 :         sk->sk_shutdown = 0;
    2614                 :            :         sock_reset_flag(sk, SOCK_DONE);
    2615                 :          0 :         tp->srtt_us = 0;
    2616                 :          0 :         tp->mdev_us = jiffies_to_usecs(TCP_TIMEOUT_INIT);
    2617                 :          0 :         tp->rcv_rtt_last_tsecr = 0;
    2618                 :            : 
    2619                 :          0 :         seq = tp->write_seq + tp->max_window + 2;
    2620                 :          0 :         if (!seq)
    2621                 :            :                 seq = 1;
    2622                 :            :         WRITE_ONCE(tp->write_seq, seq);
    2623                 :            : 
    2624                 :          0 :         icsk->icsk_backoff = 0;
    2625                 :          0 :         tp->snd_cwnd = 2;
    2626                 :          0 :         icsk->icsk_probes_out = 0;
    2627                 :          0 :         icsk->icsk_rto = TCP_TIMEOUT_INIT;
    2628                 :          0 :         tp->snd_ssthresh = TCP_INFINITE_SSTHRESH;
    2629                 :          0 :         tp->snd_cwnd = TCP_INIT_CWND;
    2630                 :          0 :         tp->snd_cwnd_cnt = 0;
    2631                 :          0 :         tp->window_clamp = 0;
    2632                 :          0 :         tp->delivered = 0;
    2633                 :          0 :         tp->delivered_ce = 0;
    2634                 :          0 :         if (icsk->icsk_ca_ops->release)
    2635                 :          0 :                 icsk->icsk_ca_ops->release(sk);
    2636                 :          0 :         memset(icsk->icsk_ca_priv, 0, sizeof(icsk->icsk_ca_priv));
    2637                 :            :         tcp_set_ca_state(sk, TCP_CA_Open);
    2638                 :          0 :         tp->is_sack_reneg = 0;
    2639                 :          0 :         tcp_clear_retrans(tp);
    2640                 :          0 :         tp->total_retrans = 0;
    2641                 :            :         inet_csk_delack_init(sk);
    2642                 :            :         /* Initialize rcv_mss to TCP_MIN_MSS to avoid division by 0
    2643                 :            :          * issue in __tcp_select_window()
    2644                 :            :          */
    2645                 :          0 :         icsk->icsk_ack.rcv_mss = TCP_MIN_MSS;
    2646                 :          0 :         memset(&tp->rx_opt, 0, sizeof(tp->rx_opt));
    2647                 :            :         __sk_dst_reset(sk);
    2648                 :          0 :         dst_release(sk->sk_rx_dst);
    2649                 :          0 :         sk->sk_rx_dst = NULL;
    2650                 :            :         tcp_saved_syn_free(tp);
    2651                 :          0 :         tp->compressed_ack = 0;
    2652                 :          0 :         tp->segs_in = 0;
    2653                 :          0 :         tp->segs_out = 0;
    2654                 :          0 :         tp->bytes_sent = 0;
    2655                 :          0 :         tp->bytes_acked = 0;
    2656                 :          0 :         tp->bytes_received = 0;
    2657                 :          0 :         tp->bytes_retrans = 0;
    2658                 :          0 :         tp->data_segs_in = 0;
    2659                 :          0 :         tp->data_segs_out = 0;
    2660                 :          0 :         tp->duplicate_sack[0].start_seq = 0;
    2661                 :          0 :         tp->duplicate_sack[0].end_seq = 0;
    2662                 :          0 :         tp->dsack_dups = 0;
    2663                 :          0 :         tp->reord_seen = 0;
    2664                 :          0 :         tp->retrans_out = 0;
    2665                 :          0 :         tp->sacked_out = 0;
    2666                 :          0 :         tp->tlp_high_seq = 0;
    2667                 :          0 :         tp->last_oow_ack_time = 0;
    2668                 :            :         /* There's a bubble in the pipe until at least the first ACK. */
    2669                 :          0 :         tp->app_limited = ~0U;
    2670                 :          0 :         tp->rack.mstamp = 0;
    2671                 :          0 :         tp->rack.advanced = 0;
    2672                 :          0 :         tp->rack.reo_wnd_steps = 1;
    2673                 :          0 :         tp->rack.last_delivered = 0;
    2674                 :          0 :         tp->rack.reo_wnd_persist = 0;
    2675                 :          0 :         tp->rack.dsack_seen = 0;
    2676                 :          0 :         tp->syn_data_acked = 0;
    2677                 :          0 :         tp->rx_opt.saw_tstamp = 0;
    2678                 :          0 :         tp->rx_opt.dsack = 0;
    2679                 :          0 :         tp->rx_opt.num_sacks = 0;
    2680                 :          0 :         tp->rcv_ooopack = 0;
    2681                 :            : 
    2682                 :            : 
    2683                 :            :         /* Clean up fastopen related fields */
    2684                 :            :         tcp_free_fastopen_req(tp);
    2685                 :          0 :         inet->defer_connect = 0;
    2686                 :            : 
    2687                 :          0 :         WARN_ON(inet->inet_num && !icsk->icsk_bind_hash);
    2688                 :            : 
    2689                 :          0 :         if (sk->sk_frag.page) {
    2690                 :          0 :                 put_page(sk->sk_frag.page);
    2691                 :          0 :                 sk->sk_frag.page = NULL;
    2692                 :          0 :                 sk->sk_frag.offset = 0;
    2693                 :            :         }
    2694                 :            : 
    2695                 :          0 :         sk->sk_error_report(sk);
    2696                 :          0 :         return 0;
    2697                 :            : }
    2698                 :            : EXPORT_SYMBOL(tcp_disconnect);
    2699                 :            : 
    2700                 :          0 : static inline bool tcp_can_repair_sock(const struct sock *sk)
    2701                 :            : {
    2702                 :          0 :         return ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN) &&
    2703                 :          0 :                 (sk->sk_state != TCP_LISTEN);
    2704                 :            : }
    2705                 :            : 
    2706                 :          0 : static int tcp_repair_set_window(struct tcp_sock *tp, char __user *optbuf, int len)
    2707                 :            : {
    2708                 :            :         struct tcp_repair_window opt;
    2709                 :            : 
    2710                 :          0 :         if (!tp->repair)
    2711                 :            :                 return -EPERM;
    2712                 :            : 
    2713                 :          0 :         if (len != sizeof(opt))
    2714                 :            :                 return -EINVAL;
    2715                 :            : 
    2716                 :          0 :         if (copy_from_user(&opt, optbuf, sizeof(opt)))
    2717                 :            :                 return -EFAULT;
    2718                 :            : 
    2719                 :          0 :         if (opt.max_window < opt.snd_wnd)
    2720                 :            :                 return -EINVAL;
    2721                 :            : 
    2722                 :          0 :         if (after(opt.snd_wl1, tp->rcv_nxt + opt.rcv_wnd))
    2723                 :            :                 return -EINVAL;
    2724                 :            : 
    2725                 :          0 :         if (after(opt.rcv_wup, tp->rcv_nxt))
    2726                 :            :                 return -EINVAL;
    2727                 :            : 
    2728                 :          0 :         tp->snd_wl1  = opt.snd_wl1;
    2729                 :          0 :         tp->snd_wnd  = opt.snd_wnd;
    2730                 :          0 :         tp->max_window       = opt.max_window;
    2731                 :            : 
    2732                 :          0 :         tp->rcv_wnd  = opt.rcv_wnd;
    2733                 :          0 :         tp->rcv_wup  = opt.rcv_wup;
    2734                 :            : 
    2735                 :          0 :         return 0;
    2736                 :            : }
    2737                 :            : 
    2738                 :          0 : static int tcp_repair_options_est(struct sock *sk,
    2739                 :            :                 struct tcp_repair_opt __user *optbuf, unsigned int len)
    2740                 :            : {
    2741                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2742                 :            :         struct tcp_repair_opt opt;
    2743                 :            : 
    2744                 :          0 :         while (len >= sizeof(opt)) {
    2745                 :          0 :                 if (copy_from_user(&opt, optbuf, sizeof(opt)))
    2746                 :            :                         return -EFAULT;
    2747                 :            : 
    2748                 :          0 :                 optbuf++;
    2749                 :          0 :                 len -= sizeof(opt);
    2750                 :            : 
    2751                 :          0 :                 switch (opt.opt_code) {
    2752                 :            :                 case TCPOPT_MSS:
    2753                 :          0 :                         tp->rx_opt.mss_clamp = opt.opt_val;
    2754                 :          0 :                         tcp_mtup_init(sk);
    2755                 :          0 :                         break;
    2756                 :            :                 case TCPOPT_WINDOW:
    2757                 :            :                         {
    2758                 :          0 :                                 u16 snd_wscale = opt.opt_val & 0xFFFF;
    2759                 :          0 :                                 u16 rcv_wscale = opt.opt_val >> 16;
    2760                 :            : 
    2761                 :          0 :                                 if (snd_wscale > TCP_MAX_WSCALE || rcv_wscale > TCP_MAX_WSCALE)
    2762                 :            :                                         return -EFBIG;
    2763                 :            : 
    2764                 :          0 :                                 tp->rx_opt.snd_wscale = snd_wscale;
    2765                 :          0 :                                 tp->rx_opt.rcv_wscale = rcv_wscale;
    2766                 :          0 :                                 tp->rx_opt.wscale_ok = 1;
    2767                 :            :                         }
    2768                 :          0 :                         break;
    2769                 :            :                 case TCPOPT_SACK_PERM:
    2770                 :          0 :                         if (opt.opt_val != 0)
    2771                 :            :                                 return -EINVAL;
    2772                 :            : 
    2773                 :          0 :                         tp->rx_opt.sack_ok |= TCP_SACK_SEEN;
    2774                 :          0 :                         break;
    2775                 :            :                 case TCPOPT_TIMESTAMP:
    2776                 :          0 :                         if (opt.opt_val != 0)
    2777                 :            :                                 return -EINVAL;
    2778                 :            : 
    2779                 :          0 :                         tp->rx_opt.tstamp_ok = 1;
    2780                 :          0 :                         break;
    2781                 :            :                 }
    2782                 :            :         }
    2783                 :            : 
    2784                 :            :         return 0;
    2785                 :            : }
    2786                 :            : 
    2787                 :            : DEFINE_STATIC_KEY_FALSE(tcp_tx_delay_enabled);
    2788                 :            : EXPORT_SYMBOL(tcp_tx_delay_enabled);
    2789                 :            : 
    2790                 :          0 : static void tcp_enable_tx_delay(void)
    2791                 :            : {
    2792                 :          0 :         if (!static_branch_unlikely(&tcp_tx_delay_enabled)) {
    2793                 :            :                 static int __tcp_tx_delay_enabled = 0;
    2794                 :            : 
    2795                 :          0 :                 if (cmpxchg(&__tcp_tx_delay_enabled, 0, 1) == 0) {
    2796                 :          0 :                         static_branch_enable(&tcp_tx_delay_enabled);
    2797                 :          0 :                         pr_info("TCP_TX_DELAY enabled\n");
    2798                 :            :                 }
    2799                 :            :         }
    2800                 :          0 : }
    2801                 :            : 
    2802                 :            : /*
    2803                 :            :  *      Socket option code for TCP.
    2804                 :            :  */
    2805                 :          1 : static int do_tcp_setsockopt(struct sock *sk, int level,
    2806                 :            :                 int optname, char __user *optval, unsigned int optlen)
    2807                 :            : {
    2808                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    2809                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    2810                 :            :         struct net *net = sock_net(sk);
    2811                 :            :         int val;
    2812                 :            :         int err = 0;
    2813                 :            : 
    2814                 :            :         /* These are data/string values, all the others are ints */
    2815                 :          1 :         switch (optname) {
    2816                 :            :         case TCP_CONGESTION: {
    2817                 :            :                 char name[TCP_CA_NAME_MAX];
    2818                 :            : 
    2819                 :          0 :                 if (optlen < 1)
    2820                 :            :                         return -EINVAL;
    2821                 :            : 
    2822                 :          0 :                 val = strncpy_from_user(name, optval,
    2823                 :          0 :                                         min_t(long, TCP_CA_NAME_MAX-1, optlen));
    2824                 :          0 :                 if (val < 0)
    2825                 :            :                         return -EFAULT;
    2826                 :          0 :                 name[val] = 0;
    2827                 :            : 
    2828                 :            :                 lock_sock(sk);
    2829                 :          0 :                 err = tcp_set_congestion_control(sk, name, true, true,
    2830                 :            :                                                  ns_capable(sock_net(sk)->user_ns,
    2831                 :            :                                                             CAP_NET_ADMIN));
    2832                 :          0 :                 release_sock(sk);
    2833                 :          0 :                 return err;
    2834                 :            :         }
    2835                 :            :         case TCP_ULP: {
    2836                 :            :                 char name[TCP_ULP_NAME_MAX];
    2837                 :            : 
    2838                 :          0 :                 if (optlen < 1)
    2839                 :            :                         return -EINVAL;
    2840                 :            : 
    2841                 :          0 :                 val = strncpy_from_user(name, optval,
    2842                 :          0 :                                         min_t(long, TCP_ULP_NAME_MAX - 1,
    2843                 :            :                                               optlen));
    2844                 :          0 :                 if (val < 0)
    2845                 :            :                         return -EFAULT;
    2846                 :          0 :                 name[val] = 0;
    2847                 :            : 
    2848                 :            :                 lock_sock(sk);
    2849                 :          0 :                 err = tcp_set_ulp(sk, name);
    2850                 :          0 :                 release_sock(sk);
    2851                 :          0 :                 return err;
    2852                 :            :         }
    2853                 :            :         case TCP_FASTOPEN_KEY: {
    2854                 :            :                 __u8 key[TCP_FASTOPEN_KEY_BUF_LENGTH];
    2855                 :            :                 __u8 *backup_key = NULL;
    2856                 :            : 
    2857                 :            :                 /* Allow a backup key as well to facilitate key rotation
    2858                 :            :                  * First key is the active one.
    2859                 :            :                  */
    2860                 :          0 :                 if (optlen != TCP_FASTOPEN_KEY_LENGTH &&
    2861                 :          0 :                     optlen != TCP_FASTOPEN_KEY_BUF_LENGTH)
    2862                 :            :                         return -EINVAL;
    2863                 :            : 
    2864                 :          0 :                 if (copy_from_user(key, optval, optlen))
    2865                 :            :                         return -EFAULT;
    2866                 :            : 
    2867                 :          0 :                 if (optlen == TCP_FASTOPEN_KEY_BUF_LENGTH)
    2868                 :            :                         backup_key = key + TCP_FASTOPEN_KEY_LENGTH;
    2869                 :            : 
    2870                 :          0 :                 return tcp_fastopen_reset_cipher(net, sk, key, backup_key);
    2871                 :            :         }
    2872                 :            :         default:
    2873                 :            :                 /* fallthru */
    2874                 :            :                 break;
    2875                 :            :         }
    2876                 :            : 
    2877                 :          1 :         if (optlen < sizeof(int))
    2878                 :            :                 return -EINVAL;
    2879                 :            : 
    2880                 :          1 :         if (get_user(val, (int __user *)optval))
    2881                 :            :                 return -EFAULT;
    2882                 :            : 
    2883                 :            :         lock_sock(sk);
    2884                 :            : 
    2885                 :          1 :         switch (optname) {
    2886                 :            :         case TCP_MAXSEG:
    2887                 :            :                 /* Values greater than interface MTU won't take effect. However
    2888                 :            :                  * at the point when this call is done we typically don't yet
    2889                 :            :                  * know which interface is going to be used
    2890                 :            :                  */
    2891                 :          0 :                 if (val && (val < TCP_MIN_MSS || val > MAX_TCP_WINDOW)) {
    2892                 :            :                         err = -EINVAL;
    2893                 :            :                         break;
    2894                 :            :                 }
    2895                 :          0 :                 tp->rx_opt.user_mss = val;
    2896                 :          0 :                 break;
    2897                 :            : 
    2898                 :            :         case TCP_NODELAY:
    2899                 :          1 :                 if (val) {
    2900                 :            :                         /* TCP_NODELAY is weaker than TCP_CORK, so that
    2901                 :            :                          * this option on corked socket is remembered, but
    2902                 :            :                          * it is not activated until cork is cleared.
    2903                 :            :                          *
    2904                 :            :                          * However, when TCP_NODELAY is set we make
    2905                 :            :                          * an explicit push, which overrides even TCP_CORK
    2906                 :            :                          * for currently queued segments.
    2907                 :            :                          */
    2908                 :          1 :                         tp->nonagle |= TCP_NAGLE_OFF|TCP_NAGLE_PUSH;
    2909                 :          1 :                         tcp_push_pending_frames(sk);
    2910                 :            :                 } else {
    2911                 :          0 :                         tp->nonagle &= ~TCP_NAGLE_OFF;
    2912                 :            :                 }
    2913                 :            :                 break;
    2914                 :            : 
    2915                 :            :         case TCP_THIN_LINEAR_TIMEOUTS:
    2916                 :          0 :                 if (val < 0 || val > 1)
    2917                 :            :                         err = -EINVAL;
    2918                 :            :                 else
    2919                 :          0 :                         tp->thin_lto = val;
    2920                 :            :                 break;
    2921                 :            : 
    2922                 :            :         case TCP_THIN_DUPACK:
    2923                 :          0 :                 if (val < 0 || val > 1)
    2924                 :            :                         err = -EINVAL;
    2925                 :            :                 break;
    2926                 :            : 
    2927                 :            :         case TCP_REPAIR:
    2928                 :          0 :                 if (!tcp_can_repair_sock(sk))
    2929                 :            :                         err = -EPERM;
    2930                 :          0 :                 else if (val == TCP_REPAIR_ON) {
    2931                 :          0 :                         tp->repair = 1;
    2932                 :          0 :                         sk->sk_reuse = SK_FORCE_REUSE;
    2933                 :          0 :                         tp->repair_queue = TCP_NO_QUEUE;
    2934                 :          0 :                 } else if (val == TCP_REPAIR_OFF) {
    2935                 :          0 :                         tp->repair = 0;
    2936                 :          0 :                         sk->sk_reuse = SK_NO_REUSE;
    2937                 :          0 :                         tcp_send_window_probe(sk);
    2938                 :          0 :                 } else if (val == TCP_REPAIR_OFF_NO_WP) {
    2939                 :          0 :                         tp->repair = 0;
    2940                 :          0 :                         sk->sk_reuse = SK_NO_REUSE;
    2941                 :            :                 } else
    2942                 :            :                         err = -EINVAL;
    2943                 :            : 
    2944                 :            :                 break;
    2945                 :            : 
    2946                 :            :         case TCP_REPAIR_QUEUE:
    2947                 :          0 :                 if (!tp->repair)
    2948                 :            :                         err = -EPERM;
    2949                 :          0 :                 else if ((unsigned int)val < TCP_QUEUES_NR)
    2950                 :          0 :                         tp->repair_queue = val;
    2951                 :            :                 else
    2952                 :            :                         err = -EINVAL;
    2953                 :            :                 break;
    2954                 :            : 
    2955                 :            :         case TCP_QUEUE_SEQ:
    2956                 :          0 :                 if (sk->sk_state != TCP_CLOSE)
    2957                 :            :                         err = -EPERM;
    2958                 :          0 :                 else if (tp->repair_queue == TCP_SEND_QUEUE)
    2959                 :            :                         WRITE_ONCE(tp->write_seq, val);
    2960                 :          0 :                 else if (tp->repair_queue == TCP_RECV_QUEUE) {
    2961                 :            :                         WRITE_ONCE(tp->rcv_nxt, val);
    2962                 :            :                         WRITE_ONCE(tp->copied_seq, val);
    2963                 :            :                 }
    2964                 :            :                 else
    2965                 :            :                         err = -EINVAL;
    2966                 :            :                 break;
    2967                 :            : 
    2968                 :            :         case TCP_REPAIR_OPTIONS:
    2969                 :          0 :                 if (!tp->repair)
    2970                 :            :                         err = -EINVAL;
    2971                 :          0 :                 else if (sk->sk_state == TCP_ESTABLISHED)
    2972                 :          0 :                         err = tcp_repair_options_est(sk,
    2973                 :            :                                         (struct tcp_repair_opt __user *)optval,
    2974                 :            :                                         optlen);
    2975                 :            :                 else
    2976                 :            :                         err = -EPERM;
    2977                 :            :                 break;
    2978                 :            : 
    2979                 :            :         case TCP_CORK:
    2980                 :            :                 /* When set indicates to always queue non-full frames.
    2981                 :            :                  * Later the user clears this option and we transmit
    2982                 :            :                  * any pending partial frames in the queue.  This is
    2983                 :            :                  * meant to be used alongside sendfile() to get properly
    2984                 :            :                  * filled frames when the user (for example) must write
    2985                 :            :                  * out headers with a write() call first and then use
    2986                 :            :                  * sendfile to send out the data parts.
    2987                 :            :                  *
    2988                 :            :                  * TCP_CORK can be set together with TCP_NODELAY and it is
    2989                 :            :                  * stronger than TCP_NODELAY.
    2990                 :            :                  */
    2991                 :          0 :                 if (val) {
    2992                 :          0 :                         tp->nonagle |= TCP_NAGLE_CORK;
    2993                 :            :                 } else {
    2994                 :          0 :                         tp->nonagle &= ~TCP_NAGLE_CORK;
    2995                 :          0 :                         if (tp->nonagle&TCP_NAGLE_OFF)
    2996                 :          0 :                                 tp->nonagle |= TCP_NAGLE_PUSH;
    2997                 :          0 :                         tcp_push_pending_frames(sk);
    2998                 :            :                 }
    2999                 :            :                 break;
    3000                 :            : 
    3001                 :            :         case TCP_KEEPIDLE:
    3002                 :          1 :                 if (val < 1 || val > MAX_TCP_KEEPIDLE)
    3003                 :            :                         err = -EINVAL;
    3004                 :            :                 else {
    3005                 :          1 :                         tp->keepalive_time = val * HZ;
    3006                 :          1 :                         if (sock_flag(sk, SOCK_KEEPOPEN) &&
    3007                 :          1 :                             !((1 << sk->sk_state) &
    3008                 :            :                               (TCPF_CLOSE | TCPF_LISTEN))) {
    3009                 :            :                                 u32 elapsed = keepalive_time_elapsed(tp);
    3010                 :          0 :                                 if (tp->keepalive_time > elapsed)
    3011                 :          0 :                                         elapsed = tp->keepalive_time - elapsed;
    3012                 :            :                                 else
    3013                 :            :                                         elapsed = 0;
    3014                 :          0 :                                 inet_csk_reset_keepalive_timer(sk, elapsed);
    3015                 :            :                         }
    3016                 :            :                 }
    3017                 :            :                 break;
    3018                 :            :         case TCP_KEEPINTVL:
    3019                 :          1 :                 if (val < 1 || val > MAX_TCP_KEEPINTVL)
    3020                 :            :                         err = -EINVAL;
    3021                 :            :                 else
    3022                 :          1 :                         tp->keepalive_intvl = val * HZ;
    3023                 :            :                 break;
    3024                 :            :         case TCP_KEEPCNT:
    3025                 :          0 :                 if (val < 1 || val > MAX_TCP_KEEPCNT)
    3026                 :            :                         err = -EINVAL;
    3027                 :            :                 else
    3028                 :          0 :                         tp->keepalive_probes = val;
    3029                 :            :                 break;
    3030                 :            :         case TCP_SYNCNT:
    3031                 :          0 :                 if (val < 1 || val > MAX_TCP_SYNCNT)
    3032                 :            :                         err = -EINVAL;
    3033                 :            :                 else
    3034                 :          0 :                         icsk->icsk_syn_retries = val;
    3035                 :            :                 break;
    3036                 :            : 
    3037                 :            :         case TCP_SAVE_SYN:
    3038                 :          0 :                 if (val < 0 || val > 1)
    3039                 :            :                         err = -EINVAL;
    3040                 :            :                 else
    3041                 :          0 :                         tp->save_syn = val;
    3042                 :            :                 break;
    3043                 :            : 
    3044                 :            :         case TCP_LINGER2:
    3045                 :          0 :                 if (val < 0)
    3046                 :          0 :                         tp->linger2 = -1;
    3047                 :          0 :                 else if (val > net->ipv4.sysctl_tcp_fin_timeout / HZ)
    3048                 :          0 :                         tp->linger2 = 0;
    3049                 :            :                 else
    3050                 :          0 :                         tp->linger2 = val * HZ;
    3051                 :            :                 break;
    3052                 :            : 
    3053                 :            :         case TCP_DEFER_ACCEPT:
    3054                 :            :                 /* Translate value in seconds to number of retransmits */
    3055                 :          0 :                 icsk->icsk_accept_queue.rskq_defer_accept =
    3056                 :            :                         secs_to_retrans(val, TCP_TIMEOUT_INIT / HZ,
    3057                 :            :                                         TCP_RTO_MAX / HZ);
    3058                 :          0 :                 break;
    3059                 :            : 
    3060                 :            :         case TCP_WINDOW_CLAMP:
    3061                 :          0 :                 if (!val) {
    3062                 :          0 :                         if (sk->sk_state != TCP_CLOSE) {
    3063                 :            :                                 err = -EINVAL;
    3064                 :            :                                 break;
    3065                 :            :                         }
    3066                 :          0 :                         tp->window_clamp = 0;
    3067                 :            :                 } else
    3068                 :          0 :                         tp->window_clamp = val < SOCK_MIN_RCVBUF / 2 ?
    3069                 :          0 :                                                 SOCK_MIN_RCVBUF / 2 : val;
    3070                 :            :                 break;
    3071                 :            : 
    3072                 :            :         case TCP_QUICKACK:
    3073                 :          0 :                 if (!val) {
    3074                 :            :                         inet_csk_enter_pingpong_mode(sk);
    3075                 :            :                 } else {
    3076                 :            :                         inet_csk_exit_pingpong_mode(sk);
    3077                 :          0 :                         if ((1 << sk->sk_state) &
    3078                 :          0 :                             (TCPF_ESTABLISHED | TCPF_CLOSE_WAIT) &&
    3079                 :            :                             inet_csk_ack_scheduled(sk)) {
    3080                 :          0 :                                 icsk->icsk_ack.pending |= ICSK_ACK_PUSHED;
    3081                 :          0 :                                 tcp_cleanup_rbuf(sk, 1);
    3082                 :          0 :                                 if (!(val & 1))
    3083                 :            :                                         inet_csk_enter_pingpong_mode(sk);
    3084                 :            :                         }
    3085                 :            :                 }
    3086                 :            :                 break;
    3087                 :            : 
    3088                 :            : #ifdef CONFIG_TCP_MD5SIG
    3089                 :            :         case TCP_MD5SIG:
    3090                 :            :         case TCP_MD5SIG_EXT:
    3091                 :            :                 err = tp->af_specific->md5_parse(sk, optname, optval, optlen);
    3092                 :            :                 break;
    3093                 :            : #endif
    3094                 :            :         case TCP_USER_TIMEOUT:
    3095                 :            :                 /* Cap the max time in ms TCP will retry or probe the window
    3096                 :            :                  * before giving up and aborting (ETIMEDOUT) a connection.
    3097                 :            :                  */
    3098                 :          0 :                 if (val < 0)
    3099                 :            :                         err = -EINVAL;
    3100                 :            :                 else
    3101                 :          0 :                         icsk->icsk_user_timeout = val;
    3102                 :            :                 break;
    3103                 :            : 
    3104                 :            :         case TCP_FASTOPEN:
    3105                 :          0 :                 if (val >= 0 && ((1 << sk->sk_state) & (TCPF_CLOSE |
    3106                 :            :                     TCPF_LISTEN))) {
    3107                 :          0 :                         tcp_fastopen_init_key_once(net);
    3108                 :            : 
    3109                 :            :                         fastopen_queue_tune(sk, val);
    3110                 :            :                 } else {
    3111                 :            :                         err = -EINVAL;
    3112                 :            :                 }
    3113                 :            :                 break;
    3114                 :            :         case TCP_FASTOPEN_CONNECT:
    3115                 :          0 :                 if (val > 1 || val < 0) {
    3116                 :            :                         err = -EINVAL;
    3117                 :          0 :                 } else if (net->ipv4.sysctl_tcp_fastopen & TFO_CLIENT_ENABLE) {
    3118                 :          0 :                         if (sk->sk_state == TCP_CLOSE)
    3119                 :          0 :                                 tp->fastopen_connect = val;
    3120                 :            :                         else
    3121                 :            :                                 err = -EINVAL;
    3122                 :            :                 } else {
    3123                 :            :                         err = -EOPNOTSUPP;
    3124                 :            :                 }
    3125                 :            :                 break;
    3126                 :            :         case TCP_FASTOPEN_NO_COOKIE:
    3127                 :          0 :                 if (val > 1 || val < 0)
    3128                 :            :                         err = -EINVAL;
    3129                 :          0 :                 else if (!((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)))
    3130                 :            :                         err = -EINVAL;
    3131                 :            :                 else
    3132                 :          0 :                         tp->fastopen_no_cookie = val;
    3133                 :            :                 break;
    3134                 :            :         case TCP_TIMESTAMP:
    3135                 :          0 :                 if (!tp->repair)
    3136                 :            :                         err = -EPERM;
    3137                 :            :                 else
    3138                 :          0 :                         tp->tsoffset = val - tcp_time_stamp_raw();
    3139                 :            :                 break;
    3140                 :            :         case TCP_REPAIR_WINDOW:
    3141                 :          0 :                 err = tcp_repair_set_window(tp, optval, optlen);
    3142                 :          0 :                 break;
    3143                 :            :         case TCP_NOTSENT_LOWAT:
    3144                 :          0 :                 tp->notsent_lowat = val;
    3145                 :          0 :                 sk->sk_write_space(sk);
    3146                 :          0 :                 break;
    3147                 :            :         case TCP_INQ:
    3148                 :          0 :                 if (val > 1 || val < 0)
    3149                 :            :                         err = -EINVAL;
    3150                 :            :                 else
    3151                 :          0 :                         tp->recvmsg_inq = val;
    3152                 :            :                 break;
    3153                 :            :         case TCP_TX_DELAY:
    3154                 :          0 :                 if (val)
    3155                 :          0 :                         tcp_enable_tx_delay();
    3156                 :          0 :                 tp->tcp_tx_delay = val;
    3157                 :          0 :                 break;
    3158                 :            :         default:
    3159                 :            :                 err = -ENOPROTOOPT;
    3160                 :            :                 break;
    3161                 :            :         }
    3162                 :            : 
    3163                 :          1 :         release_sock(sk);
    3164                 :          1 :         return err;
    3165                 :            : }
    3166                 :            : 
    3167                 :          1 : int tcp_setsockopt(struct sock *sk, int level, int optname, char __user *optval,
    3168                 :            :                    unsigned int optlen)
    3169                 :            : {
    3170                 :            :         const struct inet_connection_sock *icsk = inet_csk(sk);
    3171                 :            : 
    3172                 :          1 :         if (level != SOL_TCP)
    3173                 :          0 :                 return icsk->icsk_af_ops->setsockopt(sk, level, optname,
    3174                 :            :                                                      optval, optlen);
    3175                 :          1 :         return do_tcp_setsockopt(sk, level, optname, optval, optlen);
    3176                 :            : }
    3177                 :            : EXPORT_SYMBOL(tcp_setsockopt);
    3178                 :            : 
    3179                 :            : #ifdef CONFIG_COMPAT
    3180                 :            : int compat_tcp_setsockopt(struct sock *sk, int level, int optname,
    3181                 :            :                           char __user *optval, unsigned int optlen)
    3182                 :            : {
    3183                 :            :         if (level != SOL_TCP)
    3184                 :            :                 return inet_csk_compat_setsockopt(sk, level, optname,
    3185                 :            :                                                   optval, optlen);
    3186                 :            :         return do_tcp_setsockopt(sk, level, optname, optval, optlen);
    3187                 :            : }
    3188                 :            : EXPORT_SYMBOL(compat_tcp_setsockopt);
    3189                 :            : #endif
    3190                 :            : 
    3191                 :          1 : static void tcp_get_info_chrono_stats(const struct tcp_sock *tp,
    3192                 :            :                                       struct tcp_info *info)
    3193                 :            : {
    3194                 :            :         u64 stats[__TCP_CHRONO_MAX], total = 0;
    3195                 :            :         enum tcp_chrono i;
    3196                 :            : 
    3197                 :          1 :         for (i = TCP_CHRONO_BUSY; i < __TCP_CHRONO_MAX; ++i) {
    3198                 :          1 :                 stats[i] = tp->chrono_stat[i - 1];
    3199                 :          1 :                 if (i == tp->chrono_type)
    3200                 :          1 :                         stats[i] += tcp_jiffies32 - tp->chrono_start;
    3201                 :          1 :                 stats[i] *= USEC_PER_SEC / HZ;
    3202                 :          1 :                 total += stats[i];
    3203                 :            :         }
    3204                 :            : 
    3205                 :          1 :         info->tcpi_busy_time = total;
    3206                 :          1 :         info->tcpi_rwnd_limited = stats[TCP_CHRONO_RWND_LIMITED];
    3207                 :          1 :         info->tcpi_sndbuf_limited = stats[TCP_CHRONO_SNDBUF_LIMITED];
    3208                 :          1 : }
    3209                 :            : 
    3210                 :            : /* Return information about state of tcp endpoint in API format. */
    3211                 :          1 : void tcp_get_info(struct sock *sk, struct tcp_info *info)
    3212                 :            : {
    3213                 :            :         const struct tcp_sock *tp = tcp_sk(sk); /* iff sk_type == SOCK_STREAM */
    3214                 :            :         const struct inet_connection_sock *icsk = inet_csk(sk);
    3215                 :            :         unsigned long rate;
    3216                 :            :         u32 now;
    3217                 :            :         u64 rate64;
    3218                 :            :         bool slow;
    3219                 :            : 
    3220                 :          1 :         memset(info, 0, sizeof(*info));
    3221                 :          1 :         if (sk->sk_type != SOCK_STREAM)
    3222                 :            :                 return;
    3223                 :            : 
    3224                 :          1 :         info->tcpi_state = inet_sk_state_load(sk);
    3225                 :            : 
    3226                 :            :         /* Report meaningful fields for all TCP states, including listeners */
    3227                 :            :         rate = READ_ONCE(sk->sk_pacing_rate);
    3228                 :          1 :         rate64 = (rate != ~0UL) ? rate : ~0ULL;
    3229                 :          1 :         info->tcpi_pacing_rate = rate64;
    3230                 :            : 
    3231                 :            :         rate = READ_ONCE(sk->sk_max_pacing_rate);
    3232                 :          1 :         rate64 = (rate != ~0UL) ? rate : ~0ULL;
    3233                 :          1 :         info->tcpi_max_pacing_rate = rate64;
    3234                 :            : 
    3235                 :          1 :         info->tcpi_reordering = tp->reordering;
    3236                 :          1 :         info->tcpi_snd_cwnd = tp->snd_cwnd;
    3237                 :            : 
    3238                 :          1 :         if (info->tcpi_state == TCP_LISTEN) {
    3239                 :            :                 /* listeners aliased fields :
    3240                 :            :                  * tcpi_unacked -> Number of children ready for accept()
    3241                 :            :                  * tcpi_sacked  -> max backlog
    3242                 :            :                  */
    3243                 :          0 :                 info->tcpi_unacked = sk->sk_ack_backlog;
    3244                 :          0 :                 info->tcpi_sacked = sk->sk_max_ack_backlog;
    3245                 :          0 :                 return;
    3246                 :            :         }
    3247                 :            : 
    3248                 :          1 :         slow = lock_sock_fast(sk);
    3249                 :            : 
    3250                 :          1 :         info->tcpi_ca_state = icsk->icsk_ca_state;
    3251                 :          1 :         info->tcpi_retransmits = icsk->icsk_retransmits;
    3252                 :          1 :         info->tcpi_probes = icsk->icsk_probes_out;
    3253                 :          1 :         info->tcpi_backoff = icsk->icsk_backoff;
    3254                 :            : 
    3255                 :          1 :         if (tp->rx_opt.tstamp_ok)
    3256                 :          0 :                 info->tcpi_options |= TCPI_OPT_TIMESTAMPS;
    3257                 :          1 :         if (tcp_is_sack(tp))
    3258                 :          0 :                 info->tcpi_options |= TCPI_OPT_SACK;
    3259                 :          1 :         if (tp->rx_opt.wscale_ok) {
    3260                 :          0 :                 info->tcpi_options |= TCPI_OPT_WSCALE;
    3261                 :          0 :                 info->tcpi_snd_wscale = tp->rx_opt.snd_wscale;
    3262                 :          0 :                 info->tcpi_rcv_wscale = tp->rx_opt.rcv_wscale;
    3263                 :            :         }
    3264                 :            : 
    3265                 :          1 :         if (tp->ecn_flags & TCP_ECN_OK)
    3266                 :          0 :                 info->tcpi_options |= TCPI_OPT_ECN;
    3267                 :          1 :         if (tp->ecn_flags & TCP_ECN_SEEN)
    3268                 :          0 :                 info->tcpi_options |= TCPI_OPT_ECN_SEEN;
    3269                 :          1 :         if (tp->syn_data_acked)
    3270                 :          0 :                 info->tcpi_options |= TCPI_OPT_SYN_DATA;
    3271                 :            : 
    3272                 :          1 :         info->tcpi_rto = jiffies_to_usecs(icsk->icsk_rto);
    3273                 :          1 :         info->tcpi_ato = jiffies_to_usecs(icsk->icsk_ack.ato);
    3274                 :          1 :         info->tcpi_snd_mss = tp->mss_cache;
    3275                 :          1 :         info->tcpi_rcv_mss = icsk->icsk_ack.rcv_mss;
    3276                 :            : 
    3277                 :          1 :         info->tcpi_unacked = tp->packets_out;
    3278                 :          1 :         info->tcpi_sacked = tp->sacked_out;
    3279                 :            : 
    3280                 :          1 :         info->tcpi_lost = tp->lost_out;
    3281                 :          1 :         info->tcpi_retrans = tp->retrans_out;
    3282                 :            : 
    3283                 :          1 :         now = tcp_jiffies32;
    3284                 :          1 :         info->tcpi_last_data_sent = jiffies_to_msecs(now - tp->lsndtime);
    3285                 :          1 :         info->tcpi_last_data_recv = jiffies_to_msecs(now - icsk->icsk_ack.lrcvtime);
    3286                 :          1 :         info->tcpi_last_ack_recv = jiffies_to_msecs(now - tp->rcv_tstamp);
    3287                 :            : 
    3288                 :          1 :         info->tcpi_pmtu = icsk->icsk_pmtu_cookie;
    3289                 :          1 :         info->tcpi_rcv_ssthresh = tp->rcv_ssthresh;
    3290                 :          1 :         info->tcpi_rtt = tp->srtt_us >> 3;
    3291                 :          1 :         info->tcpi_rttvar = tp->mdev_us >> 2;
    3292                 :          1 :         info->tcpi_snd_ssthresh = tp->snd_ssthresh;
    3293                 :          1 :         info->tcpi_advmss = tp->advmss;
    3294                 :            : 
    3295                 :          1 :         info->tcpi_rcv_rtt = tp->rcv_rtt_est.rtt_us >> 3;
    3296                 :          1 :         info->tcpi_rcv_space = tp->rcvq_space.space;
    3297                 :            : 
    3298                 :          1 :         info->tcpi_total_retrans = tp->total_retrans;
    3299                 :            : 
    3300                 :          1 :         info->tcpi_bytes_acked = tp->bytes_acked;
    3301                 :          1 :         info->tcpi_bytes_received = tp->bytes_received;
    3302                 :          1 :         info->tcpi_notsent_bytes = max_t(int, 0, tp->write_seq - tp->snd_nxt);
    3303                 :          1 :         tcp_get_info_chrono_stats(tp, info);
    3304                 :            : 
    3305                 :          1 :         info->tcpi_segs_out = tp->segs_out;
    3306                 :          1 :         info->tcpi_segs_in = tp->segs_in;
    3307                 :            : 
    3308                 :          1 :         info->tcpi_min_rtt = tcp_min_rtt(tp);
    3309                 :          1 :         info->tcpi_data_segs_in = tp->data_segs_in;
    3310                 :          1 :         info->tcpi_data_segs_out = tp->data_segs_out;
    3311                 :            : 
    3312                 :          1 :         info->tcpi_delivery_rate_app_limited = tp->rate_app_limited ? 1 : 0;
    3313                 :          1 :         rate64 = tcp_compute_delivery_rate(tp);
    3314                 :          1 :         if (rate64)
    3315                 :          1 :                 info->tcpi_delivery_rate = rate64;
    3316                 :          1 :         info->tcpi_delivered = tp->delivered;
    3317                 :          1 :         info->tcpi_delivered_ce = tp->delivered_ce;
    3318                 :          1 :         info->tcpi_bytes_sent = tp->bytes_sent;
    3319                 :          1 :         info->tcpi_bytes_retrans = tp->bytes_retrans;
    3320                 :          1 :         info->tcpi_dsack_dups = tp->dsack_dups;
    3321                 :          1 :         info->tcpi_reord_seen = tp->reord_seen;
    3322                 :          1 :         info->tcpi_rcv_ooopack = tp->rcv_ooopack;
    3323                 :          1 :         info->tcpi_snd_wnd = tp->snd_wnd;
    3324                 :            :         unlock_sock_fast(sk, slow);
    3325                 :            : }
    3326                 :            : EXPORT_SYMBOL_GPL(tcp_get_info);
    3327                 :            : 
    3328                 :            : static size_t tcp_opt_stats_get_size(void)
    3329                 :            : {
    3330                 :            :         return
    3331                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BUSY */
    3332                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_RWND_LIMITED */
    3333                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_SNDBUF_LIMITED */
    3334                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_DATA_SEGS_OUT */
    3335                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_TOTAL_RETRANS */
    3336                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_PACING_RATE */
    3337                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_DELIVERY_RATE */
    3338                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_SND_CWND */
    3339                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_REORDERING */
    3340                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_MIN_RTT */
    3341                 :            :                 nla_total_size(sizeof(u8)) + /* TCP_NLA_RECUR_RETRANS */
    3342                 :            :                 nla_total_size(sizeof(u8)) + /* TCP_NLA_DELIVERY_RATE_APP_LMT */
    3343                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_SNDQ_SIZE */
    3344                 :            :                 nla_total_size(sizeof(u8)) + /* TCP_NLA_CA_STATE */
    3345                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_SND_SSTHRESH */
    3346                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_DELIVERED */
    3347                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_DELIVERED_CE */
    3348                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BYTES_SENT */
    3349                 :            :                 nla_total_size_64bit(sizeof(u64)) + /* TCP_NLA_BYTES_RETRANS */
    3350                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_DSACK_DUPS */
    3351                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_REORD_SEEN */
    3352                 :            :                 nla_total_size(sizeof(u32)) + /* TCP_NLA_SRTT */
    3353                 :            :                 0;
    3354                 :            : }
    3355                 :            : 
    3356                 :          0 : struct sk_buff *tcp_get_timestamping_opt_stats(const struct sock *sk)
    3357                 :            : {
    3358                 :            :         const struct tcp_sock *tp = tcp_sk(sk);
    3359                 :            :         struct sk_buff *stats;
    3360                 :            :         struct tcp_info info;
    3361                 :            :         unsigned long rate;
    3362                 :            :         u64 rate64;
    3363                 :            : 
    3364                 :            :         stats = alloc_skb(tcp_opt_stats_get_size(), GFP_ATOMIC);
    3365                 :          0 :         if (!stats)
    3366                 :            :                 return NULL;
    3367                 :            : 
    3368                 :          0 :         tcp_get_info_chrono_stats(tp, &info);
    3369                 :          0 :         nla_put_u64_64bit(stats, TCP_NLA_BUSY,
    3370                 :            :                           info.tcpi_busy_time, TCP_NLA_PAD);
    3371                 :          0 :         nla_put_u64_64bit(stats, TCP_NLA_RWND_LIMITED,
    3372                 :            :                           info.tcpi_rwnd_limited, TCP_NLA_PAD);
    3373                 :          0 :         nla_put_u64_64bit(stats, TCP_NLA_SNDBUF_LIMITED,
    3374                 :            :                           info.tcpi_sndbuf_limited, TCP_NLA_PAD);
    3375                 :          0 :         nla_put_u64_64bit(stats, TCP_NLA_DATA_SEGS_OUT,
    3376                 :          0 :                           tp->data_segs_out, TCP_NLA_PAD);
    3377                 :          0 :         nla_put_u64_64bit(stats, TCP_NLA_TOTAL_RETRANS,
    3378                 :          0 :                           tp->total_retrans, TCP_NLA_PAD);
    3379                 :            : 
    3380                 :            :         rate = READ_ONCE(sk->sk_pacing_rate);
    3381                 :          0 :         rate64 = (rate != ~0UL) ? rate : ~0ULL;
    3382                 :            :         nla_put_u64_64bit(stats, TCP_NLA_PACING_RATE, rate64, TCP_NLA_PAD);
    3383                 :            : 
    3384                 :          0 :         rate64 = tcp_compute_delivery_rate(tp);
    3385                 :            :         nla_put_u64_64bit(stats, TCP_NLA_DELIVERY_RATE, rate64, TCP_NLA_PAD);
    3386                 :            : 
    3387                 :          0 :         nla_put_u32(stats, TCP_NLA_SND_CWND, tp->snd_cwnd);
    3388                 :          0 :         nla_put_u32(stats, TCP_NLA_REORDERING, tp->reordering);
    3389                 :            :         nla_put_u32(stats, TCP_NLA_MIN_RTT, tcp_min_rtt(tp));
    3390                 :            : 
    3391                 :          0 :         nla_put_u8(stats, TCP_NLA_RECUR_RETRANS, inet_csk(sk)->icsk_retransmits);
    3392                 :          0 :         nla_put_u8(stats, TCP_NLA_DELIVERY_RATE_APP_LMT, !!tp->rate_app_limited);
    3393                 :          0 :         nla_put_u32(stats, TCP_NLA_SND_SSTHRESH, tp->snd_ssthresh);
    3394                 :          0 :         nla_put_u32(stats, TCP_NLA_DELIVERED, tp->delivered);
    3395                 :          0 :         nla_put_u32(stats, TCP_NLA_DELIVERED_CE, tp->delivered_ce);
    3396                 :            : 
    3397                 :          0 :         nla_put_u32(stats, TCP_NLA_SNDQ_SIZE, tp->write_seq - tp->snd_una);
    3398                 :          0 :         nla_put_u8(stats, TCP_NLA_CA_STATE, inet_csk(sk)->icsk_ca_state);
    3399                 :            : 
    3400                 :          0 :         nla_put_u64_64bit(stats, TCP_NLA_BYTES_SENT, tp->bytes_sent,
    3401                 :            :                           TCP_NLA_PAD);
    3402                 :          0 :         nla_put_u64_64bit(stats, TCP_NLA_BYTES_RETRANS, tp->bytes_retrans,
    3403                 :            :                           TCP_NLA_PAD);
    3404                 :          0 :         nla_put_u32(stats, TCP_NLA_DSACK_DUPS, tp->dsack_dups);
    3405                 :          0 :         nla_put_u32(stats, TCP_NLA_REORD_SEEN, tp->reord_seen);
    3406                 :          0 :         nla_put_u32(stats, TCP_NLA_SRTT, tp->srtt_us >> 3);
    3407                 :            : 
    3408                 :          0 :         return stats;
    3409                 :            : }
    3410                 :            : 
    3411                 :          1 : static int do_tcp_getsockopt(struct sock *sk, int level,
    3412                 :            :                 int optname, char __user *optval, int __user *optlen)
    3413                 :            : {
    3414                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    3415                 :            :         struct tcp_sock *tp = tcp_sk(sk);
    3416                 :            :         struct net *net = sock_net(sk);
    3417                 :            :         int val, len;
    3418                 :            : 
    3419                 :          1 :         if (get_user(len, optlen))
    3420                 :            :                 return -EFAULT;
    3421                 :            : 
    3422                 :          1 :         len = min_t(unsigned int, len, sizeof(int));
    3423                 :            : 
    3424                 :          1 :         if (len < 0)
    3425                 :            :                 return -EINVAL;
    3426                 :            : 
    3427                 :          1 :         switch (optname) {
    3428                 :            :         case TCP_MAXSEG:
    3429                 :          0 :                 val = tp->mss_cache;
    3430                 :          0 :                 if (!val && ((1 << sk->sk_state) & (TCPF_CLOSE | TCPF_LISTEN)))
    3431                 :          0 :                         val = tp->rx_opt.user_mss;
    3432                 :          0 :                 if (tp->repair)
    3433                 :          0 :                         val = tp->rx_opt.mss_clamp;
    3434                 :            :                 break;
    3435                 :            :         case TCP_NODELAY:
    3436                 :          0 :                 val = !!(tp->nonagle&TCP_NAGLE_OFF);
    3437                 :          0 :                 break;
    3438                 :            :         case TCP_CORK:
    3439                 :          0 :                 val = !!(tp->nonagle&TCP_NAGLE_CORK);
    3440                 :          0 :                 break;
    3441                 :            :         case TCP_KEEPIDLE:
    3442                 :          0 :                 val = keepalive_time_when(tp) / HZ;
    3443                 :          0 :                 break;
    3444                 :            :         case TCP_KEEPINTVL:
    3445                 :          0 :                 val = keepalive_intvl_when(tp) / HZ;
    3446                 :          0 :                 break;
    3447                 :            :         case TCP_KEEPCNT:
    3448                 :          0 :                 val = keepalive_probes(tp);
    3449                 :          0 :                 break;
    3450                 :            :         case TCP_SYNCNT:
    3451                 :          0 :                 val = icsk->icsk_syn_retries ? : net->ipv4.sysctl_tcp_syn_retries;
    3452                 :          0 :                 break;
    3453                 :            :         case TCP_LINGER2:
    3454                 :          0 :                 val = tp->linger2;
    3455                 :          0 :                 if (val >= 0)
    3456                 :          0 :                         val = (val ? : net->ipv4.sysctl_tcp_fin_timeout) / HZ;
    3457                 :            :                 break;
    3458                 :            :         case TCP_DEFER_ACCEPT:
    3459                 :          0 :                 val = retrans_to_secs(icsk->icsk_accept_queue.rskq_defer_accept,
    3460                 :            :                                       TCP_TIMEOUT_INIT / HZ, TCP_RTO_MAX / HZ);
    3461                 :          0 :                 break;
    3462                 :            :         case TCP_WINDOW_CLAMP:
    3463                 :          0 :                 val = tp->window_clamp;
    3464                 :          0 :                 break;
    3465                 :            :         case TCP_INFO: {
    3466                 :            :                 struct tcp_info info;
    3467                 :            : 
    3468                 :          1 :                 if (get_user(len, optlen))
    3469                 :            :                         return -EFAULT;
    3470                 :            : 
    3471                 :          1 :                 tcp_get_info(sk, &info);
    3472                 :            : 
    3473                 :          1 :                 len = min_t(unsigned int, len, sizeof(info));
    3474                 :          1 :                 if (put_user(len, optlen))
    3475                 :            :                         return -EFAULT;
    3476                 :          1 :                 if (copy_to_user(optval, &info, len))
    3477                 :            :                         return -EFAULT;
    3478                 :          1 :                 return 0;
    3479                 :            :         }
    3480                 :            :         case TCP_CC_INFO: {
    3481                 :            :                 const struct tcp_congestion_ops *ca_ops;
    3482                 :            :                 union tcp_cc_info info;
    3483                 :            :                 size_t sz = 0;
    3484                 :            :                 int attr;
    3485                 :            : 
    3486                 :          0 :                 if (get_user(len, optlen))
    3487                 :            :                         return -EFAULT;
    3488                 :            : 
    3489                 :          0 :                 ca_ops = icsk->icsk_ca_ops;
    3490                 :          0 :                 if (ca_ops && ca_ops->get_info)
    3491                 :          0 :                         sz = ca_ops->get_info(sk, ~0U, &attr, &info);
    3492                 :            : 
    3493                 :          0 :                 len = min_t(unsigned int, len, sz);
    3494                 :          0 :                 if (put_user(len, optlen))
    3495                 :            :                         return -EFAULT;
    3496                 :          0 :                 if (copy_to_user(optval, &info, len))
    3497                 :            :                         return -EFAULT;
    3498                 :          0 :                 return 0;
    3499                 :            :         }
    3500                 :            :         case TCP_QUICKACK:
    3501                 :          0 :                 val = !inet_csk_in_pingpong_mode(sk);
    3502                 :          0 :                 break;
    3503                 :            : 
    3504                 :            :         case TCP_CONGESTION:
    3505                 :          0 :                 if (get_user(len, optlen))
    3506                 :            :                         return -EFAULT;
    3507                 :          0 :                 len = min_t(unsigned int, len, TCP_CA_NAME_MAX);
    3508                 :          0 :                 if (put_user(len, optlen))
    3509                 :            :                         return -EFAULT;
    3510                 :          0 :                 if (copy_to_user(optval, icsk->icsk_ca_ops->name, len))
    3511                 :            :                         return -EFAULT;
    3512                 :          0 :                 return 0;
    3513                 :            : 
    3514                 :            :         case TCP_ULP:
    3515                 :          0 :                 if (get_user(len, optlen))
    3516                 :            :                         return -EFAULT;
    3517                 :          0 :                 len = min_t(unsigned int, len, TCP_ULP_NAME_MAX);
    3518                 :          0 :                 if (!icsk->icsk_ulp_ops) {
    3519                 :          0 :                         if (put_user(0, optlen))
    3520                 :            :                                 return -EFAULT;
    3521                 :          0 :                         return 0;
    3522                 :            :                 }
    3523                 :          0 :                 if (put_user(len, optlen))
    3524                 :            :                         return -EFAULT;
    3525                 :          0 :                 if (copy_to_user(optval, icsk->icsk_ulp_ops->name, len))
    3526                 :            :                         return -EFAULT;
    3527                 :          0 :                 return 0;
    3528                 :            : 
    3529                 :            :         case TCP_FASTOPEN_KEY: {
    3530                 :            :                 u64 key[TCP_FASTOPEN_KEY_BUF_LENGTH / sizeof(u64)];
    3531                 :            :                 unsigned int key_len;
    3532                 :            : 
    3533                 :          0 :                 if (get_user(len, optlen))
    3534                 :            :                         return -EFAULT;
    3535                 :            : 
    3536                 :          0 :                 key_len = tcp_fastopen_get_cipher(net, icsk, key) *
    3537                 :            :                                 TCP_FASTOPEN_KEY_LENGTH;
    3538                 :          0 :                 len = min_t(unsigned int, len, key_len);
    3539                 :          0 :                 if (put_user(len, optlen))
    3540                 :            :                         return -EFAULT;
    3541                 :          0 :                 if (copy_to_user(optval, key, len))
    3542                 :            :                         return -EFAULT;
    3543                 :          0 :                 return 0;
    3544                 :            :         }
    3545                 :            :         case TCP_THIN_LINEAR_TIMEOUTS:
    3546                 :          0 :                 val = tp->thin_lto;
    3547                 :          0 :                 break;
    3548                 :            : 
    3549                 :            :         case TCP_THIN_DUPACK:
    3550                 :          0 :                 val = 0;
    3551                 :          0 :                 break;
    3552                 :            : 
    3553                 :            :         case TCP_REPAIR:
    3554                 :          0 :                 val = tp->repair;
    3555                 :          0 :                 break;
    3556                 :            : 
    3557                 :            :         case TCP_REPAIR_QUEUE:
    3558                 :          0 :                 if (tp->repair)
    3559                 :          0 :                         val = tp->repair_queue;
    3560                 :            :                 else
    3561                 :            :                         return -EINVAL;
    3562                 :          0 :                 break;
    3563                 :            : 
    3564                 :            :         case TCP_REPAIR_WINDOW: {
    3565                 :            :                 struct tcp_repair_window opt;
    3566                 :            : 
    3567                 :          0 :                 if (get_user(len, optlen))
    3568                 :            :                         return -EFAULT;
    3569                 :            : 
    3570                 :          0 :                 if (len != sizeof(opt))
    3571                 :            :                         return -EINVAL;
    3572                 :            : 
    3573                 :          0 :                 if (!tp->repair)
    3574                 :            :                         return -EPERM;
    3575                 :            : 
    3576                 :          0 :                 opt.snd_wl1     = tp->snd_wl1;
    3577                 :          0 :                 opt.snd_wnd     = tp->snd_wnd;
    3578                 :          0 :                 opt.max_window  = tp->max_window;
    3579                 :          0 :                 opt.rcv_wnd     = tp->rcv_wnd;
    3580                 :          0 :                 opt.rcv_wup     = tp->rcv_wup;
    3581                 :            : 
    3582                 :          0 :                 if (copy_to_user(optval, &opt, len))
    3583                 :            :                         return -EFAULT;
    3584                 :          0 :                 return 0;
    3585                 :            :         }
    3586                 :            :         case TCP_QUEUE_SEQ:
    3587                 :          0 :                 if (tp->repair_queue == TCP_SEND_QUEUE)
    3588                 :          0 :                         val = tp->write_seq;
    3589                 :          0 :                 else if (tp->repair_queue == TCP_RECV_QUEUE)
    3590                 :          0 :                         val = tp->rcv_nxt;
    3591                 :            :                 else
    3592                 :            :                         return -EINVAL;
    3593                 :            :                 break;
    3594                 :            : 
    3595                 :            :         case TCP_USER_TIMEOUT:
    3596                 :          0 :                 val = icsk->icsk_user_timeout;
    3597                 :          0 :                 break;
    3598                 :            : 
    3599                 :            :         case TCP_FASTOPEN:
    3600                 :          0 :                 val = icsk->icsk_accept_queue.fastopenq.max_qlen;
    3601                 :          0 :                 break;
    3602                 :            : 
    3603                 :            :         case TCP_FASTOPEN_CONNECT:
    3604                 :          0 :                 val = tp->fastopen_connect;
    3605                 :          0 :                 break;
    3606                 :            : 
    3607                 :            :         case TCP_FASTOPEN_NO_COOKIE:
    3608                 :          0 :                 val = tp->fastopen_no_cookie;
    3609                 :          0 :                 break;
    3610                 :            : 
    3611                 :            :         case TCP_TX_DELAY:
    3612                 :          0 :                 val = tp->tcp_tx_delay;
    3613                 :          0 :                 break;
    3614                 :            : 
    3615                 :            :         case TCP_TIMESTAMP:
    3616                 :          0 :                 val = tcp_time_stamp_raw() + tp->tsoffset;
    3617                 :          0 :                 break;
    3618                 :            :         case TCP_NOTSENT_LOWAT:
    3619                 :          0 :                 val = tp->notsent_lowat;
    3620                 :          0 :                 break;
    3621                 :            :         case TCP_INQ:
    3622                 :          0 :                 val = tp->recvmsg_inq;
    3623                 :          0 :                 break;
    3624                 :            :         case TCP_SAVE_SYN:
    3625                 :          0 :                 val = tp->save_syn;
    3626                 :          0 :                 break;
    3627                 :            :         case TCP_SAVED_SYN: {
    3628                 :          0 :                 if (get_user(len, optlen))
    3629                 :            :                         return -EFAULT;
    3630                 :            : 
    3631                 :            :                 lock_sock(sk);
    3632                 :          0 :                 if (tp->saved_syn) {
    3633                 :          0 :                         if (len < tp->saved_syn[0]) {
    3634                 :          0 :                                 if (put_user(tp->saved_syn[0], optlen)) {
    3635                 :          0 :                                         release_sock(sk);
    3636                 :          0 :                                         return -EFAULT;
    3637                 :            :                                 }
    3638                 :          0 :                                 release_sock(sk);
    3639                 :          0 :                                 return -EINVAL;
    3640                 :            :                         }
    3641                 :          0 :                         len = tp->saved_syn[0];
    3642                 :          0 :                         if (put_user(len, optlen)) {
    3643                 :          0 :                                 release_sock(sk);
    3644                 :          0 :                                 return -EFAULT;
    3645                 :            :                         }
    3646                 :          0 :                         if (copy_to_user(optval, tp->saved_syn + 1, len)) {
    3647                 :          0 :                                 release_sock(sk);
    3648                 :          0 :                                 return -EFAULT;
    3649                 :            :                         }
    3650                 :            :                         tcp_saved_syn_free(tp);
    3651                 :          0 :                         release_sock(sk);
    3652                 :            :                 } else {
    3653                 :          0 :                         release_sock(sk);
    3654                 :            :                         len = 0;
    3655                 :          0 :                         if (put_user(len, optlen))
    3656                 :            :                                 return -EFAULT;
    3657                 :            :                 }
    3658                 :            :                 return 0;
    3659                 :            :         }
    3660                 :            : #ifdef CONFIG_MMU
    3661                 :            :         case TCP_ZEROCOPY_RECEIVE: {
    3662                 :            :                 struct tcp_zerocopy_receive zc;
    3663                 :            :                 int err;
    3664                 :            : 
    3665                 :          0 :                 if (get_user(len, optlen))
    3666                 :            :                         return -EFAULT;
    3667                 :          0 :                 if (len != sizeof(zc))
    3668                 :            :                         return -EINVAL;
    3669                 :          0 :                 if (copy_from_user(&zc, optval, len))
    3670                 :            :                         return -EFAULT;
    3671                 :            :                 lock_sock(sk);
    3672                 :          0 :                 err = tcp_zerocopy_receive(sk, &zc);
    3673                 :          0 :                 release_sock(sk);
    3674                 :          0 :                 if (!err && copy_to_user(optval, &zc, len))
    3675                 :            :                         err = -EFAULT;
    3676                 :          0 :                 return err;
    3677                 :            :         }
    3678                 :            : #endif
    3679                 :            :         default:
    3680                 :            :                 return -ENOPROTOOPT;
    3681                 :            :         }
    3682                 :            : 
    3683                 :          0 :         if (put_user(len, optlen))
    3684                 :            :                 return -EFAULT;
    3685                 :          0 :         if (copy_to_user(optval, &val, len))
    3686                 :            :                 return -EFAULT;
    3687                 :          0 :         return 0;
    3688                 :            : }
    3689                 :            : 
    3690                 :          1 : int tcp_getsockopt(struct sock *sk, int level, int optname, char __user *optval,
    3691                 :            :                    int __user *optlen)
    3692                 :            : {
    3693                 :            :         struct inet_connection_sock *icsk = inet_csk(sk);
    3694                 :            : 
    3695                 :          1 :         if (level != SOL_TCP)
    3696                 :          0 :                 return icsk->icsk_af_ops->getsockopt(sk, level, optname,
    3697                 :            :                                                      optval, optlen);
    3698                 :          1 :         return do_tcp_getsockopt(sk, level, optname, optval, optlen);
    3699                 :            : }
    3700                 :            : EXPORT_SYMBOL(tcp_getsockopt);
    3701                 :            : 
    3702                 :            : #ifdef CONFIG_COMPAT
    3703                 :            : int compat_tcp_getsockopt(struct sock *sk, int level, int optname,
    3704                 :            :                           char __user *optval, int __user *optlen)
    3705                 :            : {
    3706                 :            :         if (level != SOL_TCP)
    3707                 :            :                 return inet_csk_compat_getsockopt(sk, level, optname,
    3708                 :            :                                                   optval, optlen);
    3709                 :            :         return do_tcp_getsockopt(sk, level, optname, optval, optlen);
    3710                 :            : }
    3711                 :            : EXPORT_SYMBOL(compat_tcp_getsockopt);
    3712                 :            : #endif
    3713                 :            : 
    3714                 :            : #ifdef CONFIG_TCP_MD5SIG
    3715                 :            : static DEFINE_PER_CPU(struct tcp_md5sig_pool, tcp_md5sig_pool);
    3716                 :            : static DEFINE_MUTEX(tcp_md5sig_mutex);
    3717                 :            : static bool tcp_md5sig_pool_populated = false;
    3718                 :            : 
    3719                 :            : static void __tcp_alloc_md5sig_pool(void)
    3720                 :            : {
    3721                 :            :         struct crypto_ahash *hash;
    3722                 :            :         int cpu;
    3723                 :            : 
    3724                 :            :         hash = crypto_alloc_ahash("md5", 0, CRYPTO_ALG_ASYNC);
    3725                 :            :         if (IS_ERR(hash))
    3726                 :            :                 return;
    3727                 :            : 
    3728                 :            :         for_each_possible_cpu(cpu) {
    3729                 :            :                 void *scratch = per_cpu(tcp_md5sig_pool, cpu).scratch;
    3730                 :            :                 struct ahash_request *req;
    3731                 :            : 
    3732                 :            :                 if (!scratch) {
    3733                 :            :                         scratch = kmalloc_node(sizeof(union tcp_md5sum_block) +
    3734                 :            :                                                sizeof(struct tcphdr),
    3735                 :            :                                                GFP_KERNEL,
    3736                 :            :                                                cpu_to_node(cpu));
    3737                 :            :                         if (!scratch)
    3738                 :            :                                 return;
    3739                 :            :                         per_cpu(tcp_md5sig_pool, cpu).scratch = scratch;
    3740                 :            :                 }
    3741                 :            :                 if (per_cpu(tcp_md5sig_pool, cpu).md5_req)
    3742                 :            :                         continue;
    3743                 :            : 
    3744                 :            :                 req = ahash_request_alloc(hash, GFP_KERNEL);
    3745                 :            :                 if (!req)
    3746                 :            :                         return;
    3747                 :            : 
    3748                 :            :                 ahash_request_set_callback(req, 0, NULL, NULL);
    3749                 :            : 
    3750                 :            :                 per_cpu(tcp_md5sig_pool, cpu).md5_req = req;
    3751                 :            :         }
    3752                 :            :         /* before setting tcp_md5sig_pool_populated, we must commit all writes
    3753                 :            :          * to memory. See smp_rmb() in tcp_get_md5sig_pool()
    3754                 :            :          */
    3755                 :            :         smp_wmb();
    3756                 :            :         tcp_md5sig_pool_populated = true;
    3757                 :            : }
    3758                 :            : 
    3759                 :            : bool tcp_alloc_md5sig_pool(void)
    3760                 :            : {
    3761                 :            :         if (unlikely(!tcp_md5sig_pool_populated)) {
    3762                 :            :                 mutex_lock(&tcp_md5sig_mutex);
    3763                 :            : 
    3764                 :            :                 if (!tcp_md5sig_pool_populated) {
    3765                 :            :                         __tcp_alloc_md5sig_pool();
    3766                 :            :                         if (tcp_md5sig_pool_populated)
    3767                 :            :                                 static_branch_inc(&tcp_md5_needed);
    3768                 :            :                 }
    3769                 :            : 
    3770                 :            :                 mutex_unlock(&tcp_md5sig_mutex);
    3771                 :            :         }
    3772                 :            :         return tcp_md5sig_pool_populated;
    3773                 :            : }
    3774                 :            : EXPORT_SYMBOL(tcp_alloc_md5sig_pool);
    3775                 :            : 
    3776                 :            : 
    3777                 :            : /**
    3778                 :            :  *      tcp_get_md5sig_pool - get md5sig_pool for this user
    3779                 :            :  *
    3780                 :            :  *      We use percpu structure, so if we succeed, we exit with preemption
    3781                 :            :  *      and BH disabled, to make sure another thread or softirq handling
    3782                 :            :  *      wont try to get same context.
    3783                 :            :  */
    3784                 :            : struct tcp_md5sig_pool *tcp_get_md5sig_pool(void)
    3785                 :            : {
    3786                 :            :         local_bh_disable();
    3787                 :            : 
    3788                 :            :         if (tcp_md5sig_pool_populated) {
    3789                 :            :                 /* coupled with smp_wmb() in __tcp_alloc_md5sig_pool() */
    3790                 :            :                 smp_rmb();
    3791                 :            :                 return this_cpu_ptr(&tcp_md5sig_pool);
    3792                 :            :         }
    3793                 :            :         local_bh_enable();
    3794                 :            :         return NULL;
    3795                 :            : }
    3796                 :            : EXPORT_SYMBOL(tcp_get_md5sig_pool);
    3797                 :            : 
    3798                 :            : int tcp_md5_hash_skb_data(struct tcp_md5sig_pool *hp,
    3799                 :            :                           const struct sk_buff *skb, unsigned int header_len)
    3800                 :            : {
    3801                 :            :         struct scatterlist sg;
    3802                 :            :         const struct tcphdr *tp = tcp_hdr(skb);
    3803                 :            :         struct ahash_request *req = hp->md5_req;
    3804                 :            :         unsigned int i;
    3805                 :            :         const unsigned int head_data_len = skb_headlen(skb) > header_len ?
    3806                 :            :                                            skb_headlen(skb) - header_len : 0;
    3807                 :            :         const struct skb_shared_info *shi = skb_shinfo(skb);
    3808                 :            :         struct sk_buff *frag_iter;
    3809                 :            : 
    3810                 :            :         sg_init_table(&sg, 1);
    3811                 :            : 
    3812                 :            :         sg_set_buf(&sg, ((u8 *) tp) + header_len, head_data_len);
    3813                 :            :         ahash_request_set_crypt(req, &sg, NULL, head_data_len);
    3814                 :            :         if (crypto_ahash_update(req))
    3815                 :            :                 return 1;
    3816                 :            : 
    3817                 :            :         for (i = 0; i < shi->nr_frags; ++i) {
    3818                 :            :                 const skb_frag_t *f = &shi->frags[i];
    3819                 :            :                 unsigned int offset = skb_frag_off(f);
    3820                 :            :                 struct page *page = skb_frag_page(f) + (offset >> PAGE_SHIFT);
    3821                 :            : 
    3822                 :            :                 sg_set_page(&sg, page, skb_frag_size(f),
    3823                 :            :                             offset_in_page(offset));
    3824                 :            :                 ahash_request_set_crypt(req, &sg, NULL, skb_frag_size(f));
    3825                 :            :                 if (crypto_ahash_update(req))
    3826                 :            :                         return 1;
    3827                 :            :         }
    3828                 :            : 
    3829                 :            :         skb_walk_frags(skb, frag_iter)
    3830                 :            :                 if (tcp_md5_hash_skb_data(hp, frag_iter, 0))
    3831                 :            :                         return 1;
    3832                 :            : 
    3833                 :            :         return 0;
    3834                 :            : }
    3835                 :            : EXPORT_SYMBOL(tcp_md5_hash_skb_data);
    3836                 :            : 
    3837                 :            : int tcp_md5_hash_key(struct tcp_md5sig_pool *hp, const struct tcp_md5sig_key *key)
    3838                 :            : {
    3839                 :            :         u8 keylen = READ_ONCE(key->keylen); /* paired with WRITE_ONCE() in tcp_md5_do_add */
    3840                 :            :         struct scatterlist sg;
    3841                 :            : 
    3842                 :            :         sg_init_one(&sg, key->key, keylen);
    3843                 :            :         ahash_request_set_crypt(hp->md5_req, &sg, NULL, keylen);
    3844                 :            : 
    3845                 :            :         /* tcp_md5_do_add() might change key->key under us */
    3846                 :            :         return crypto_ahash_update(hp->md5_req);
    3847                 :            : }
    3848                 :            : EXPORT_SYMBOL(tcp_md5_hash_key);
    3849                 :            : 
    3850                 :            : #endif
    3851                 :            : 
    3852                 :          1 : void tcp_done(struct sock *sk)
    3853                 :            : {
    3854                 :            :         struct request_sock *req;
    3855                 :            : 
    3856                 :            :         /* We might be called with a new socket, after
    3857                 :            :          * inet_csk_prepare_forced_close() has been called
    3858                 :            :          * so we can not use lockdep_sock_is_held(sk)
    3859                 :            :          */
    3860                 :          1 :         req = rcu_dereference_protected(tcp_sk(sk)->fastopen_rsk, 1);
    3861                 :            : 
    3862                 :          1 :         if (sk->sk_state == TCP_SYN_SENT || sk->sk_state == TCP_SYN_RECV)
    3863                 :          0 :                 TCP_INC_STATS(sock_net(sk), TCP_MIB_ATTEMPTFAILS);
    3864                 :            : 
    3865                 :          1 :         tcp_set_state(sk, TCP_CLOSE);
    3866                 :          1 :         tcp_clear_xmit_timers(sk);
    3867                 :          1 :         if (req)
    3868                 :          0 :                 reqsk_fastopen_remove(sk, req, false);
    3869                 :            : 
    3870                 :          1 :         sk->sk_shutdown = SHUTDOWN_MASK;
    3871                 :            : 
    3872                 :          1 :         if (!sock_flag(sk, SOCK_DEAD))
    3873                 :          0 :                 sk->sk_state_change(sk);
    3874                 :            :         else
    3875                 :          1 :                 inet_csk_destroy_sock(sk);
    3876                 :          1 : }
    3877                 :            : EXPORT_SYMBOL_GPL(tcp_done);
    3878                 :            : 
    3879                 :          0 : int tcp_abort(struct sock *sk, int err)
    3880                 :            : {
    3881                 :          0 :         if (!sk_fullsock(sk)) {
    3882                 :          0 :                 if (sk->sk_state == TCP_NEW_SYN_RECV) {
    3883                 :            :                         struct request_sock *req = inet_reqsk(sk);
    3884                 :            : 
    3885                 :            :                         local_bh_disable();
    3886                 :          0 :                         inet_csk_reqsk_queue_drop(req->rsk_listener, req);
    3887                 :            :                         local_bh_enable();
    3888                 :          0 :                         return 0;
    3889                 :            :                 }
    3890                 :            :                 return -EOPNOTSUPP;
    3891                 :            :         }
    3892                 :            : 
    3893                 :            :         /* Don't race with userspace socket closes such as tcp_close. */
    3894                 :            :         lock_sock(sk);
    3895                 :            : 
    3896                 :          0 :         if (sk->sk_state == TCP_LISTEN) {
    3897                 :          0 :                 tcp_set_state(sk, TCP_CLOSE);
    3898                 :          0 :                 inet_csk_listen_stop(sk);
    3899                 :            :         }
    3900                 :            : 
    3901                 :            :         /* Don't race with BH socket closes such as inet_csk_listen_stop. */
    3902                 :            :         local_bh_disable();
    3903                 :            :         bh_lock_sock(sk);
    3904                 :            : 
    3905                 :          0 :         if (!sock_flag(sk, SOCK_DEAD)) {
    3906                 :          0 :                 sk->sk_err = err;
    3907                 :            :                 /* This barrier is coupled with smp_rmb() in tcp_poll() */
    3908                 :          0 :                 smp_wmb();
    3909                 :          0 :                 sk->sk_error_report(sk);
    3910                 :          0 :                 if (tcp_need_reset(sk->sk_state))
    3911                 :          0 :                         tcp_send_active_reset(sk, GFP_ATOMIC);
    3912                 :          0 :                 tcp_done(sk);
    3913                 :            :         }
    3914                 :            : 
    3915                 :            :         bh_unlock_sock(sk);
    3916                 :            :         local_bh_enable();
    3917                 :          0 :         tcp_write_queue_purge(sk);
    3918                 :          0 :         release_sock(sk);
    3919                 :          0 :         return 0;
    3920                 :            : }
    3921                 :            : EXPORT_SYMBOL_GPL(tcp_abort);
    3922                 :            : 
    3923                 :            : extern struct tcp_congestion_ops tcp_reno;
    3924                 :            : 
    3925                 :            : static __initdata unsigned long thash_entries;
    3926                 :          0 : static int __init set_thash_entries(char *str)
    3927                 :            : {
    3928                 :            :         ssize_t ret;
    3929                 :            : 
    3930                 :          0 :         if (!str)
    3931                 :            :                 return 0;
    3932                 :            : 
    3933                 :            :         ret = kstrtoul(str, 0, &thash_entries);
    3934                 :          0 :         if (ret)
    3935                 :            :                 return 0;
    3936                 :            : 
    3937                 :          0 :         return 1;
    3938                 :            : }
    3939                 :            : __setup("thash_entries=", set_thash_entries);
    3940                 :            : 
    3941                 :          3 : static void __init tcp_init_mem(void)
    3942                 :            : {
    3943                 :          3 :         unsigned long limit = nr_free_buffer_pages() / 16;
    3944                 :            : 
    3945                 :          3 :         limit = max(limit, 128UL);
    3946                 :          3 :         sysctl_tcp_mem[0] = limit / 4 * 3;              /* 4.68 % */
    3947                 :          3 :         sysctl_tcp_mem[1] = limit;                      /* 6.25 % */
    3948                 :          3 :         sysctl_tcp_mem[2] = sysctl_tcp_mem[0] * 2;      /* 9.37 % */
    3949                 :          3 : }
    3950                 :            : 
    3951                 :          3 : void __init tcp_init(void)
    3952                 :            : {
    3953                 :            :         int max_rshare, max_wshare, cnt;
    3954                 :            :         unsigned long limit;
    3955                 :            :         unsigned int i;
    3956                 :            : 
    3957                 :            :         BUILD_BUG_ON(TCP_MIN_SND_MSS <= MAX_TCP_OPTION_SPACE);
    3958                 :            :         BUILD_BUG_ON(sizeof(struct tcp_skb_cb) >
    3959                 :            :                      FIELD_SIZEOF(struct sk_buff, cb));
    3960                 :            : 
    3961                 :          3 :         percpu_counter_init(&tcp_sockets_allocated, 0, GFP_KERNEL);
    3962                 :          3 :         percpu_counter_init(&tcp_orphan_count, 0, GFP_KERNEL);
    3963                 :          3 :         inet_hashinfo_init(&tcp_hashinfo);
    3964                 :          3 :         inet_hashinfo2_init(&tcp_hashinfo, "tcp_listen_portaddr_hash",
    3965                 :            :                             thash_entries, 21,  /* one slot per 2 MB*/
    3966                 :            :                             0, 64 * 1024);
    3967                 :          3 :         tcp_hashinfo.bind_bucket_cachep =
    3968                 :          3 :                 kmem_cache_create("tcp_bind_bucket",
    3969                 :            :                                   sizeof(struct inet_bind_bucket), 0,
    3970                 :            :                                   SLAB_HWCACHE_ALIGN|SLAB_PANIC, NULL);
    3971                 :            : 
    3972                 :            :         /* Size and allocate the main established and bind bucket
    3973                 :            :          * hash tables.
    3974                 :            :          *
    3975                 :            :          * The methodology is similar to that of the buffer cache.
    3976                 :            :          */
    3977                 :          3 :         tcp_hashinfo.ehash =
    3978                 :          3 :                 alloc_large_system_hash("TCP established",
    3979                 :            :                                         sizeof(struct inet_ehash_bucket),
    3980                 :            :                                         thash_entries,
    3981                 :            :                                         17, /* one slot per 128 KB of memory */
    3982                 :            :                                         0,
    3983                 :            :                                         NULL,
    3984                 :            :                                         &tcp_hashinfo.ehash_mask,
    3985                 :            :                                         0,
    3986                 :          3 :                                         thash_entries ? 0 : 512 * 1024);
    3987                 :          3 :         for (i = 0; i <= tcp_hashinfo.ehash_mask; i++)
    3988                 :          3 :                 INIT_HLIST_NULLS_HEAD(&tcp_hashinfo.ehash[i].chain, i);
    3989                 :            : 
    3990                 :          3 :         if (inet_ehash_locks_alloc(&tcp_hashinfo))
    3991                 :          0 :                 panic("TCP: failed to alloc ehash_locks");
    3992                 :          3 :         tcp_hashinfo.bhash =
    3993                 :          3 :                 alloc_large_system_hash("TCP bind",
    3994                 :            :                                         sizeof(struct inet_bind_hashbucket),
    3995                 :          3 :                                         tcp_hashinfo.ehash_mask + 1,
    3996                 :            :                                         17, /* one slot per 128 KB of memory */
    3997                 :            :                                         0,
    3998                 :            :                                         &tcp_hashinfo.bhash_size,
    3999                 :            :                                         NULL,
    4000                 :            :                                         0,
    4001                 :            :                                         64 * 1024);
    4002                 :          3 :         tcp_hashinfo.bhash_size = 1U << tcp_hashinfo.bhash_size;
    4003                 :          3 :         for (i = 0; i < tcp_hashinfo.bhash_size; i++) {
    4004                 :          3 :                 spin_lock_init(&tcp_hashinfo.bhash[i].lock);
    4005                 :          3 :                 INIT_HLIST_HEAD(&tcp_hashinfo.bhash[i].chain);
    4006                 :            :         }
    4007                 :            : 
    4008                 :            : 
    4009                 :          3 :         cnt = tcp_hashinfo.ehash_mask + 1;
    4010                 :          3 :         sysctl_tcp_max_orphans = cnt / 2;
    4011                 :            : 
    4012                 :          3 :         tcp_init_mem();
    4013                 :            :         /* Set per-socket limits to no more than 1/128 the pressure threshold */
    4014                 :          3 :         limit = nr_free_buffer_pages() << (PAGE_SHIFT - 7);
    4015                 :          3 :         max_wshare = min(4UL*1024*1024, limit);
    4016                 :          3 :         max_rshare = min(6UL*1024*1024, limit);
    4017                 :            : 
    4018                 :          3 :         init_net.ipv4.sysctl_tcp_wmem[0] = SK_MEM_QUANTUM;
    4019                 :          3 :         init_net.ipv4.sysctl_tcp_wmem[1] = 16*1024;
    4020                 :          3 :         init_net.ipv4.sysctl_tcp_wmem[2] = max(64*1024, max_wshare);
    4021                 :            : 
    4022                 :          3 :         init_net.ipv4.sysctl_tcp_rmem[0] = SK_MEM_QUANTUM;
    4023                 :          3 :         init_net.ipv4.sysctl_tcp_rmem[1] = 131072;
    4024                 :          3 :         init_net.ipv4.sysctl_tcp_rmem[2] = max(131072, max_rshare);
    4025                 :            : 
    4026                 :          3 :         pr_info("Hash tables configured (established %u bind %u)\n",
    4027                 :            :                 tcp_hashinfo.ehash_mask + 1, tcp_hashinfo.bhash_size);
    4028                 :            : 
    4029                 :          3 :         tcp_v4_init();
    4030                 :          3 :         tcp_metrics_init();
    4031                 :          3 :         BUG_ON(tcp_register_congestion_control(&tcp_reno) != 0);
    4032                 :          3 :         tcp_tasklet_init();
    4033                 :          3 : }
    

Generated by: LCOV version 1.14