LCOV - code coverage report
Current view: top level - net/core - sock.c (source / functions) Hit Total Coverage
Test: Real Lines: 520 1204 43.2 %
Date: 2020-10-17 15:46:43 Functions: 0 126 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                 :            :  *              Generic socket support routines. Memory allocators, socket lock/release
       8                 :            :  *              handler for protocols to use and generic option handler.
       9                 :            :  *
      10                 :            :  * Authors:     Ross Biro
      11                 :            :  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
      12                 :            :  *              Florian La Roche, <flla@stud.uni-sb.de>
      13                 :            :  *              Alan Cox, <A.Cox@swansea.ac.uk>
      14                 :            :  *
      15                 :            :  * Fixes:
      16                 :            :  *              Alan Cox        :       Numerous verify_area() problems
      17                 :            :  *              Alan Cox        :       Connecting on a connecting socket
      18                 :            :  *                                      now returns an error for tcp.
      19                 :            :  *              Alan Cox        :       sock->protocol is set correctly.
      20                 :            :  *                                      and is not sometimes left as 0.
      21                 :            :  *              Alan Cox        :       connect handles icmp errors on a
      22                 :            :  *                                      connect properly. Unfortunately there
      23                 :            :  *                                      is a restart syscall nasty there. I
      24                 :            :  *                                      can't match BSD without hacking the C
      25                 :            :  *                                      library. Ideas urgently sought!
      26                 :            :  *              Alan Cox        :       Disallow bind() to addresses that are
      27                 :            :  *                                      not ours - especially broadcast ones!!
      28                 :            :  *              Alan Cox        :       Socket 1024 _IS_ ok for users. (fencepost)
      29                 :            :  *              Alan Cox        :       sock_wfree/sock_rfree don't destroy sockets,
      30                 :            :  *                                      instead they leave that for the DESTROY timer.
      31                 :            :  *              Alan Cox        :       Clean up error flag in accept
      32                 :            :  *              Alan Cox        :       TCP ack handling is buggy, the DESTROY timer
      33                 :            :  *                                      was buggy. Put a remove_sock() in the handler
      34                 :            :  *                                      for memory when we hit 0. Also altered the timer
      35                 :            :  *                                      code. The ACK stuff can wait and needs major
      36                 :            :  *                                      TCP layer surgery.
      37                 :            :  *              Alan Cox        :       Fixed TCP ack bug, removed remove sock
      38                 :            :  *                                      and fixed timer/inet_bh race.
      39                 :            :  *              Alan Cox        :       Added zapped flag for TCP
      40                 :            :  *              Alan Cox        :       Move kfree_skb into skbuff.c and tidied up surplus code
      41                 :            :  *              Alan Cox        :       for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
      42                 :            :  *              Alan Cox        :       kfree_s calls now are kfree_skbmem so we can track skb resources
      43                 :            :  *              Alan Cox        :       Supports socket option broadcast now as does udp. Packet and raw need fixing.
      44                 :            :  *              Alan Cox        :       Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
      45                 :            :  *              Rick Sladkey    :       Relaxed UDP rules for matching packets.
      46                 :            :  *              C.E.Hawkins     :       IFF_PROMISC/SIOCGHWADDR support
      47                 :            :  *      Pauline Middelink       :       identd support
      48                 :            :  *              Alan Cox        :       Fixed connect() taking signals I think.
      49                 :            :  *              Alan Cox        :       SO_LINGER supported
      50                 :            :  *              Alan Cox        :       Error reporting fixes
      51                 :            :  *              Anonymous       :       inet_create tidied up (sk->reuse setting)
      52                 :            :  *              Alan Cox        :       inet sockets don't set sk->type!
      53                 :            :  *              Alan Cox        :       Split socket option code
      54                 :            :  *              Alan Cox        :       Callbacks
      55                 :            :  *              Alan Cox        :       Nagle flag for Charles & Johannes stuff
      56                 :            :  *              Alex            :       Removed restriction on inet fioctl
      57                 :            :  *              Alan Cox        :       Splitting INET from NET core
      58                 :            :  *              Alan Cox        :       Fixed bogus SO_TYPE handling in getsockopt()
      59                 :            :  *              Adam Caldwell   :       Missing return in SO_DONTROUTE/SO_DEBUG code
      60                 :            :  *              Alan Cox        :       Split IP from generic code
      61                 :            :  *              Alan Cox        :       New kfree_skbmem()
      62                 :            :  *              Alan Cox        :       Make SO_DEBUG superuser only.
      63                 :            :  *              Alan Cox        :       Allow anyone to clear SO_DEBUG
      64                 :            :  *                                      (compatibility fix)
      65                 :            :  *              Alan Cox        :       Added optimistic memory grabbing for AF_UNIX throughput.
      66                 :            :  *              Alan Cox        :       Allocator for a socket is settable.
      67                 :            :  *              Alan Cox        :       SO_ERROR includes soft errors.
      68                 :            :  *              Alan Cox        :       Allow NULL arguments on some SO_ opts
      69                 :            :  *              Alan Cox        :       Generic socket allocation to make hooks
      70                 :            :  *                                      easier (suggested by Craig Metz).
      71                 :            :  *              Michael Pall    :       SO_ERROR returns positive errno again
      72                 :            :  *              Steve Whitehouse:       Added default destructor to free
      73                 :            :  *                                      protocol private data.
      74                 :            :  *              Steve Whitehouse:       Added various other default routines
      75                 :            :  *                                      common to several socket families.
      76                 :            :  *              Chris Evans     :       Call suser() check last on F_SETOWN
      77                 :            :  *              Jay Schulist    :       Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
      78                 :            :  *              Andi Kleen      :       Add sock_kmalloc()/sock_kfree_s()
      79                 :            :  *              Andi Kleen      :       Fix write_space callback
      80                 :            :  *              Chris Evans     :       Security fixes - signedness again
      81                 :            :  *              Arnaldo C. Melo :       cleanups, use skb_queue_purge
      82                 :            :  *
      83                 :            :  * To Fix:
      84                 :            :  */
      85                 :            : 
      86                 :            : #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
      87                 :            : 
      88                 :            : #include <asm/unaligned.h>
      89                 :            : #include <linux/capability.h>
      90                 :            : #include <linux/errno.h>
      91                 :            : #include <linux/errqueue.h>
      92                 :            : #include <linux/types.h>
      93                 :            : #include <linux/socket.h>
      94                 :            : #include <linux/in.h>
      95                 :            : #include <linux/kernel.h>
      96                 :            : #include <linux/module.h>
      97                 :            : #include <linux/proc_fs.h>
      98                 :            : #include <linux/seq_file.h>
      99                 :            : #include <linux/sched.h>
     100                 :            : #include <linux/sched/mm.h>
     101                 :            : #include <linux/timer.h>
     102                 :            : #include <linux/string.h>
     103                 :            : #include <linux/sockios.h>
     104                 :            : #include <linux/net.h>
     105                 :            : #include <linux/mm.h>
     106                 :            : #include <linux/slab.h>
     107                 :            : #include <linux/interrupt.h>
     108                 :            : #include <linux/poll.h>
     109                 :            : #include <linux/tcp.h>
     110                 :            : #include <linux/init.h>
     111                 :            : #include <linux/highmem.h>
     112                 :            : #include <linux/user_namespace.h>
     113                 :            : #include <linux/static_key.h>
     114                 :            : #include <linux/memcontrol.h>
     115                 :            : #include <linux/prefetch.h>
     116                 :            : 
     117                 :            : #include <linux/uaccess.h>
     118                 :            : 
     119                 :            : #include <linux/netdevice.h>
     120                 :            : #include <net/protocol.h>
     121                 :            : #include <linux/skbuff.h>
     122                 :            : #include <net/net_namespace.h>
     123                 :            : #include <net/request_sock.h>
     124                 :            : #include <net/sock.h>
     125                 :            : #include <linux/net_tstamp.h>
     126                 :            : #include <net/xfrm.h>
     127                 :            : #include <linux/ipsec.h>
     128                 :            : #include <net/cls_cgroup.h>
     129                 :            : #include <net/netprio_cgroup.h>
     130                 :            : #include <linux/sock_diag.h>
     131                 :            : 
     132                 :            : #include <linux/filter.h>
     133                 :            : #include <net/sock_reuseport.h>
     134                 :            : #include <net/bpf_sk_storage.h>
     135                 :            : 
     136                 :            : #include <trace/events/sock.h>
     137                 :            : 
     138                 :            : #include <net/tcp.h>
     139                 :            : #include <net/busy_poll.h>
     140                 :            : 
     141                 :            : static DEFINE_MUTEX(proto_list_mutex);
     142                 :            : static LIST_HEAD(proto_list);
     143                 :            : 
     144                 :            : static void sock_inuse_add(struct net *net, int val);
     145                 :            : 
     146                 :            : /**
     147                 :            :  * sk_ns_capable - General socket capability test
     148                 :            :  * @sk: Socket to use a capability on or through
     149                 :            :  * @user_ns: The user namespace of the capability to use
     150                 :            :  * @cap: The capability to use
     151                 :            :  *
     152                 :            :  * Test to see if the opener of the socket had when the socket was
     153                 :            :  * created and the current process has the capability @cap in the user
     154                 :            :  * namespace @user_ns.
     155                 :            :  */
     156                 :          0 : bool sk_ns_capable(const struct sock *sk,
     157                 :            :                    struct user_namespace *user_ns, int cap)
     158                 :            : {
     159                 :          0 :         return file_ns_capable(sk->sk_socket->file, user_ns, cap) &&
     160                 :          0 :                 ns_capable(user_ns, cap);
     161                 :            : }
     162                 :            : EXPORT_SYMBOL(sk_ns_capable);
     163                 :            : 
     164                 :            : /**
     165                 :            :  * sk_capable - Socket global capability test
     166                 :            :  * @sk: Socket to use a capability on or through
     167                 :            :  * @cap: The global capability to use
     168                 :            :  *
     169                 :            :  * Test to see if the opener of the socket had when the socket was
     170                 :            :  * created and the current process has the capability @cap in all user
     171                 :            :  * namespaces.
     172                 :            :  */
     173                 :          0 : bool sk_capable(const struct sock *sk, int cap)
     174                 :            : {
     175                 :          0 :         return sk_ns_capable(sk, &init_user_ns, cap);
     176                 :            : }
     177                 :            : EXPORT_SYMBOL(sk_capable);
     178                 :            : 
     179                 :            : /**
     180                 :            :  * sk_net_capable - Network namespace socket capability test
     181                 :            :  * @sk: Socket to use a capability on or through
     182                 :            :  * @cap: The capability to use
     183                 :            :  *
     184                 :            :  * Test to see if the opener of the socket had when the socket was created
     185                 :            :  * and the current process has the capability @cap over the network namespace
     186                 :            :  * the socket is a member of.
     187                 :            :  */
     188                 :          0 : bool sk_net_capable(const struct sock *sk, int cap)
     189                 :            : {
     190                 :          0 :         return sk_ns_capable(sk, sock_net(sk)->user_ns, cap);
     191                 :            : }
     192                 :            : EXPORT_SYMBOL(sk_net_capable);
     193                 :            : 
     194                 :            : /*
     195                 :            :  * Each address family might have different locking rules, so we have
     196                 :            :  * one slock key per address family and separate keys for internal and
     197                 :            :  * userspace sockets.
     198                 :            :  */
     199                 :            : static struct lock_class_key af_family_keys[AF_MAX];
     200                 :            : static struct lock_class_key af_family_kern_keys[AF_MAX];
     201                 :            : static struct lock_class_key af_family_slock_keys[AF_MAX];
     202                 :            : static struct lock_class_key af_family_kern_slock_keys[AF_MAX];
     203                 :            : 
     204                 :            : /*
     205                 :            :  * Make lock validator output more readable. (we pre-construct these
     206                 :            :  * strings build-time, so that runtime initialization of socket
     207                 :            :  * locks is fast):
     208                 :            :  */
     209                 :            : 
     210                 :            : #define _sock_locks(x)                                            \
     211                 :            :   x "AF_UNSPEC",      x "AF_UNIX"     ,     x "AF_INET"     , \
     212                 :            :   x "AF_AX25"  ,      x "AF_IPX"      ,     x "AF_APPLETALK", \
     213                 :            :   x "AF_NETROM",      x "AF_BRIDGE"   ,     x "AF_ATMPVC"   , \
     214                 :            :   x "AF_X25"   ,      x "AF_INET6"    ,     x "AF_ROSE"     , \
     215                 :            :   x "AF_DECnet",      x "AF_NETBEUI"  ,     x "AF_SECURITY" , \
     216                 :            :   x "AF_KEY"   ,      x "AF_NETLINK"  ,     x "AF_PACKET"   , \
     217                 :            :   x "AF_ASH"   ,      x "AF_ECONET"   ,     x "AF_ATMSVC"   , \
     218                 :            :   x "AF_RDS"   ,      x "AF_SNA"      ,     x "AF_IRDA"     , \
     219                 :            :   x "AF_PPPOX" ,      x "AF_WANPIPE"  ,     x "AF_LLC"      , \
     220                 :            :   x "27"       ,      x "28"          ,     x "AF_CAN"      , \
     221                 :            :   x "AF_TIPC"  ,      x "AF_BLUETOOTH",     x "IUCV"        , \
     222                 :            :   x "AF_RXRPC" ,      x "AF_ISDN"     ,     x "AF_PHONET"   , \
     223                 :            :   x "AF_IEEE802154",  x "AF_CAIF"   ,       x "AF_ALG"      , \
     224                 :            :   x "AF_NFC"   ,      x "AF_VSOCK"    ,     x "AF_KCM"      , \
     225                 :            :   x "AF_QIPCRTR",     x "AF_SMC"    ,       x "AF_XDP"    , \
     226                 :            :   x "AF_MAX"
     227                 :            : 
     228                 :            : static const char *const af_family_key_strings[AF_MAX+1] = {
     229                 :            :         _sock_locks("sk_lock-")
     230                 :            : };
     231                 :            : static const char *const af_family_slock_key_strings[AF_MAX+1] = {
     232                 :            :         _sock_locks("slock-")
     233                 :            : };
     234                 :            : static const char *const af_family_clock_key_strings[AF_MAX+1] = {
     235                 :            :         _sock_locks("clock-")
     236                 :            : };
     237                 :            : 
     238                 :            : static const char *const af_family_kern_key_strings[AF_MAX+1] = {
     239                 :            :         _sock_locks("k-sk_lock-")
     240                 :            : };
     241                 :            : static const char *const af_family_kern_slock_key_strings[AF_MAX+1] = {
     242                 :            :         _sock_locks("k-slock-")
     243                 :            : };
     244                 :            : static const char *const af_family_kern_clock_key_strings[AF_MAX+1] = {
     245                 :            :         _sock_locks("k-clock-")
     246                 :            : };
     247                 :            : static const char *const af_family_rlock_key_strings[AF_MAX+1] = {
     248                 :            :         _sock_locks("rlock-")
     249                 :            : };
     250                 :            : static const char *const af_family_wlock_key_strings[AF_MAX+1] = {
     251                 :            :         _sock_locks("wlock-")
     252                 :            : };
     253                 :            : static const char *const af_family_elock_key_strings[AF_MAX+1] = {
     254                 :            :         _sock_locks("elock-")
     255                 :            : };
     256                 :            : 
     257                 :            : /*
     258                 :            :  * sk_callback_lock and sk queues locking rules are per-address-family,
     259                 :            :  * so split the lock classes by using a per-AF key:
     260                 :            :  */
     261                 :            : static struct lock_class_key af_callback_keys[AF_MAX];
     262                 :            : static struct lock_class_key af_rlock_keys[AF_MAX];
     263                 :            : static struct lock_class_key af_wlock_keys[AF_MAX];
     264                 :            : static struct lock_class_key af_elock_keys[AF_MAX];
     265                 :            : static struct lock_class_key af_kern_callback_keys[AF_MAX];
     266                 :            : 
     267                 :            : /* Run time adjustable parameters. */
     268                 :            : __u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
     269                 :            : EXPORT_SYMBOL(sysctl_wmem_max);
     270                 :            : __u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
     271                 :            : EXPORT_SYMBOL(sysctl_rmem_max);
     272                 :            : __u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
     273                 :            : __u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
     274                 :            : 
     275                 :            : /* Maximal space eaten by iovec or ancillary data plus some space */
     276                 :            : int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
     277                 :            : EXPORT_SYMBOL(sysctl_optmem_max);
     278                 :            : 
     279                 :            : int sysctl_tstamp_allow_data __read_mostly = 1;
     280                 :            : 
     281                 :            : DEFINE_STATIC_KEY_FALSE(memalloc_socks_key);
     282                 :            : EXPORT_SYMBOL_GPL(memalloc_socks_key);
     283                 :            : 
     284                 :            : /**
     285                 :            :  * sk_set_memalloc - sets %SOCK_MEMALLOC
     286                 :            :  * @sk: socket to set it on
     287                 :            :  *
     288                 :            :  * Set %SOCK_MEMALLOC on a socket for access to emergency reserves.
     289                 :            :  * It's the responsibility of the admin to adjust min_free_kbytes
     290                 :            :  * to meet the requirements
     291                 :            :  */
     292                 :          0 : void sk_set_memalloc(struct sock *sk)
     293                 :            : {
     294                 :            :         sock_set_flag(sk, SOCK_MEMALLOC);
     295                 :          0 :         sk->sk_allocation |= __GFP_MEMALLOC;
     296                 :          0 :         static_branch_inc(&memalloc_socks_key);
     297                 :          0 : }
     298                 :            : EXPORT_SYMBOL_GPL(sk_set_memalloc);
     299                 :            : 
     300                 :          0 : void sk_clear_memalloc(struct sock *sk)
     301                 :            : {
     302                 :            :         sock_reset_flag(sk, SOCK_MEMALLOC);
     303                 :          0 :         sk->sk_allocation &= ~__GFP_MEMALLOC;
     304                 :          0 :         static_branch_dec(&memalloc_socks_key);
     305                 :            : 
     306                 :            :         /*
     307                 :            :          * SOCK_MEMALLOC is allowed to ignore rmem limits to ensure forward
     308                 :            :          * progress of swapping. SOCK_MEMALLOC may be cleared while
     309                 :            :          * it has rmem allocations due to the last swapfile being deactivated
     310                 :            :          * but there is a risk that the socket is unusable due to exceeding
     311                 :            :          * the rmem limits. Reclaim the reserves and obey rmem limits again.
     312                 :            :          */
     313                 :          0 :         sk_mem_reclaim(sk);
     314                 :          0 : }
     315                 :            : EXPORT_SYMBOL_GPL(sk_clear_memalloc);
     316                 :            : 
     317                 :          0 : int __sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
     318                 :            : {
     319                 :            :         int ret;
     320                 :            :         unsigned int noreclaim_flag;
     321                 :            : 
     322                 :            :         /* these should have been dropped before queueing */
     323                 :          0 :         BUG_ON(!sock_flag(sk, SOCK_MEMALLOC));
     324                 :            : 
     325                 :            :         noreclaim_flag = memalloc_noreclaim_save();
     326                 :          0 :         ret = sk->sk_backlog_rcv(sk, skb);
     327                 :            :         memalloc_noreclaim_restore(noreclaim_flag);
     328                 :            : 
     329                 :          0 :         return ret;
     330                 :            : }
     331                 :            : EXPORT_SYMBOL(__sk_backlog_rcv);
     332                 :            : 
     333                 :            : static int sock_get_timeout(long timeo, void *optval, bool old_timeval)
     334                 :            : {
     335                 :            :         struct __kernel_sock_timeval tv;
     336                 :            :         int size;
     337                 :            : 
     338                 :          0 :         if (timeo == MAX_SCHEDULE_TIMEOUT) {
     339                 :            :                 tv.tv_sec = 0;
     340                 :            :                 tv.tv_usec = 0;
     341                 :            :         } else {
     342                 :          0 :                 tv.tv_sec = timeo / HZ;
     343                 :          0 :                 tv.tv_usec = ((timeo % HZ) * USEC_PER_SEC) / HZ;
     344                 :            :         }
     345                 :            : 
     346                 :            :         if (old_timeval && in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
     347                 :            :                 struct old_timeval32 tv32 = { tv.tv_sec, tv.tv_usec };
     348                 :            :                 *(struct old_timeval32 *)optval = tv32;
     349                 :            :                 return sizeof(tv32);
     350                 :            :         }
     351                 :            : 
     352                 :          0 :         if (old_timeval) {
     353                 :            :                 struct __kernel_old_timeval old_tv;
     354                 :          0 :                 old_tv.tv_sec = tv.tv_sec;
     355                 :          0 :                 old_tv.tv_usec = tv.tv_usec;
     356                 :          0 :                 *(struct __kernel_old_timeval *)optval = old_tv;
     357                 :            :                 size = sizeof(old_tv);
     358                 :            :         } else {
     359                 :          0 :                 *(struct __kernel_sock_timeval *)optval = tv;
     360                 :            :                 size = sizeof(tv);
     361                 :            :         }
     362                 :            : 
     363                 :            :         return size;
     364                 :            : }
     365                 :            : 
     366                 :          3 : static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen, bool old_timeval)
     367                 :            : {
     368                 :            :         struct __kernel_sock_timeval tv;
     369                 :            : 
     370                 :            :         if (old_timeval && in_compat_syscall() && !COMPAT_USE_64BIT_TIME) {
     371                 :            :                 struct old_timeval32 tv32;
     372                 :            : 
     373                 :            :                 if (optlen < sizeof(tv32))
     374                 :            :                         return -EINVAL;
     375                 :            : 
     376                 :            :                 if (copy_from_user(&tv32, optval, sizeof(tv32)))
     377                 :            :                         return -EFAULT;
     378                 :            :                 tv.tv_sec = tv32.tv_sec;
     379                 :            :                 tv.tv_usec = tv32.tv_usec;
     380                 :          3 :         } else if (old_timeval) {
     381                 :            :                 struct __kernel_old_timeval old_tv;
     382                 :            : 
     383                 :          3 :                 if (optlen < sizeof(old_tv))
     384                 :          0 :                         return -EINVAL;
     385                 :          3 :                 if (copy_from_user(&old_tv, optval, sizeof(old_tv)))
     386                 :            :                         return -EFAULT;
     387                 :          3 :                 tv.tv_sec = old_tv.tv_sec;
     388                 :          3 :                 tv.tv_usec = old_tv.tv_usec;
     389                 :            :         } else {
     390                 :          0 :                 if (optlen < sizeof(tv))
     391                 :            :                         return -EINVAL;
     392                 :          0 :                 if (copy_from_user(&tv, optval, sizeof(tv)))
     393                 :            :                         return -EFAULT;
     394                 :            :         }
     395                 :          3 :         if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
     396                 :            :                 return -EDOM;
     397                 :            : 
     398                 :          3 :         if (tv.tv_sec < 0) {
     399                 :            :                 static int warned __read_mostly;
     400                 :            : 
     401                 :          0 :                 *timeo_p = 0;
     402                 :          0 :                 if (warned < 10 && net_ratelimit()) {
     403                 :          0 :                         warned++;
     404                 :          0 :                         pr_info("%s: `%s' (pid %d) tries to set negative timeout\n",
     405                 :            :                                 __func__, current->comm, task_pid_nr(current));
     406                 :            :                 }
     407                 :            :                 return 0;
     408                 :            :         }
     409                 :          3 :         *timeo_p = MAX_SCHEDULE_TIMEOUT;
     410                 :          3 :         if (tv.tv_sec == 0 && tv.tv_usec == 0)
     411                 :            :                 return 0;
     412                 :          3 :         if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT / HZ - 1))
     413                 :          3 :                 *timeo_p = tv.tv_sec * HZ + DIV_ROUND_UP((unsigned long)tv.tv_usec, USEC_PER_SEC / HZ);
     414                 :            :         return 0;
     415                 :            : }
     416                 :            : 
     417                 :          0 : static void sock_warn_obsolete_bsdism(const char *name)
     418                 :            : {
     419                 :            :         static int warned;
     420                 :            :         static char warncomm[TASK_COMM_LEN];
     421                 :          0 :         if (strcmp(warncomm, current->comm) && warned < 5) {
     422                 :          0 :                 strcpy(warncomm,  current->comm);
     423                 :          0 :                 pr_warn("process `%s' is using obsolete %s SO_BSDCOMPAT\n",
     424                 :            :                         warncomm, name);
     425                 :          0 :                 warned++;
     426                 :            :         }
     427                 :          0 : }
     428                 :            : 
     429                 :            : static bool sock_needs_netstamp(const struct sock *sk)
     430                 :            : {
     431                 :          3 :         switch (sk->sk_family) {
     432                 :            :         case AF_UNSPEC:
     433                 :            :         case AF_UNIX:
     434                 :            :                 return false;
     435                 :            :         default:
     436                 :            :                 return true;
     437                 :            :         }
     438                 :            : }
     439                 :            : 
     440                 :          3 : static void sock_disable_timestamp(struct sock *sk, unsigned long flags)
     441                 :            : {
     442                 :          3 :         if (sk->sk_flags & flags) {
     443                 :          3 :                 sk->sk_flags &= ~flags;
     444                 :          3 :                 if (sock_needs_netstamp(sk) &&
     445                 :          3 :                     !(sk->sk_flags & SK_FLAGS_TIMESTAMP))
     446                 :          3 :                         net_disable_timestamp();
     447                 :            :         }
     448                 :          3 : }
     449                 :            : 
     450                 :            : 
     451                 :          1 : int __sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
     452                 :            : {
     453                 :            :         unsigned long flags;
     454                 :          1 :         struct sk_buff_head *list = &sk->sk_receive_queue;
     455                 :            : 
     456                 :          1 :         if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf) {
     457                 :          0 :                 atomic_inc(&sk->sk_drops);
     458                 :          0 :                 trace_sock_rcvqueue_full(sk, skb);
     459                 :          0 :                 return -ENOMEM;
     460                 :            :         }
     461                 :            : 
     462                 :          1 :         if (!sk_rmem_schedule(sk, skb, skb->truesize)) {
     463                 :          0 :                 atomic_inc(&sk->sk_drops);
     464                 :          0 :                 return -ENOBUFS;
     465                 :            :         }
     466                 :            : 
     467                 :          1 :         skb->dev = NULL;
     468                 :          1 :         skb_set_owner_r(skb, sk);
     469                 :            : 
     470                 :            :         /* we escape from rcu protected region, make sure we dont leak
     471                 :            :          * a norefcounted dst
     472                 :            :          */
     473                 :          1 :         skb_dst_force(skb);
     474                 :            : 
     475                 :          1 :         spin_lock_irqsave(&list->lock, flags);
     476                 :            :         sock_skb_set_dropcount(sk, skb);
     477                 :            :         __skb_queue_tail(list, skb);
     478                 :            :         spin_unlock_irqrestore(&list->lock, flags);
     479                 :            : 
     480                 :          1 :         if (!sock_flag(sk, SOCK_DEAD))
     481                 :          1 :                 sk->sk_data_ready(sk);
     482                 :            :         return 0;
     483                 :            : }
     484                 :            : EXPORT_SYMBOL(__sock_queue_rcv_skb);
     485                 :            : 
     486                 :          1 : int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
     487                 :            : {
     488                 :            :         int err;
     489                 :            : 
     490                 :            :         err = sk_filter(sk, skb);
     491                 :          1 :         if (err)
     492                 :            :                 return err;
     493                 :            : 
     494                 :          1 :         return __sock_queue_rcv_skb(sk, skb);
     495                 :            : }
     496                 :            : EXPORT_SYMBOL(sock_queue_rcv_skb);
     497                 :            : 
     498                 :          0 : int __sk_receive_skb(struct sock *sk, struct sk_buff *skb,
     499                 :            :                      const int nested, unsigned int trim_cap, bool refcounted)
     500                 :            : {
     501                 :            :         int rc = NET_RX_SUCCESS;
     502                 :            : 
     503                 :          0 :         if (sk_filter_trim_cap(sk, skb, trim_cap))
     504                 :            :                 goto discard_and_relse;
     505                 :            : 
     506                 :          0 :         skb->dev = NULL;
     507                 :            : 
     508                 :          0 :         if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
     509                 :          0 :                 atomic_inc(&sk->sk_drops);
     510                 :            :                 goto discard_and_relse;
     511                 :            :         }
     512                 :          0 :         if (nested)
     513                 :          0 :                 bh_lock_sock_nested(sk);
     514                 :            :         else
     515                 :            :                 bh_lock_sock(sk);
     516                 :          0 :         if (!sock_owned_by_user(sk)) {
     517                 :            :                 /*
     518                 :            :                  * trylock + unlock semantics:
     519                 :            :                  */
     520                 :            :                 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
     521                 :            : 
     522                 :          0 :                 rc = sk_backlog_rcv(sk, skb);
     523                 :            : 
     524                 :            :                 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
     525                 :          0 :         } else if (sk_add_backlog(sk, skb, READ_ONCE(sk->sk_rcvbuf))) {
     526                 :            :                 bh_unlock_sock(sk);
     527                 :          0 :                 atomic_inc(&sk->sk_drops);
     528                 :            :                 goto discard_and_relse;
     529                 :            :         }
     530                 :            : 
     531                 :            :         bh_unlock_sock(sk);
     532                 :            : out:
     533                 :          0 :         if (refcounted)
     534                 :          0 :                 sock_put(sk);
     535                 :          0 :         return rc;
     536                 :            : discard_and_relse:
     537                 :          0 :         kfree_skb(skb);
     538                 :          0 :         goto out;
     539                 :            : }
     540                 :            : EXPORT_SYMBOL(__sk_receive_skb);
     541                 :            : 
     542                 :          1 : struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
     543                 :            : {
     544                 :            :         struct dst_entry *dst = __sk_dst_get(sk);
     545                 :            : 
     546                 :          1 :         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
     547                 :            :                 sk_tx_queue_clear(sk);
     548                 :          0 :                 sk->sk_dst_pending_confirm = 0;
     549                 :            :                 RCU_INIT_POINTER(sk->sk_dst_cache, NULL);
     550                 :          0 :                 dst_release(dst);
     551                 :          0 :                 return NULL;
     552                 :            :         }
     553                 :            : 
     554                 :          1 :         return dst;
     555                 :            : }
     556                 :            : EXPORT_SYMBOL(__sk_dst_check);
     557                 :            : 
     558                 :          3 : struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
     559                 :            : {
     560                 :          3 :         struct dst_entry *dst = sk_dst_get(sk);
     561                 :            : 
     562                 :          3 :         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
     563                 :            :                 sk_dst_reset(sk);
     564                 :          0 :                 dst_release(dst);
     565                 :          0 :                 return NULL;
     566                 :            :         }
     567                 :            : 
     568                 :          3 :         return dst;
     569                 :            : }
     570                 :            : EXPORT_SYMBOL(sk_dst_check);
     571                 :            : 
     572                 :          0 : static int sock_setbindtodevice_locked(struct sock *sk, int ifindex)
     573                 :            : {
     574                 :            :         int ret = -ENOPROTOOPT;
     575                 :            : #ifdef CONFIG_NETDEVICES
     576                 :            :         struct net *net = sock_net(sk);
     577                 :            : 
     578                 :            :         /* Sorry... */
     579                 :            :         ret = -EPERM;
     580                 :          0 :         if (!ns_capable(net->user_ns, CAP_NET_RAW))
     581                 :            :                 goto out;
     582                 :            : 
     583                 :            :         ret = -EINVAL;
     584                 :          0 :         if (ifindex < 0)
     585                 :            :                 goto out;
     586                 :            : 
     587                 :          0 :         sk->sk_bound_dev_if = ifindex;
     588                 :          0 :         if (sk->sk_prot->rehash)
     589                 :          0 :                 sk->sk_prot->rehash(sk);
     590                 :            :         sk_dst_reset(sk);
     591                 :            : 
     592                 :            :         ret = 0;
     593                 :            : 
     594                 :            : out:
     595                 :            : #endif
     596                 :            : 
     597                 :          0 :         return ret;
     598                 :            : }
     599                 :            : 
     600                 :          0 : static int sock_setbindtodevice(struct sock *sk, char __user *optval,
     601                 :            :                                 int optlen)
     602                 :            : {
     603                 :            :         int ret = -ENOPROTOOPT;
     604                 :            : #ifdef CONFIG_NETDEVICES
     605                 :            :         struct net *net = sock_net(sk);
     606                 :            :         char devname[IFNAMSIZ];
     607                 :            :         int index;
     608                 :            : 
     609                 :            :         ret = -EINVAL;
     610                 :          0 :         if (optlen < 0)
     611                 :            :                 goto out;
     612                 :            : 
     613                 :            :         /* Bind this socket to a particular device like "eth0",
     614                 :            :          * as specified in the passed interface name. If the
     615                 :            :          * name is "" or the option length is zero the socket
     616                 :            :          * is not bound.
     617                 :            :          */
     618                 :          0 :         if (optlen > IFNAMSIZ - 1)
     619                 :            :                 optlen = IFNAMSIZ - 1;
     620                 :          0 :         memset(devname, 0, sizeof(devname));
     621                 :            : 
     622                 :            :         ret = -EFAULT;
     623                 :          0 :         if (copy_from_user(devname, optval, optlen))
     624                 :            :                 goto out;
     625                 :            : 
     626                 :            :         index = 0;
     627                 :          0 :         if (devname[0] != '\0') {
     628                 :            :                 struct net_device *dev;
     629                 :            : 
     630                 :            :                 rcu_read_lock();
     631                 :          0 :                 dev = dev_get_by_name_rcu(net, devname);
     632                 :          0 :                 if (dev)
     633                 :          0 :                         index = dev->ifindex;
     634                 :            :                 rcu_read_unlock();
     635                 :            :                 ret = -ENODEV;
     636                 :          0 :                 if (!dev)
     637                 :            :                         goto out;
     638                 :            :         }
     639                 :            : 
     640                 :            :         lock_sock(sk);
     641                 :          0 :         ret = sock_setbindtodevice_locked(sk, index);
     642                 :          0 :         release_sock(sk);
     643                 :            : 
     644                 :            : out:
     645                 :            : #endif
     646                 :            : 
     647                 :          0 :         return ret;
     648                 :            : }
     649                 :            : 
     650                 :          0 : static int sock_getbindtodevice(struct sock *sk, char __user *optval,
     651                 :            :                                 int __user *optlen, int len)
     652                 :            : {
     653                 :            :         int ret = -ENOPROTOOPT;
     654                 :            : #ifdef CONFIG_NETDEVICES
     655                 :            :         struct net *net = sock_net(sk);
     656                 :            :         char devname[IFNAMSIZ];
     657                 :            : 
     658                 :          0 :         if (sk->sk_bound_dev_if == 0) {
     659                 :            :                 len = 0;
     660                 :            :                 goto zero;
     661                 :            :         }
     662                 :            : 
     663                 :            :         ret = -EINVAL;
     664                 :          0 :         if (len < IFNAMSIZ)
     665                 :            :                 goto out;
     666                 :            : 
     667                 :          0 :         ret = netdev_get_name(net, devname, sk->sk_bound_dev_if);
     668                 :          0 :         if (ret)
     669                 :            :                 goto out;
     670                 :            : 
     671                 :          0 :         len = strlen(devname) + 1;
     672                 :            : 
     673                 :            :         ret = -EFAULT;
     674                 :          0 :         if (copy_to_user(optval, devname, len))
     675                 :            :                 goto out;
     676                 :            : 
     677                 :            : zero:
     678                 :            :         ret = -EFAULT;
     679                 :          0 :         if (put_user(len, optlen))
     680                 :            :                 goto out;
     681                 :            : 
     682                 :            :         ret = 0;
     683                 :            : 
     684                 :            : out:
     685                 :            : #endif
     686                 :            : 
     687                 :          0 :         return ret;
     688                 :            : }
     689                 :            : 
     690                 :          1 : static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
     691                 :            : {
     692                 :          1 :         if (valbool)
     693                 :            :                 sock_set_flag(sk, bit);
     694                 :            :         else
     695                 :            :                 sock_reset_flag(sk, bit);
     696                 :          1 : }
     697                 :            : 
     698                 :          3 : bool sk_mc_loop(struct sock *sk)
     699                 :            : {
     700                 :          3 :         if (dev_recursion_level())
     701                 :            :                 return false;
     702                 :          3 :         if (!sk)
     703                 :            :                 return true;
     704                 :          3 :         switch (sk->sk_family) {
     705                 :            :         case AF_INET:
     706                 :          3 :                 return inet_sk(sk)->mc_loop;
     707                 :            : #if IS_ENABLED(CONFIG_IPV6)
     708                 :            :         case AF_INET6:
     709                 :          3 :                 return inet6_sk(sk)->mc_loop;
     710                 :            : #endif
     711                 :            :         }
     712                 :          0 :         WARN_ON_ONCE(1);
     713                 :            :         return true;
     714                 :            : }
     715                 :            : EXPORT_SYMBOL(sk_mc_loop);
     716                 :            : 
     717                 :            : /*
     718                 :            :  *      This is meant for all protocols to use and covers goings on
     719                 :            :  *      at the socket level. Everything here is generic.
     720                 :            :  */
     721                 :            : 
     722                 :          3 : int sock_setsockopt(struct socket *sock, int level, int optname,
     723                 :            :                     char __user *optval, unsigned int optlen)
     724                 :            : {
     725                 :            :         struct sock_txtime sk_txtime;
     726                 :          3 :         struct sock *sk = sock->sk;
     727                 :            :         int val;
     728                 :            :         int valbool;
     729                 :            :         struct linger ling;
     730                 :            :         int ret = 0;
     731                 :            : 
     732                 :            :         /*
     733                 :            :          *      Options without arguments
     734                 :            :          */
     735                 :            : 
     736                 :          3 :         if (optname == SO_BINDTODEVICE)
     737                 :          0 :                 return sock_setbindtodevice(sk, optval, optlen);
     738                 :            : 
     739                 :          3 :         if (optlen < sizeof(int))
     740                 :            :                 return -EINVAL;
     741                 :            : 
     742                 :          3 :         if (get_user(val, (int __user *)optval))
     743                 :            :                 return -EFAULT;
     744                 :            : 
     745                 :          3 :         valbool = val ? 1 : 0;
     746                 :            : 
     747                 :            :         lock_sock(sk);
     748                 :            : 
     749                 :          3 :         switch (optname) {
     750                 :            :         case SO_DEBUG:
     751                 :          0 :                 if (val && !capable(CAP_NET_ADMIN))
     752                 :            :                         ret = -EACCES;
     753                 :            :                 else
     754                 :          0 :                         sock_valbool_flag(sk, SOCK_DBG, valbool);
     755                 :            :                 break;
     756                 :            :         case SO_REUSEADDR:
     757                 :          3 :                 sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);
     758                 :          3 :                 break;
     759                 :            :         case SO_REUSEPORT:
     760                 :          3 :                 sk->sk_reuseport = valbool;
     761                 :          3 :                 break;
     762                 :            :         case SO_TYPE:
     763                 :            :         case SO_PROTOCOL:
     764                 :            :         case SO_DOMAIN:
     765                 :            :         case SO_ERROR:
     766                 :            :                 ret = -ENOPROTOOPT;
     767                 :            :                 break;
     768                 :            :         case SO_DONTROUTE:
     769                 :          0 :                 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
     770                 :            :                 sk_dst_reset(sk);
     771                 :            :                 break;
     772                 :            :         case SO_BROADCAST:
     773                 :          1 :                 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
     774                 :          1 :                 break;
     775                 :            :         case SO_SNDBUF:
     776                 :            :                 /* Don't error on this BSD doesn't and if you think
     777                 :            :                  * about it this is right. Otherwise apps have to
     778                 :            :                  * play 'guess the biggest size' games. RCVBUF/SNDBUF
     779                 :            :                  * are treated in BSD as hints
     780                 :            :                  */
     781                 :          3 :                 val = min_t(u32, val, sysctl_wmem_max);
     782                 :            : set_sndbuf:
     783                 :            :                 /* Ensure val * 2 fits into an int, to prevent max_t()
     784                 :            :                  * from treating it as a negative value.
     785                 :            :                  */
     786                 :          3 :                 val = min_t(int, val, INT_MAX / 2);
     787                 :          3 :                 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
     788                 :          3 :                 WRITE_ONCE(sk->sk_sndbuf,
     789                 :            :                            max_t(int, val * 2, SOCK_MIN_SNDBUF));
     790                 :            :                 /* Wake up sending tasks if we upped the value. */
     791                 :          3 :                 sk->sk_write_space(sk);
     792                 :          3 :                 break;
     793                 :            : 
     794                 :            :         case SO_SNDBUFFORCE:
     795                 :          3 :                 if (!capable(CAP_NET_ADMIN)) {
     796                 :            :                         ret = -EPERM;
     797                 :            :                         break;
     798                 :            :                 }
     799                 :            : 
     800                 :            :                 /* No negative values (to prevent underflow, as val will be
     801                 :            :                  * multiplied by 2).
     802                 :            :                  */
     803                 :          3 :                 if (val < 0)
     804                 :            :                         val = 0;
     805                 :            :                 goto set_sndbuf;
     806                 :            : 
     807                 :            :         case SO_RCVBUF:
     808                 :            :                 /* Don't error on this BSD doesn't and if you think
     809                 :            :                  * about it this is right. Otherwise apps have to
     810                 :            :                  * play 'guess the biggest size' games. RCVBUF/SNDBUF
     811                 :            :                  * are treated in BSD as hints
     812                 :            :                  */
     813                 :          3 :                 val = min_t(u32, val, sysctl_rmem_max);
     814                 :            : set_rcvbuf:
     815                 :            :                 /* Ensure val * 2 fits into an int, to prevent max_t()
     816                 :            :                  * from treating it as a negative value.
     817                 :            :                  */
     818                 :          3 :                 val = min_t(int, val, INT_MAX / 2);
     819                 :          3 :                 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
     820                 :            :                 /*
     821                 :            :                  * We double it on the way in to account for
     822                 :            :                  * "struct sk_buff" etc. overhead.   Applications
     823                 :            :                  * assume that the SO_RCVBUF setting they make will
     824                 :            :                  * allow that much actual data to be received on that
     825                 :            :                  * socket.
     826                 :            :                  *
     827                 :            :                  * Applications are unaware that "struct sk_buff" and
     828                 :            :                  * other overheads allocate from the receive buffer
     829                 :            :                  * during socket buffer allocation.
     830                 :            :                  *
     831                 :            :                  * And after considering the possible alternatives,
     832                 :            :                  * returning the value we actually used in getsockopt
     833                 :            :                  * is the most desirable behavior.
     834                 :            :                  */
     835                 :          3 :                 WRITE_ONCE(sk->sk_rcvbuf,
     836                 :            :                            max_t(int, val * 2, SOCK_MIN_RCVBUF));
     837                 :          3 :                 break;
     838                 :            : 
     839                 :            :         case SO_RCVBUFFORCE:
     840                 :          3 :                 if (!capable(CAP_NET_ADMIN)) {
     841                 :            :                         ret = -EPERM;
     842                 :            :                         break;
     843                 :            :                 }
     844                 :            : 
     845                 :            :                 /* No negative values (to prevent underflow, as val will be
     846                 :            :                  * multiplied by 2).
     847                 :            :                  */
     848                 :          3 :                 if (val < 0)
     849                 :            :                         val = 0;
     850                 :            :                 goto set_rcvbuf;
     851                 :            : 
     852                 :            :         case SO_KEEPALIVE:
     853                 :          1 :                 if (sk->sk_prot->keepalive)
     854                 :          1 :                         sk->sk_prot->keepalive(sk, valbool);
     855                 :          1 :                 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
     856                 :          1 :                 break;
     857                 :            : 
     858                 :            :         case SO_OOBINLINE:
     859                 :          0 :                 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
     860                 :          0 :                 break;
     861                 :            : 
     862                 :            :         case SO_NO_CHECK:
     863                 :          0 :                 sk->sk_no_check_tx = valbool;
     864                 :          0 :                 break;
     865                 :            : 
     866                 :            :         case SO_PRIORITY:
     867                 :          1 :                 if ((val >= 0 && val <= 6) ||
     868                 :          0 :                     ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
     869                 :          1 :                         sk->sk_priority = val;
     870                 :            :                 else
     871                 :            :                         ret = -EPERM;
     872                 :            :                 break;
     873                 :            : 
     874                 :            :         case SO_LINGER:
     875                 :          0 :                 if (optlen < sizeof(ling)) {
     876                 :            :                         ret = -EINVAL;  /* 1003.1g */
     877                 :            :                         break;
     878                 :            :                 }
     879                 :          0 :                 if (copy_from_user(&ling, optval, sizeof(ling))) {
     880                 :            :                         ret = -EFAULT;
     881                 :            :                         break;
     882                 :            :                 }
     883                 :          0 :                 if (!ling.l_onoff)
     884                 :            :                         sock_reset_flag(sk, SOCK_LINGER);
     885                 :            :                 else {
     886                 :            : #if (BITS_PER_LONG == 32)
     887                 :          0 :                         if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
     888                 :          0 :                                 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
     889                 :            :                         else
     890                 :            : #endif
     891                 :          0 :                                 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
     892                 :            :                         sock_set_flag(sk, SOCK_LINGER);
     893                 :            :                 }
     894                 :            :                 break;
     895                 :            : 
     896                 :            :         case SO_BSDCOMPAT:
     897                 :          0 :                 sock_warn_obsolete_bsdism("setsockopt");
     898                 :          0 :                 break;
     899                 :            : 
     900                 :            :         case SO_PASSCRED:
     901                 :          3 :                 if (valbool)
     902                 :          3 :                         set_bit(SOCK_PASSCRED, &sock->flags);
     903                 :            :                 else
     904                 :          0 :                         clear_bit(SOCK_PASSCRED, &sock->flags);
     905                 :            :                 break;
     906                 :            : 
     907                 :            :         case SO_TIMESTAMP_OLD:
     908                 :            :         case SO_TIMESTAMP_NEW:
     909                 :            :         case SO_TIMESTAMPNS_OLD:
     910                 :            :         case SO_TIMESTAMPNS_NEW:
     911                 :          3 :                 if (valbool)  {
     912                 :          3 :                         if (optname == SO_TIMESTAMP_NEW || optname == SO_TIMESTAMPNS_NEW)
     913                 :            :                                 sock_set_flag(sk, SOCK_TSTAMP_NEW);
     914                 :            :                         else
     915                 :            :                                 sock_reset_flag(sk, SOCK_TSTAMP_NEW);
     916                 :            : 
     917                 :          3 :                         if (optname == SO_TIMESTAMP_OLD || optname == SO_TIMESTAMP_NEW)
     918                 :            :                                 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
     919                 :            :                         else
     920                 :            :                                 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
     921                 :            :                         sock_set_flag(sk, SOCK_RCVTSTAMP);
     922                 :          3 :                         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
     923                 :            :                 } else {
     924                 :            :                         sock_reset_flag(sk, SOCK_RCVTSTAMP);
     925                 :            :                         sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
     926                 :            :                         sock_reset_flag(sk, SOCK_TSTAMP_NEW);
     927                 :            :                 }
     928                 :            :                 break;
     929                 :            : 
     930                 :            :         case SO_TIMESTAMPING_NEW:
     931                 :            :                 sock_set_flag(sk, SOCK_TSTAMP_NEW);
     932                 :            :                 /* fall through */
     933                 :            :         case SO_TIMESTAMPING_OLD:
     934                 :          0 :                 if (val & ~SOF_TIMESTAMPING_MASK) {
     935                 :            :                         ret = -EINVAL;
     936                 :            :                         break;
     937                 :            :                 }
     938                 :            : 
     939                 :          0 :                 if (val & SOF_TIMESTAMPING_OPT_ID &&
     940                 :          0 :                     !(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)) {
     941                 :          0 :                         if (sk->sk_protocol == IPPROTO_TCP &&
     942                 :            :                             sk->sk_type == SOCK_STREAM) {
     943                 :          0 :                                 if ((1 << sk->sk_state) &
     944                 :            :                                     (TCPF_CLOSE | TCPF_LISTEN)) {
     945                 :            :                                         ret = -EINVAL;
     946                 :            :                                         break;
     947                 :            :                                 }
     948                 :          0 :                                 sk->sk_tskey = tcp_sk(sk)->snd_una;
     949                 :            :                         } else {
     950                 :          0 :                                 sk->sk_tskey = 0;
     951                 :            :                         }
     952                 :            :                 }
     953                 :            : 
     954                 :          0 :                 if (val & SOF_TIMESTAMPING_OPT_STATS &&
     955                 :            :                     !(val & SOF_TIMESTAMPING_OPT_TSONLY)) {
     956                 :            :                         ret = -EINVAL;
     957                 :            :                         break;
     958                 :            :                 }
     959                 :            : 
     960                 :          0 :                 sk->sk_tsflags = val;
     961                 :          0 :                 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
     962                 :          0 :                         sock_enable_timestamp(sk,
     963                 :            :                                               SOCK_TIMESTAMPING_RX_SOFTWARE);
     964                 :            :                 else {
     965                 :          0 :                         if (optname == SO_TIMESTAMPING_NEW)
     966                 :            :                                 sock_reset_flag(sk, SOCK_TSTAMP_NEW);
     967                 :            : 
     968                 :          0 :                         sock_disable_timestamp(sk,
     969                 :            :                                                (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE));
     970                 :            :                 }
     971                 :            :                 break;
     972                 :            : 
     973                 :            :         case SO_RCVLOWAT:
     974                 :          0 :                 if (val < 0)
     975                 :            :                         val = INT_MAX;
     976                 :          0 :                 if (sock->ops->set_rcvlowat)
     977                 :          0 :                         ret = sock->ops->set_rcvlowat(sk, val);
     978                 :            :                 else
     979                 :          0 :                         WRITE_ONCE(sk->sk_rcvlowat, val ? : 1);
     980                 :            :                 break;
     981                 :            : 
     982                 :            :         case SO_RCVTIMEO_OLD:
     983                 :            :         case SO_RCVTIMEO_NEW:
     984                 :          0 :                 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen, optname == SO_RCVTIMEO_OLD);
     985                 :          0 :                 break;
     986                 :            : 
     987                 :            :         case SO_SNDTIMEO_OLD:
     988                 :            :         case SO_SNDTIMEO_NEW:
     989                 :          3 :                 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen, optname == SO_SNDTIMEO_OLD);
     990                 :          3 :                 break;
     991                 :            : 
     992                 :            :         case SO_ATTACH_FILTER:
     993                 :            :                 ret = -EINVAL;
     994                 :          3 :                 if (optlen == sizeof(struct sock_fprog)) {
     995                 :            :                         struct sock_fprog fprog;
     996                 :            : 
     997                 :            :                         ret = -EFAULT;
     998                 :          3 :                         if (copy_from_user(&fprog, optval, sizeof(fprog)))
     999                 :            :                                 break;
    1000                 :            : 
    1001                 :          3 :                         ret = sk_attach_filter(&fprog, sk);
    1002                 :            :                 }
    1003                 :            :                 break;
    1004                 :            : 
    1005                 :            :         case SO_ATTACH_BPF:
    1006                 :            :                 ret = -EINVAL;
    1007                 :          0 :                 if (optlen == sizeof(u32)) {
    1008                 :            :                         u32 ufd;
    1009                 :            : 
    1010                 :            :                         ret = -EFAULT;
    1011                 :          0 :                         if (copy_from_user(&ufd, optval, sizeof(ufd)))
    1012                 :            :                                 break;
    1013                 :            : 
    1014                 :          0 :                         ret = sk_attach_bpf(ufd, sk);
    1015                 :            :                 }
    1016                 :            :                 break;
    1017                 :            : 
    1018                 :            :         case SO_ATTACH_REUSEPORT_CBPF:
    1019                 :            :                 ret = -EINVAL;
    1020                 :          0 :                 if (optlen == sizeof(struct sock_fprog)) {
    1021                 :            :                         struct sock_fprog fprog;
    1022                 :            : 
    1023                 :            :                         ret = -EFAULT;
    1024                 :          0 :                         if (copy_from_user(&fprog, optval, sizeof(fprog)))
    1025                 :            :                                 break;
    1026                 :            : 
    1027                 :          0 :                         ret = sk_reuseport_attach_filter(&fprog, sk);
    1028                 :            :                 }
    1029                 :            :                 break;
    1030                 :            : 
    1031                 :            :         case SO_ATTACH_REUSEPORT_EBPF:
    1032                 :            :                 ret = -EINVAL;
    1033                 :          0 :                 if (optlen == sizeof(u32)) {
    1034                 :            :                         u32 ufd;
    1035                 :            : 
    1036                 :            :                         ret = -EFAULT;
    1037                 :          0 :                         if (copy_from_user(&ufd, optval, sizeof(ufd)))
    1038                 :            :                                 break;
    1039                 :            : 
    1040                 :          0 :                         ret = sk_reuseport_attach_bpf(ufd, sk);
    1041                 :            :                 }
    1042                 :            :                 break;
    1043                 :            : 
    1044                 :            :         case SO_DETACH_REUSEPORT_BPF:
    1045                 :          0 :                 ret = reuseport_detach_prog(sk);
    1046                 :          0 :                 break;
    1047                 :            : 
    1048                 :            :         case SO_DETACH_FILTER:
    1049                 :          0 :                 ret = sk_detach_filter(sk);
    1050                 :          0 :                 break;
    1051                 :            : 
    1052                 :            :         case SO_LOCK_FILTER:
    1053                 :          0 :                 if (sock_flag(sk, SOCK_FILTER_LOCKED) && !valbool)
    1054                 :            :                         ret = -EPERM;
    1055                 :            :                 else
    1056                 :          0 :                         sock_valbool_flag(sk, SOCK_FILTER_LOCKED, valbool);
    1057                 :            :                 break;
    1058                 :            : 
    1059                 :            :         case SO_PASSSEC:
    1060                 :          3 :                 if (valbool)
    1061                 :          3 :                         set_bit(SOCK_PASSSEC, &sock->flags);
    1062                 :            :                 else
    1063                 :          0 :                         clear_bit(SOCK_PASSSEC, &sock->flags);
    1064                 :            :                 break;
    1065                 :            :         case SO_MARK:
    1066                 :          0 :                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
    1067                 :            :                         ret = -EPERM;
    1068                 :          0 :                 } else if (val != sk->sk_mark) {
    1069                 :          0 :                         sk->sk_mark = val;
    1070                 :            :                         sk_dst_reset(sk);
    1071                 :            :                 }
    1072                 :            :                 break;
    1073                 :            : 
    1074                 :            :         case SO_RXQ_OVFL:
    1075                 :          0 :                 sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
    1076                 :          0 :                 break;
    1077                 :            : 
    1078                 :            :         case SO_WIFI_STATUS:
    1079                 :          0 :                 sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
    1080                 :          0 :                 break;
    1081                 :            : 
    1082                 :            :         case SO_PEEK_OFF:
    1083                 :          0 :                 if (sock->ops->set_peek_off)
    1084                 :          0 :                         ret = sock->ops->set_peek_off(sk, val);
    1085                 :            :                 else
    1086                 :            :                         ret = -EOPNOTSUPP;
    1087                 :            :                 break;
    1088                 :            : 
    1089                 :            :         case SO_NOFCS:
    1090                 :          0 :                 sock_valbool_flag(sk, SOCK_NOFCS, valbool);
    1091                 :          0 :                 break;
    1092                 :            : 
    1093                 :            :         case SO_SELECT_ERR_QUEUE:
    1094                 :          0 :                 sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
    1095                 :          0 :                 break;
    1096                 :            : 
    1097                 :            : #ifdef CONFIG_NET_RX_BUSY_POLL
    1098                 :            :         case SO_BUSY_POLL:
    1099                 :            :                 /* allow unprivileged users to decrease the value */
    1100                 :          0 :                 if ((val > sk->sk_ll_usec) && !capable(CAP_NET_ADMIN))
    1101                 :            :                         ret = -EPERM;
    1102                 :            :                 else {
    1103                 :          0 :                         if (val < 0)
    1104                 :            :                                 ret = -EINVAL;
    1105                 :            :                         else
    1106                 :          0 :                                 sk->sk_ll_usec = val;
    1107                 :            :                 }
    1108                 :            :                 break;
    1109                 :            : #endif
    1110                 :            : 
    1111                 :            :         case SO_MAX_PACING_RATE:
    1112                 :            :                 {
    1113                 :          0 :                 unsigned long ulval = (val == ~0U) ? ~0UL : val;
    1114                 :            : 
    1115                 :            :                 if (sizeof(ulval) != sizeof(val) &&
    1116                 :            :                     optlen >= sizeof(ulval) &&
    1117                 :            :                     get_user(ulval, (unsigned long __user *)optval)) {
    1118                 :            :                         ret = -EFAULT;
    1119                 :            :                         break;
    1120                 :            :                 }
    1121                 :          0 :                 if (ulval != ~0UL)
    1122                 :          0 :                         cmpxchg(&sk->sk_pacing_status,
    1123                 :            :                                 SK_PACING_NONE,
    1124                 :            :                                 SK_PACING_NEEDED);
    1125                 :          0 :                 sk->sk_max_pacing_rate = ulval;
    1126                 :          0 :                 sk->sk_pacing_rate = min(sk->sk_pacing_rate, ulval);
    1127                 :          0 :                 break;
    1128                 :            :                 }
    1129                 :            :         case SO_INCOMING_CPU:
    1130                 :            :                 WRITE_ONCE(sk->sk_incoming_cpu, val);
    1131                 :          0 :                 break;
    1132                 :            : 
    1133                 :            :         case SO_CNX_ADVICE:
    1134                 :          0 :                 if (val == 1)
    1135                 :          0 :                         dst_negative_advice(sk);
    1136                 :            :                 break;
    1137                 :            : 
    1138                 :            :         case SO_ZEROCOPY:
    1139                 :          0 :                 if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6) {
    1140                 :          0 :                         if (!((sk->sk_type == SOCK_STREAM &&
    1141                 :            :                                sk->sk_protocol == IPPROTO_TCP) ||
    1142                 :            :                               (sk->sk_type == SOCK_DGRAM &&
    1143                 :            :                                sk->sk_protocol == IPPROTO_UDP)))
    1144                 :            :                                 ret = -ENOTSUPP;
    1145                 :          0 :                 } else if (sk->sk_family != PF_RDS) {
    1146                 :            :                         ret = -ENOTSUPP;
    1147                 :            :                 }
    1148                 :          0 :                 if (!ret) {
    1149                 :          0 :                         if (val < 0 || val > 1)
    1150                 :            :                                 ret = -EINVAL;
    1151                 :            :                         else
    1152                 :          0 :                                 sock_valbool_flag(sk, SOCK_ZEROCOPY, valbool);
    1153                 :            :                 }
    1154                 :            :                 break;
    1155                 :            : 
    1156                 :            :         case SO_TXTIME:
    1157                 :          0 :                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
    1158                 :            :                         ret = -EPERM;
    1159                 :          0 :                 } else if (optlen != sizeof(struct sock_txtime)) {
    1160                 :            :                         ret = -EINVAL;
    1161                 :          0 :                 } else if (copy_from_user(&sk_txtime, optval,
    1162                 :            :                            sizeof(struct sock_txtime))) {
    1163                 :            :                         ret = -EFAULT;
    1164                 :          0 :                 } else if (sk_txtime.flags & ~SOF_TXTIME_FLAGS_MASK) {
    1165                 :            :                         ret = -EINVAL;
    1166                 :            :                 } else {
    1167                 :          0 :                         sock_valbool_flag(sk, SOCK_TXTIME, true);
    1168                 :          0 :                         sk->sk_clockid = sk_txtime.clockid;
    1169                 :          0 :                         sk->sk_txtime_deadline_mode =
    1170                 :          0 :                                 !!(sk_txtime.flags & SOF_TXTIME_DEADLINE_MODE);
    1171                 :          0 :                         sk->sk_txtime_report_errors =
    1172                 :          0 :                                 !!(sk_txtime.flags & SOF_TXTIME_REPORT_ERRORS);
    1173                 :            :                 }
    1174                 :            :                 break;
    1175                 :            : 
    1176                 :            :         case SO_BINDTOIFINDEX:
    1177                 :          0 :                 ret = sock_setbindtodevice_locked(sk, val);
    1178                 :          0 :                 break;
    1179                 :            : 
    1180                 :            :         default:
    1181                 :            :                 ret = -ENOPROTOOPT;
    1182                 :            :                 break;
    1183                 :            :         }
    1184                 :          3 :         release_sock(sk);
    1185                 :          3 :         return ret;
    1186                 :            : }
    1187                 :            : EXPORT_SYMBOL(sock_setsockopt);
    1188                 :            : 
    1189                 :            : 
    1190                 :          3 : static void cred_to_ucred(struct pid *pid, const struct cred *cred,
    1191                 :            :                           struct ucred *ucred)
    1192                 :            : {
    1193                 :          3 :         ucred->pid = pid_vnr(pid);
    1194                 :          3 :         ucred->uid = ucred->gid = -1;
    1195                 :          3 :         if (cred) {
    1196                 :          3 :                 struct user_namespace *current_ns = current_user_ns();
    1197                 :            : 
    1198                 :          3 :                 ucred->uid = from_kuid_munged(current_ns, cred->euid);
    1199                 :          3 :                 ucred->gid = from_kgid_munged(current_ns, cred->egid);
    1200                 :            :         }
    1201                 :          3 : }
    1202                 :            : 
    1203                 :          3 : static int groups_to_user(gid_t __user *dst, const struct group_info *src)
    1204                 :            : {
    1205                 :          3 :         struct user_namespace *user_ns = current_user_ns();
    1206                 :            :         int i;
    1207                 :            : 
    1208                 :          3 :         for (i = 0; i < src->ngroups; i++)
    1209                 :          3 :                 if (put_user(from_kgid_munged(user_ns, src->gid[i]), dst + i))
    1210                 :            :                         return -EFAULT;
    1211                 :            : 
    1212                 :            :         return 0;
    1213                 :            : }
    1214                 :            : 
    1215                 :          3 : int sock_getsockopt(struct socket *sock, int level, int optname,
    1216                 :            :                     char __user *optval, int __user *optlen)
    1217                 :            : {
    1218                 :          3 :         struct sock *sk = sock->sk;
    1219                 :            : 
    1220                 :            :         union {
    1221                 :            :                 int val;
    1222                 :            :                 u64 val64;
    1223                 :            :                 unsigned long ulval;
    1224                 :            :                 struct linger ling;
    1225                 :            :                 struct old_timeval32 tm32;
    1226                 :            :                 struct __kernel_old_timeval tm;
    1227                 :            :                 struct  __kernel_sock_timeval stm;
    1228                 :            :                 struct sock_txtime txtime;
    1229                 :            :         } v;
    1230                 :            : 
    1231                 :            :         int lv = sizeof(int);
    1232                 :            :         int len;
    1233                 :            : 
    1234                 :          3 :         if (get_user(len, optlen))
    1235                 :            :                 return -EFAULT;
    1236                 :          3 :         if (len < 0)
    1237                 :            :                 return -EINVAL;
    1238                 :            : 
    1239                 :          3 :         memset(&v, 0, sizeof(v));
    1240                 :            : 
    1241                 :          3 :         switch (optname) {
    1242                 :            :         case SO_DEBUG:
    1243                 :          0 :                 v.val = sock_flag(sk, SOCK_DBG);
    1244                 :          0 :                 break;
    1245                 :            : 
    1246                 :            :         case SO_DONTROUTE:
    1247                 :          0 :                 v.val = sock_flag(sk, SOCK_LOCALROUTE);
    1248                 :          0 :                 break;
    1249                 :            : 
    1250                 :            :         case SO_BROADCAST:
    1251                 :          0 :                 v.val = sock_flag(sk, SOCK_BROADCAST);
    1252                 :          0 :                 break;
    1253                 :            : 
    1254                 :            :         case SO_SNDBUF:
    1255                 :          3 :                 v.val = sk->sk_sndbuf;
    1256                 :          3 :                 break;
    1257                 :            : 
    1258                 :            :         case SO_RCVBUF:
    1259                 :          3 :                 v.val = sk->sk_rcvbuf;
    1260                 :          3 :                 break;
    1261                 :            : 
    1262                 :            :         case SO_REUSEADDR:
    1263                 :          0 :                 v.val = sk->sk_reuse;
    1264                 :          0 :                 break;
    1265                 :            : 
    1266                 :            :         case SO_REUSEPORT:
    1267                 :          0 :                 v.val = sk->sk_reuseport;
    1268                 :          0 :                 break;
    1269                 :            : 
    1270                 :            :         case SO_KEEPALIVE:
    1271                 :          3 :                 v.val = sock_flag(sk, SOCK_KEEPOPEN);
    1272                 :          3 :                 break;
    1273                 :            : 
    1274                 :            :         case SO_TYPE:
    1275                 :          3 :                 v.val = sk->sk_type;
    1276                 :          3 :                 break;
    1277                 :            : 
    1278                 :            :         case SO_PROTOCOL:
    1279                 :          3 :                 v.val = sk->sk_protocol;
    1280                 :          3 :                 break;
    1281                 :            : 
    1282                 :            :         case SO_DOMAIN:
    1283                 :          0 :                 v.val = sk->sk_family;
    1284                 :          0 :                 break;
    1285                 :            : 
    1286                 :            :         case SO_ERROR:
    1287                 :          1 :                 v.val = -sock_error(sk);
    1288                 :          1 :                 if (v.val == 0)
    1289                 :          1 :                         v.val = xchg(&sk->sk_err_soft, 0);
    1290                 :            :                 break;
    1291                 :            : 
    1292                 :            :         case SO_OOBINLINE:
    1293                 :          0 :                 v.val = sock_flag(sk, SOCK_URGINLINE);
    1294                 :          0 :                 break;
    1295                 :            : 
    1296                 :            :         case SO_NO_CHECK:
    1297                 :          0 :                 v.val = sk->sk_no_check_tx;
    1298                 :          0 :                 break;
    1299                 :            : 
    1300                 :            :         case SO_PRIORITY:
    1301                 :          0 :                 v.val = sk->sk_priority;
    1302                 :          0 :                 break;
    1303                 :            : 
    1304                 :            :         case SO_LINGER:
    1305                 :            :                 lv              = sizeof(v.ling);
    1306                 :          0 :                 v.ling.l_onoff  = sock_flag(sk, SOCK_LINGER);
    1307                 :          0 :                 v.ling.l_linger = sk->sk_lingertime / HZ;
    1308                 :          0 :                 break;
    1309                 :            : 
    1310                 :            :         case SO_BSDCOMPAT:
    1311                 :          0 :                 sock_warn_obsolete_bsdism("getsockopt");
    1312                 :          0 :                 break;
    1313                 :            : 
    1314                 :            :         case SO_TIMESTAMP_OLD:
    1315                 :          0 :                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
    1316                 :          0 :                                 !sock_flag(sk, SOCK_TSTAMP_NEW) &&
    1317                 :            :                                 !sock_flag(sk, SOCK_RCVTSTAMPNS);
    1318                 :          0 :                 break;
    1319                 :            : 
    1320                 :            :         case SO_TIMESTAMPNS_OLD:
    1321                 :          0 :                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS) && !sock_flag(sk, SOCK_TSTAMP_NEW);
    1322                 :          0 :                 break;
    1323                 :            : 
    1324                 :            :         case SO_TIMESTAMP_NEW:
    1325                 :          0 :                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) && sock_flag(sk, SOCK_TSTAMP_NEW);
    1326                 :          0 :                 break;
    1327                 :            : 
    1328                 :            :         case SO_TIMESTAMPNS_NEW:
    1329                 :          0 :                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS) && sock_flag(sk, SOCK_TSTAMP_NEW);
    1330                 :          0 :                 break;
    1331                 :            : 
    1332                 :            :         case SO_TIMESTAMPING_OLD:
    1333                 :          0 :                 v.val = sk->sk_tsflags;
    1334                 :          0 :                 break;
    1335                 :            : 
    1336                 :            :         case SO_RCVTIMEO_OLD:
    1337                 :            :         case SO_RCVTIMEO_NEW:
    1338                 :          0 :                 lv = sock_get_timeout(sk->sk_rcvtimeo, &v, SO_RCVTIMEO_OLD == optname);
    1339                 :          0 :                 break;
    1340                 :            : 
    1341                 :            :         case SO_SNDTIMEO_OLD:
    1342                 :            :         case SO_SNDTIMEO_NEW:
    1343                 :          0 :                 lv = sock_get_timeout(sk->sk_sndtimeo, &v, SO_SNDTIMEO_OLD == optname);
    1344                 :          0 :                 break;
    1345                 :            : 
    1346                 :            :         case SO_RCVLOWAT:
    1347                 :          0 :                 v.val = sk->sk_rcvlowat;
    1348                 :          0 :                 break;
    1349                 :            : 
    1350                 :            :         case SO_SNDLOWAT:
    1351                 :          0 :                 v.val = 1;
    1352                 :          0 :                 break;
    1353                 :            : 
    1354                 :            :         case SO_PASSCRED:
    1355                 :          0 :                 v.val = !!test_bit(SOCK_PASSCRED, &sock->flags);
    1356                 :          0 :                 break;
    1357                 :            : 
    1358                 :            :         case SO_PEERCRED:
    1359                 :            :         {
    1360                 :            :                 struct ucred peercred;
    1361                 :          3 :                 if (len > sizeof(peercred))
    1362                 :            :                         len = sizeof(peercred);
    1363                 :          3 :                 cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
    1364                 :          3 :                 if (copy_to_user(optval, &peercred, len))
    1365                 :          0 :                         return -EFAULT;
    1366                 :          3 :                 goto lenout;
    1367                 :            :         }
    1368                 :            : 
    1369                 :            :         case SO_PEERGROUPS:
    1370                 :            :         {
    1371                 :            :                 int ret, n;
    1372                 :            : 
    1373                 :          3 :                 if (!sk->sk_peer_cred)
    1374                 :            :                         return -ENODATA;
    1375                 :            : 
    1376                 :          3 :                 n = sk->sk_peer_cred->group_info->ngroups;
    1377                 :          3 :                 if (len < n * sizeof(gid_t)) {
    1378                 :          0 :                         len = n * sizeof(gid_t);
    1379                 :          0 :                         return put_user(len, optlen) ? -EFAULT : -ERANGE;
    1380                 :            :                 }
    1381                 :          3 :                 len = n * sizeof(gid_t);
    1382                 :            : 
    1383                 :          3 :                 ret = groups_to_user((gid_t __user *)optval,
    1384                 :            :                                      sk->sk_peer_cred->group_info);
    1385                 :          3 :                 if (ret)
    1386                 :            :                         return ret;
    1387                 :            :                 goto lenout;
    1388                 :            :         }
    1389                 :            : 
    1390                 :            :         case SO_PEERNAME:
    1391                 :            :         {
    1392                 :            :                 char address[128];
    1393                 :            : 
    1394                 :          0 :                 lv = sock->ops->getname(sock, (struct sockaddr *)address, 2);
    1395                 :          0 :                 if (lv < 0)
    1396                 :          0 :                         return -ENOTCONN;
    1397                 :          0 :                 if (lv < len)
    1398                 :            :                         return -EINVAL;
    1399                 :          0 :                 if (copy_to_user(optval, address, len))
    1400                 :            :                         return -EFAULT;
    1401                 :          0 :                 goto lenout;
    1402                 :            :         }
    1403                 :            : 
    1404                 :            :         /* Dubious BSD thing... Probably nobody even uses it, but
    1405                 :            :          * the UNIX standard wants it for whatever reason... -DaveM
    1406                 :            :          */
    1407                 :            :         case SO_ACCEPTCONN:
    1408                 :          3 :                 v.val = sk->sk_state == TCP_LISTEN;
    1409                 :          3 :                 break;
    1410                 :            : 
    1411                 :            :         case SO_PASSSEC:
    1412                 :          0 :                 v.val = !!test_bit(SOCK_PASSSEC, &sock->flags);
    1413                 :          0 :                 break;
    1414                 :            : 
    1415                 :            :         case SO_PEERSEC:
    1416                 :          3 :                 return security_socket_getpeersec_stream(sock, optval, optlen, len);
    1417                 :            : 
    1418                 :            :         case SO_MARK:
    1419                 :          0 :                 v.val = sk->sk_mark;
    1420                 :          0 :                 break;
    1421                 :            : 
    1422                 :            :         case SO_RXQ_OVFL:
    1423                 :          0 :                 v.val = sock_flag(sk, SOCK_RXQ_OVFL);
    1424                 :          0 :                 break;
    1425                 :            : 
    1426                 :            :         case SO_WIFI_STATUS:
    1427                 :          0 :                 v.val = sock_flag(sk, SOCK_WIFI_STATUS);
    1428                 :          0 :                 break;
    1429                 :            : 
    1430                 :            :         case SO_PEEK_OFF:
    1431                 :          0 :                 if (!sock->ops->set_peek_off)
    1432                 :            :                         return -EOPNOTSUPP;
    1433                 :            : 
    1434                 :          0 :                 v.val = sk->sk_peek_off;
    1435                 :          0 :                 break;
    1436                 :            :         case SO_NOFCS:
    1437                 :          0 :                 v.val = sock_flag(sk, SOCK_NOFCS);
    1438                 :          0 :                 break;
    1439                 :            : 
    1440                 :            :         case SO_BINDTODEVICE:
    1441                 :          0 :                 return sock_getbindtodevice(sk, optval, optlen, len);
    1442                 :            : 
    1443                 :            :         case SO_GET_FILTER:
    1444                 :          0 :                 len = sk_get_filter(sk, (struct sock_filter __user *)optval, len);
    1445                 :          0 :                 if (len < 0)
    1446                 :            :                         return len;
    1447                 :            : 
    1448                 :            :                 goto lenout;
    1449                 :            : 
    1450                 :            :         case SO_LOCK_FILTER:
    1451                 :          0 :                 v.val = sock_flag(sk, SOCK_FILTER_LOCKED);
    1452                 :          0 :                 break;
    1453                 :            : 
    1454                 :            :         case SO_BPF_EXTENSIONS:
    1455                 :          0 :                 v.val = bpf_tell_extensions();
    1456                 :          0 :                 break;
    1457                 :            : 
    1458                 :            :         case SO_SELECT_ERR_QUEUE:
    1459                 :          0 :                 v.val = sock_flag(sk, SOCK_SELECT_ERR_QUEUE);
    1460                 :          0 :                 break;
    1461                 :            : 
    1462                 :            : #ifdef CONFIG_NET_RX_BUSY_POLL
    1463                 :            :         case SO_BUSY_POLL:
    1464                 :          0 :                 v.val = sk->sk_ll_usec;
    1465                 :          0 :                 break;
    1466                 :            : #endif
    1467                 :            : 
    1468                 :            :         case SO_MAX_PACING_RATE:
    1469                 :            :                 if (sizeof(v.ulval) != sizeof(v.val) && len >= sizeof(v.ulval)) {
    1470                 :            :                         lv = sizeof(v.ulval);
    1471                 :            :                         v.ulval = sk->sk_max_pacing_rate;
    1472                 :            :                 } else {
    1473                 :            :                         /* 32bit version */
    1474                 :          0 :                         v.val = min_t(unsigned long, sk->sk_max_pacing_rate, ~0U);
    1475                 :            :                 }
    1476                 :          0 :                 break;
    1477                 :            : 
    1478                 :            :         case SO_INCOMING_CPU:
    1479                 :          0 :                 v.val = READ_ONCE(sk->sk_incoming_cpu);
    1480                 :          0 :                 break;
    1481                 :            : 
    1482                 :            :         case SO_MEMINFO:
    1483                 :            :         {
    1484                 :            :                 u32 meminfo[SK_MEMINFO_VARS];
    1485                 :            : 
    1486                 :          0 :                 sk_get_meminfo(sk, meminfo);
    1487                 :            : 
    1488                 :          0 :                 len = min_t(unsigned int, len, sizeof(meminfo));
    1489                 :          0 :                 if (copy_to_user(optval, &meminfo, len))
    1490                 :          0 :                         return -EFAULT;
    1491                 :            : 
    1492                 :          0 :                 goto lenout;
    1493                 :            :         }
    1494                 :            : 
    1495                 :            : #ifdef CONFIG_NET_RX_BUSY_POLL
    1496                 :            :         case SO_INCOMING_NAPI_ID:
    1497                 :          1 :                 v.val = READ_ONCE(sk->sk_napi_id);
    1498                 :            : 
    1499                 :            :                 /* aggregate non-NAPI IDs down to 0 */
    1500                 :          1 :                 if (v.val < MIN_NAPI_ID)
    1501                 :          0 :                         v.val = 0;
    1502                 :            : 
    1503                 :            :                 break;
    1504                 :            : #endif
    1505                 :            : 
    1506                 :            :         case SO_COOKIE:
    1507                 :            :                 lv = sizeof(u64);
    1508                 :          0 :                 if (len < lv)
    1509                 :            :                         return -EINVAL;
    1510                 :          0 :                 v.val64 = sock_gen_cookie(sk);
    1511                 :          0 :                 break;
    1512                 :            : 
    1513                 :            :         case SO_ZEROCOPY:
    1514                 :          0 :                 v.val = sock_flag(sk, SOCK_ZEROCOPY);
    1515                 :          0 :                 break;
    1516                 :            : 
    1517                 :            :         case SO_TXTIME:
    1518                 :            :                 lv = sizeof(v.txtime);
    1519                 :          0 :                 v.txtime.clockid = sk->sk_clockid;
    1520                 :          0 :                 v.txtime.flags |= sk->sk_txtime_deadline_mode ?
    1521                 :            :                                   SOF_TXTIME_DEADLINE_MODE : 0;
    1522                 :          0 :                 v.txtime.flags |= sk->sk_txtime_report_errors ?
    1523                 :            :                                   SOF_TXTIME_REPORT_ERRORS : 0;
    1524                 :          0 :                 break;
    1525                 :            : 
    1526                 :            :         case SO_BINDTOIFINDEX:
    1527                 :          0 :                 v.val = sk->sk_bound_dev_if;
    1528                 :          0 :                 break;
    1529                 :            : 
    1530                 :            :         default:
    1531                 :            :                 /* We implement the SO_SNDLOWAT etc to not be settable
    1532                 :            :                  * (1003.1g 7).
    1533                 :            :                  */
    1534                 :            :                 return -ENOPROTOOPT;
    1535                 :            :         }
    1536                 :            : 
    1537                 :          3 :         if (len > lv)
    1538                 :            :                 len = lv;
    1539                 :          3 :         if (copy_to_user(optval, &v, len))
    1540                 :            :                 return -EFAULT;
    1541                 :            : lenout:
    1542                 :          3 :         if (put_user(len, optlen))
    1543                 :            :                 return -EFAULT;
    1544                 :          3 :         return 0;
    1545                 :            : }
    1546                 :            : 
    1547                 :            : /*
    1548                 :            :  * Initialize an sk_lock.
    1549                 :            :  *
    1550                 :            :  * (We also register the sk_lock with the lock validator.)
    1551                 :            :  */
    1552                 :          3 : static inline void sock_lock_init(struct sock *sk)
    1553                 :            : {
    1554                 :          3 :         if (sk->sk_kern_sock)
    1555                 :          3 :                 sock_lock_init_class_and_name(
    1556                 :            :                         sk,
    1557                 :            :                         af_family_kern_slock_key_strings[sk->sk_family],
    1558                 :            :                         af_family_kern_slock_keys + sk->sk_family,
    1559                 :            :                         af_family_kern_key_strings[sk->sk_family],
    1560                 :            :                         af_family_kern_keys + sk->sk_family);
    1561                 :            :         else
    1562                 :          3 :                 sock_lock_init_class_and_name(
    1563                 :            :                         sk,
    1564                 :            :                         af_family_slock_key_strings[sk->sk_family],
    1565                 :            :                         af_family_slock_keys + sk->sk_family,
    1566                 :            :                         af_family_key_strings[sk->sk_family],
    1567                 :            :                         af_family_keys + sk->sk_family);
    1568                 :          3 : }
    1569                 :            : 
    1570                 :            : /*
    1571                 :            :  * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
    1572                 :            :  * even temporarly, because of RCU lookups. sk_node should also be left as is.
    1573                 :            :  * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
    1574                 :            :  */
    1575                 :          0 : static void sock_copy(struct sock *nsk, const struct sock *osk)
    1576                 :            : {
    1577                 :            : #ifdef CONFIG_SECURITY_NETWORK
    1578                 :          0 :         void *sptr = nsk->sk_security;
    1579                 :            : #endif
    1580                 :          0 :         memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
    1581                 :            : 
    1582                 :          0 :         memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
    1583                 :          0 :                osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
    1584                 :            : 
    1585                 :            : #ifdef CONFIG_SECURITY_NETWORK
    1586                 :          0 :         nsk->sk_security = sptr;
    1587                 :          0 :         security_sk_clone(osk, nsk);
    1588                 :            : #endif
    1589                 :          0 : }
    1590                 :            : 
    1591                 :          3 : static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
    1592                 :            :                 int family)
    1593                 :            : {
    1594                 :            :         struct sock *sk;
    1595                 :            :         struct kmem_cache *slab;
    1596                 :            : 
    1597                 :          3 :         slab = prot->slab;
    1598                 :          3 :         if (slab != NULL) {
    1599                 :          3 :                 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
    1600                 :          3 :                 if (!sk)
    1601                 :            :                         return sk;
    1602                 :          3 :                 if (want_init_on_alloc(priority))
    1603                 :          3 :                         sk_prot_clear_nulls(sk, prot->obj_size);
    1604                 :            :         } else
    1605                 :          3 :                 sk = kmalloc(prot->obj_size, priority);
    1606                 :            : 
    1607                 :          3 :         if (sk != NULL) {
    1608                 :          3 :                 if (security_sk_alloc(sk, family, priority))
    1609                 :            :                         goto out_free;
    1610                 :            : 
    1611                 :          3 :                 if (!try_module_get(prot->owner))
    1612                 :            :                         goto out_free_sec;
    1613                 :            :                 sk_tx_queue_clear(sk);
    1614                 :            :         }
    1615                 :            : 
    1616                 :          3 :         return sk;
    1617                 :            : 
    1618                 :            : out_free_sec:
    1619                 :          0 :         security_sk_free(sk);
    1620                 :            : out_free:
    1621                 :          0 :         if (slab != NULL)
    1622                 :          0 :                 kmem_cache_free(slab, sk);
    1623                 :            :         else
    1624                 :          0 :                 kfree(sk);
    1625                 :            :         return NULL;
    1626                 :            : }
    1627                 :            : 
    1628                 :          3 : static void sk_prot_free(struct proto *prot, struct sock *sk)
    1629                 :            : {
    1630                 :            :         struct kmem_cache *slab;
    1631                 :            :         struct module *owner;
    1632                 :            : 
    1633                 :          3 :         owner = prot->owner;
    1634                 :          3 :         slab = prot->slab;
    1635                 :            : 
    1636                 :          3 :         cgroup_sk_free(&sk->sk_cgrp_data);
    1637                 :          3 :         mem_cgroup_sk_free(sk);
    1638                 :          3 :         security_sk_free(sk);
    1639                 :          3 :         if (slab != NULL)
    1640                 :          3 :                 kmem_cache_free(slab, sk);
    1641                 :            :         else
    1642                 :          3 :                 kfree(sk);
    1643                 :          3 :         module_put(owner);
    1644                 :          3 : }
    1645                 :            : 
    1646                 :            : /**
    1647                 :            :  *      sk_alloc - All socket objects are allocated here
    1648                 :            :  *      @net: the applicable net namespace
    1649                 :            :  *      @family: protocol family
    1650                 :            :  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
    1651                 :            :  *      @prot: struct proto associated with this new sock instance
    1652                 :            :  *      @kern: is this to be a kernel socket?
    1653                 :            :  */
    1654                 :          3 : struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
    1655                 :            :                       struct proto *prot, int kern)
    1656                 :            : {
    1657                 :            :         struct sock *sk;
    1658                 :            : 
    1659                 :          3 :         sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
    1660                 :          3 :         if (sk) {
    1661                 :          3 :                 sk->sk_family = family;
    1662                 :            :                 /*
    1663                 :            :                  * See comment in struct sock definition to understand
    1664                 :            :                  * why we need sk_prot_creator -acme
    1665                 :            :                  */
    1666                 :          3 :                 sk->sk_prot = sk->sk_prot_creator = prot;
    1667                 :          3 :                 sk->sk_kern_sock = kern;
    1668                 :          3 :                 sock_lock_init(sk);
    1669                 :          3 :                 sk->sk_net_refcnt = kern ? 0 : 1;
    1670                 :          3 :                 if (likely(sk->sk_net_refcnt)) {
    1671                 :            :                         get_net(net);
    1672                 :            :                         sock_inuse_add(net, 1);
    1673                 :            :                 }
    1674                 :            : 
    1675                 :            :                 sock_net_set(sk, net);
    1676                 :            :                 refcount_set(&sk->sk_wmem_alloc, 1);
    1677                 :            : 
    1678                 :          3 :                 mem_cgroup_sk_alloc(sk);
    1679                 :          3 :                 cgroup_sk_alloc(&sk->sk_cgrp_data);
    1680                 :          3 :                 sock_update_classid(&sk->sk_cgrp_data);
    1681                 :          3 :                 sock_update_netprioidx(&sk->sk_cgrp_data);
    1682                 :            :                 sk_tx_queue_clear(sk);
    1683                 :            :         }
    1684                 :            : 
    1685                 :          3 :         return sk;
    1686                 :            : }
    1687                 :            : EXPORT_SYMBOL(sk_alloc);
    1688                 :            : 
    1689                 :            : /* Sockets having SOCK_RCU_FREE will call this function after one RCU
    1690                 :            :  * grace period. This is the case for UDP sockets and TCP listeners.
    1691                 :            :  */
    1692                 :          3 : static void __sk_destruct(struct rcu_head *head)
    1693                 :            : {
    1694                 :          3 :         struct sock *sk = container_of(head, struct sock, sk_rcu);
    1695                 :            :         struct sk_filter *filter;
    1696                 :            : 
    1697                 :          3 :         if (sk->sk_destruct)
    1698                 :          3 :                 sk->sk_destruct(sk);
    1699                 :            : 
    1700                 :          3 :         filter = rcu_dereference_check(sk->sk_filter,
    1701                 :            :                                        refcount_read(&sk->sk_wmem_alloc) == 0);
    1702                 :          3 :         if (filter) {
    1703                 :          3 :                 sk_filter_uncharge(sk, filter);
    1704                 :            :                 RCU_INIT_POINTER(sk->sk_filter, NULL);
    1705                 :            :         }
    1706                 :            : 
    1707                 :          3 :         sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
    1708                 :            : 
    1709                 :            : #ifdef CONFIG_BPF_SYSCALL
    1710                 :          3 :         bpf_sk_storage_free(sk);
    1711                 :            : #endif
    1712                 :            : 
    1713                 :            :         if (atomic_read(&sk->sk_omem_alloc))
    1714                 :            :                 pr_debug("%s: optmem leakage (%d bytes) detected\n",
    1715                 :            :                          __func__, atomic_read(&sk->sk_omem_alloc));
    1716                 :            : 
    1717                 :          3 :         if (sk->sk_frag.page) {
    1718                 :          0 :                 put_page(sk->sk_frag.page);
    1719                 :          0 :                 sk->sk_frag.page = NULL;
    1720                 :            :         }
    1721                 :            : 
    1722                 :          3 :         if (sk->sk_peer_cred)
    1723                 :          3 :                 put_cred(sk->sk_peer_cred);
    1724                 :          3 :         put_pid(sk->sk_peer_pid);
    1725                 :          3 :         if (likely(sk->sk_net_refcnt))
    1726                 :          3 :                 put_net(sock_net(sk));
    1727                 :          3 :         sk_prot_free(sk->sk_prot_creator, sk);
    1728                 :          3 : }
    1729                 :            : 
    1730                 :          3 : void sk_destruct(struct sock *sk)
    1731                 :            : {
    1732                 :            :         bool use_call_rcu = sock_flag(sk, SOCK_RCU_FREE);
    1733                 :            : 
    1734                 :          3 :         if (rcu_access_pointer(sk->sk_reuseport_cb)) {
    1735                 :          0 :                 reuseport_detach_sock(sk);
    1736                 :            :                 use_call_rcu = true;
    1737                 :            :         }
    1738                 :            : 
    1739                 :          3 :         if (use_call_rcu)
    1740                 :          3 :                 call_rcu(&sk->sk_rcu, __sk_destruct);
    1741                 :            :         else
    1742                 :          3 :                 __sk_destruct(&sk->sk_rcu);
    1743                 :          3 : }
    1744                 :            : 
    1745                 :          3 : static void __sk_free(struct sock *sk)
    1746                 :            : {
    1747                 :          3 :         if (likely(sk->sk_net_refcnt))
    1748                 :            :                 sock_inuse_add(sock_net(sk), -1);
    1749                 :            : 
    1750                 :          3 :         if (unlikely(sk->sk_net_refcnt && sock_diag_has_destroy_listeners(sk)))
    1751                 :          0 :                 sock_diag_broadcast_destroy(sk);
    1752                 :            :         else
    1753                 :          3 :                 sk_destruct(sk);
    1754                 :          3 : }
    1755                 :            : 
    1756                 :          3 : void sk_free(struct sock *sk)
    1757                 :            : {
    1758                 :            :         /*
    1759                 :            :          * We subtract one from sk_wmem_alloc and can know if
    1760                 :            :          * some packets are still in some tx queue.
    1761                 :            :          * If not null, sock_wfree() will call __sk_free(sk) later
    1762                 :            :          */
    1763                 :          3 :         if (refcount_dec_and_test(&sk->sk_wmem_alloc))
    1764                 :          3 :                 __sk_free(sk);
    1765                 :          3 : }
    1766                 :            : EXPORT_SYMBOL(sk_free);
    1767                 :            : 
    1768                 :            : static void sk_init_common(struct sock *sk)
    1769                 :            : {
    1770                 :          3 :         skb_queue_head_init(&sk->sk_receive_queue);
    1771                 :          3 :         skb_queue_head_init(&sk->sk_write_queue);
    1772                 :          3 :         skb_queue_head_init(&sk->sk_error_queue);
    1773                 :            : 
    1774                 :          3 :         rwlock_init(&sk->sk_callback_lock);
    1775                 :            :         lockdep_set_class_and_name(&sk->sk_receive_queue.lock,
    1776                 :            :                         af_rlock_keys + sk->sk_family,
    1777                 :            :                         af_family_rlock_key_strings[sk->sk_family]);
    1778                 :            :         lockdep_set_class_and_name(&sk->sk_write_queue.lock,
    1779                 :            :                         af_wlock_keys + sk->sk_family,
    1780                 :            :                         af_family_wlock_key_strings[sk->sk_family]);
    1781                 :            :         lockdep_set_class_and_name(&sk->sk_error_queue.lock,
    1782                 :            :                         af_elock_keys + sk->sk_family,
    1783                 :            :                         af_family_elock_key_strings[sk->sk_family]);
    1784                 :            :         lockdep_set_class_and_name(&sk->sk_callback_lock,
    1785                 :            :                         af_callback_keys + sk->sk_family,
    1786                 :            :                         af_family_clock_key_strings[sk->sk_family]);
    1787                 :            : }
    1788                 :            : 
    1789                 :            : /**
    1790                 :            :  *      sk_clone_lock - clone a socket, and lock its clone
    1791                 :            :  *      @sk: the socket to clone
    1792                 :            :  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
    1793                 :            :  *
    1794                 :            :  *      Caller must unlock socket even in error path (bh_unlock_sock(newsk))
    1795                 :            :  */
    1796                 :          0 : struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
    1797                 :            : {
    1798                 :            :         struct sock *newsk;
    1799                 :            :         bool is_charged = true;
    1800                 :            : 
    1801                 :          0 :         newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
    1802                 :          0 :         if (newsk != NULL) {
    1803                 :            :                 struct sk_filter *filter;
    1804                 :            : 
    1805                 :          0 :                 sock_copy(newsk, sk);
    1806                 :            : 
    1807                 :          0 :                 newsk->sk_prot_creator = sk->sk_prot;
    1808                 :            : 
    1809                 :            :                 /* SANITY */
    1810                 :          0 :                 if (likely(newsk->sk_net_refcnt))
    1811                 :            :                         get_net(sock_net(newsk));
    1812                 :            :                 sk_node_init(&newsk->sk_node);
    1813                 :          0 :                 sock_lock_init(newsk);
    1814                 :            :                 bh_lock_sock(newsk);
    1815                 :          0 :                 newsk->sk_backlog.head       = newsk->sk_backlog.tail = NULL;
    1816                 :          0 :                 newsk->sk_backlog.len = 0;
    1817                 :            : 
    1818                 :            :                 atomic_set(&newsk->sk_rmem_alloc, 0);
    1819                 :            :                 /*
    1820                 :            :                  * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
    1821                 :            :                  */
    1822                 :            :                 refcount_set(&newsk->sk_wmem_alloc, 1);
    1823                 :            :                 atomic_set(&newsk->sk_omem_alloc, 0);
    1824                 :            :                 sk_init_common(newsk);
    1825                 :            : 
    1826                 :          0 :                 newsk->sk_dst_cache  = NULL;
    1827                 :          0 :                 newsk->sk_dst_pending_confirm = 0;
    1828                 :          0 :                 newsk->sk_wmem_queued        = 0;
    1829                 :          0 :                 newsk->sk_forward_alloc = 0;
    1830                 :            :                 atomic_set(&newsk->sk_drops, 0);
    1831                 :          0 :                 newsk->sk_send_head  = NULL;
    1832                 :          0 :                 newsk->sk_userlocks  = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
    1833                 :            :                 atomic_set(&newsk->sk_zckey, 0);
    1834                 :            : 
    1835                 :            :                 sock_reset_flag(newsk, SOCK_DONE);
    1836                 :            : 
    1837                 :            :                 /* sk->sk_memcg will be populated at accept() time */
    1838                 :          0 :                 newsk->sk_memcg = NULL;
    1839                 :            : 
    1840                 :          0 :                 cgroup_sk_clone(&newsk->sk_cgrp_data);
    1841                 :            : 
    1842                 :            :                 rcu_read_lock();
    1843                 :          0 :                 filter = rcu_dereference(sk->sk_filter);
    1844                 :          0 :                 if (filter != NULL)
    1845                 :            :                         /* though it's an empty new sock, the charging may fail
    1846                 :            :                          * if sysctl_optmem_max was changed between creation of
    1847                 :            :                          * original socket and cloning
    1848                 :            :                          */
    1849                 :          0 :                         is_charged = sk_filter_charge(newsk, filter);
    1850                 :            :                 RCU_INIT_POINTER(newsk->sk_filter, filter);
    1851                 :            :                 rcu_read_unlock();
    1852                 :            : 
    1853                 :          0 :                 if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk, sk))) {
    1854                 :            :                         /* We need to make sure that we don't uncharge the new
    1855                 :            :                          * socket if we couldn't charge it in the first place
    1856                 :            :                          * as otherwise we uncharge the parent's filter.
    1857                 :            :                          */
    1858                 :          0 :                         if (!is_charged)
    1859                 :            :                                 RCU_INIT_POINTER(newsk->sk_filter, NULL);
    1860                 :            :                         sk_free_unlock_clone(newsk);
    1861                 :            :                         newsk = NULL;
    1862                 :          0 :                         goto out;
    1863                 :            :                 }
    1864                 :            :                 RCU_INIT_POINTER(newsk->sk_reuseport_cb, NULL);
    1865                 :            : 
    1866                 :          0 :                 if (bpf_sk_storage_clone(sk, newsk)) {
    1867                 :            :                         sk_free_unlock_clone(newsk);
    1868                 :            :                         newsk = NULL;
    1869                 :          0 :                         goto out;
    1870                 :            :                 }
    1871                 :            : 
    1872                 :          0 :                 newsk->sk_err           = 0;
    1873                 :          0 :                 newsk->sk_err_soft = 0;
    1874                 :          0 :                 newsk->sk_priority = 0;
    1875                 :          0 :                 newsk->sk_incoming_cpu = raw_smp_processor_id();
    1876                 :          0 :                 if (likely(newsk->sk_net_refcnt))
    1877                 :            :                         sock_inuse_add(sock_net(newsk), 1);
    1878                 :            : 
    1879                 :            :                 /*
    1880                 :            :                  * Before updating sk_refcnt, we must commit prior changes to memory
    1881                 :            :                  * (Documentation/RCU/rculist_nulls.txt for details)
    1882                 :            :                  */
    1883                 :          0 :                 smp_wmb();
    1884                 :            :                 refcount_set(&newsk->sk_refcnt, 2);
    1885                 :            : 
    1886                 :            :                 /*
    1887                 :            :                  * Increment the counter in the same struct proto as the master
    1888                 :            :                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
    1889                 :            :                  * is the same as sk->sk_prot->socks, as this field was copied
    1890                 :            :                  * with memcpy).
    1891                 :            :                  *
    1892                 :            :                  * This _changes_ the previous behaviour, where
    1893                 :            :                  * tcp_create_openreq_child always was incrementing the
    1894                 :            :                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
    1895                 :            :                  * to be taken into account in all callers. -acme
    1896                 :            :                  */
    1897                 :            :                 sk_refcnt_debug_inc(newsk);
    1898                 :            :                 sk_set_socket(newsk, NULL);
    1899                 :            :                 sk_tx_queue_clear(newsk);
    1900                 :            :                 RCU_INIT_POINTER(newsk->sk_wq, NULL);
    1901                 :            : 
    1902                 :          0 :                 if (newsk->sk_prot->sockets_allocated)
    1903                 :          0 :                         sk_sockets_allocated_inc(newsk);
    1904                 :            : 
    1905                 :          0 :                 if (sock_needs_netstamp(sk) &&
    1906                 :          0 :                     newsk->sk_flags & SK_FLAGS_TIMESTAMP)
    1907                 :          0 :                         net_enable_timestamp();
    1908                 :            :         }
    1909                 :            : out:
    1910                 :          0 :         return newsk;
    1911                 :            : }
    1912                 :            : EXPORT_SYMBOL_GPL(sk_clone_lock);
    1913                 :            : 
    1914                 :          0 : void sk_free_unlock_clone(struct sock *sk)
    1915                 :            : {
    1916                 :            :         /* It is still raw copy of parent, so invalidate
    1917                 :            :          * destructor and make plain sk_free() */
    1918                 :          0 :         sk->sk_destruct = NULL;
    1919                 :            :         bh_unlock_sock(sk);
    1920                 :          0 :         sk_free(sk);
    1921                 :          0 : }
    1922                 :            : EXPORT_SYMBOL_GPL(sk_free_unlock_clone);
    1923                 :            : 
    1924                 :          1 : void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
    1925                 :            : {
    1926                 :            :         u32 max_segs = 1;
    1927                 :            : 
    1928                 :          1 :         sk_dst_set(sk, dst);
    1929                 :          1 :         sk->sk_route_caps = dst->dev->features | sk->sk_route_forced_caps;
    1930                 :          1 :         if (sk->sk_route_caps & NETIF_F_GSO)
    1931                 :          1 :                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
    1932                 :          1 :         sk->sk_route_caps &= ~sk->sk_route_nocaps;
    1933                 :          1 :         if (sk_can_gso(sk)) {
    1934                 :          1 :                 if (dst->header_len && !xfrm_dst_offload_ok(dst)) {
    1935                 :          0 :                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
    1936                 :            :                 } else {
    1937                 :          1 :                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
    1938                 :          1 :                         sk->sk_gso_max_size = dst->dev->gso_max_size;
    1939                 :          1 :                         max_segs = max_t(u32, dst->dev->gso_max_segs, 1);
    1940                 :            :                 }
    1941                 :            :         }
    1942                 :          1 :         sk->sk_gso_max_segs = max_segs;
    1943                 :          1 : }
    1944                 :            : EXPORT_SYMBOL_GPL(sk_setup_caps);
    1945                 :            : 
    1946                 :            : /*
    1947                 :            :  *      Simple resource managers for sockets.
    1948                 :            :  */
    1949                 :            : 
    1950                 :            : 
    1951                 :            : /*
    1952                 :            :  * Write buffer destructor automatically called from kfree_skb.
    1953                 :            :  */
    1954                 :          3 : void sock_wfree(struct sk_buff *skb)
    1955                 :            : {
    1956                 :          3 :         struct sock *sk = skb->sk;
    1957                 :          3 :         unsigned int len = skb->truesize;
    1958                 :            : 
    1959                 :          3 :         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
    1960                 :            :                 /*
    1961                 :            :                  * Keep a reference on sk_wmem_alloc, this will be released
    1962                 :            :                  * after sk_write_space() call
    1963                 :            :                  */
    1964                 :          3 :                 WARN_ON(refcount_sub_and_test(len - 1, &sk->sk_wmem_alloc));
    1965                 :          3 :                 sk->sk_write_space(sk);
    1966                 :            :                 len = 1;
    1967                 :            :         }
    1968                 :            :         /*
    1969                 :            :          * if sk_wmem_alloc reaches 0, we must finish what sk_free()
    1970                 :            :          * could not do because of in-flight packets
    1971                 :            :          */
    1972                 :          3 :         if (refcount_sub_and_test(len, &sk->sk_wmem_alloc))
    1973                 :          3 :                 __sk_free(sk);
    1974                 :          3 : }
    1975                 :            : EXPORT_SYMBOL(sock_wfree);
    1976                 :            : 
    1977                 :            : /* This variant of sock_wfree() is used by TCP,
    1978                 :            :  * since it sets SOCK_USE_WRITE_QUEUE.
    1979                 :            :  */
    1980                 :          1 : void __sock_wfree(struct sk_buff *skb)
    1981                 :            : {
    1982                 :          1 :         struct sock *sk = skb->sk;
    1983                 :            : 
    1984                 :          1 :         if (refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc))
    1985                 :          0 :                 __sk_free(sk);
    1986                 :          1 : }
    1987                 :            : 
    1988                 :          3 : void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
    1989                 :            : {
    1990                 :          3 :         skb_orphan(skb);
    1991                 :          3 :         skb->sk = sk;
    1992                 :            : #ifdef CONFIG_INET
    1993                 :          3 :         if (unlikely(!sk_fullsock(sk))) {
    1994                 :          0 :                 skb->destructor = sock_edemux;
    1995                 :            :                 sock_hold(sk);
    1996                 :          3 :                 return;
    1997                 :            :         }
    1998                 :            : #endif
    1999                 :          3 :         skb->destructor = sock_wfree;
    2000                 :            :         skb_set_hash_from_sk(skb, sk);
    2001                 :            :         /*
    2002                 :            :          * We used to take a refcount on sk, but following operation
    2003                 :            :          * is enough to guarantee sk_free() wont free this sock until
    2004                 :            :          * all in-flight packets are completed
    2005                 :            :          */
    2006                 :          3 :         refcount_add(skb->truesize, &sk->sk_wmem_alloc);
    2007                 :            : }
    2008                 :            : EXPORT_SYMBOL(skb_set_owner_w);
    2009                 :            : 
    2010                 :            : static bool can_skb_orphan_partial(const struct sk_buff *skb)
    2011                 :            : {
    2012                 :            : #ifdef CONFIG_TLS_DEVICE
    2013                 :            :         /* Drivers depend on in-order delivery for crypto offload,
    2014                 :            :          * partial orphan breaks out-of-order-OK logic.
    2015                 :            :          */
    2016                 :            :         if (skb->decrypted)
    2017                 :            :                 return false;
    2018                 :            : #endif
    2019                 :          0 :         return (skb->destructor == sock_wfree ||
    2020                 :            :                 (IS_ENABLED(CONFIG_INET) && skb->destructor == tcp_wfree));
    2021                 :            : }
    2022                 :            : 
    2023                 :            : /* This helper is used by netem, as it can hold packets in its
    2024                 :            :  * delay queue. We want to allow the owner socket to send more
    2025                 :            :  * packets, as if they were already TX completed by a typical driver.
    2026                 :            :  * But we also want to keep skb->sk set because some packet schedulers
    2027                 :            :  * rely on it (sch_fq for example).
    2028                 :            :  */
    2029                 :          0 : void skb_orphan_partial(struct sk_buff *skb)
    2030                 :            : {
    2031                 :          0 :         if (skb_is_tcp_pure_ack(skb))
    2032                 :          0 :                 return;
    2033                 :            : 
    2034                 :          0 :         if (can_skb_orphan_partial(skb)) {
    2035                 :          0 :                 struct sock *sk = skb->sk;
    2036                 :            : 
    2037                 :          0 :                 if (refcount_inc_not_zero(&sk->sk_refcnt)) {
    2038                 :          0 :                         WARN_ON(refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc));
    2039                 :          0 :                         skb->destructor = sock_efree;
    2040                 :            :                 }
    2041                 :            :         } else {
    2042                 :          0 :                 skb_orphan(skb);
    2043                 :            :         }
    2044                 :            : }
    2045                 :            : EXPORT_SYMBOL(skb_orphan_partial);
    2046                 :            : 
    2047                 :            : /*
    2048                 :            :  * Read buffer destructor automatically called from kfree_skb.
    2049                 :            :  */
    2050                 :          3 : void sock_rfree(struct sk_buff *skb)
    2051                 :            : {
    2052                 :          3 :         struct sock *sk = skb->sk;
    2053                 :          3 :         unsigned int len = skb->truesize;
    2054                 :            : 
    2055                 :          3 :         atomic_sub(len, &sk->sk_rmem_alloc);
    2056                 :          3 :         sk_mem_uncharge(sk, len);
    2057                 :          3 : }
    2058                 :            : EXPORT_SYMBOL(sock_rfree);
    2059                 :            : 
    2060                 :            : /*
    2061                 :            :  * Buffer destructor for skbs that are not used directly in read or write
    2062                 :            :  * path, e.g. for error handler skbs. Automatically called from kfree_skb.
    2063                 :            :  */
    2064                 :          0 : void sock_efree(struct sk_buff *skb)
    2065                 :            : {
    2066                 :          0 :         sock_put(skb->sk);
    2067                 :          0 : }
    2068                 :            : EXPORT_SYMBOL(sock_efree);
    2069                 :            : 
    2070                 :          3 : kuid_t sock_i_uid(struct sock *sk)
    2071                 :            : {
    2072                 :            :         kuid_t uid;
    2073                 :            : 
    2074                 :          3 :         read_lock_bh(&sk->sk_callback_lock);
    2075                 :          3 :         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
    2076                 :          3 :         read_unlock_bh(&sk->sk_callback_lock);
    2077                 :          3 :         return uid;
    2078                 :            : }
    2079                 :            : EXPORT_SYMBOL(sock_i_uid);
    2080                 :            : 
    2081                 :          0 : unsigned long sock_i_ino(struct sock *sk)
    2082                 :            : {
    2083                 :            :         unsigned long ino;
    2084                 :            : 
    2085                 :          0 :         read_lock_bh(&sk->sk_callback_lock);
    2086                 :          0 :         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
    2087                 :          0 :         read_unlock_bh(&sk->sk_callback_lock);
    2088                 :          0 :         return ino;
    2089                 :            : }
    2090                 :            : EXPORT_SYMBOL(sock_i_ino);
    2091                 :            : 
    2092                 :            : /*
    2093                 :            :  * Allocate a skb from the socket's send buffer.
    2094                 :            :  */
    2095                 :          3 : struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
    2096                 :            :                              gfp_t priority)
    2097                 :            : {
    2098                 :          3 :         if (force ||
    2099                 :            :             refcount_read(&sk->sk_wmem_alloc) < READ_ONCE(sk->sk_sndbuf)) {
    2100                 :            :                 struct sk_buff *skb = alloc_skb(size, priority);
    2101                 :            : 
    2102                 :          3 :                 if (skb) {
    2103                 :          3 :                         skb_set_owner_w(skb, sk);
    2104                 :          3 :                         return skb;
    2105                 :            :                 }
    2106                 :            :         }
    2107                 :            :         return NULL;
    2108                 :            : }
    2109                 :            : EXPORT_SYMBOL(sock_wmalloc);
    2110                 :            : 
    2111                 :          0 : static void sock_ofree(struct sk_buff *skb)
    2112                 :            : {
    2113                 :          0 :         struct sock *sk = skb->sk;
    2114                 :            : 
    2115                 :          0 :         atomic_sub(skb->truesize, &sk->sk_omem_alloc);
    2116                 :          0 : }
    2117                 :            : 
    2118                 :          0 : struct sk_buff *sock_omalloc(struct sock *sk, unsigned long size,
    2119                 :            :                              gfp_t priority)
    2120                 :            : {
    2121                 :            :         struct sk_buff *skb;
    2122                 :            : 
    2123                 :            :         /* small safe race: SKB_TRUESIZE may differ from final skb->truesize */
    2124                 :          0 :         if (atomic_read(&sk->sk_omem_alloc) + SKB_TRUESIZE(size) >
    2125                 :            :             sysctl_optmem_max)
    2126                 :            :                 return NULL;
    2127                 :            : 
    2128                 :            :         skb = alloc_skb(size, priority);
    2129                 :          0 :         if (!skb)
    2130                 :            :                 return NULL;
    2131                 :            : 
    2132                 :          0 :         atomic_add(skb->truesize, &sk->sk_omem_alloc);
    2133                 :          0 :         skb->sk = sk;
    2134                 :          0 :         skb->destructor = sock_ofree;
    2135                 :          0 :         return skb;
    2136                 :            : }
    2137                 :            : 
    2138                 :            : /*
    2139                 :            :  * Allocate a memory block from the socket's option memory buffer.
    2140                 :            :  */
    2141                 :          3 : void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
    2142                 :            : {
    2143                 :          3 :         if ((unsigned int)size <= sysctl_optmem_max &&
    2144                 :          3 :             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
    2145                 :            :                 void *mem;
    2146                 :            :                 /* First do the add, to avoid the race if kmalloc
    2147                 :            :                  * might sleep.
    2148                 :            :                  */
    2149                 :          3 :                 atomic_add(size, &sk->sk_omem_alloc);
    2150                 :            :                 mem = kmalloc(size, priority);
    2151                 :          3 :                 if (mem)
    2152                 :            :                         return mem;
    2153                 :            :                 atomic_sub(size, &sk->sk_omem_alloc);
    2154                 :            :         }
    2155                 :            :         return NULL;
    2156                 :            : }
    2157                 :            : EXPORT_SYMBOL(sock_kmalloc);
    2158                 :            : 
    2159                 :            : /* Free an option memory block. Note, we actually want the inline
    2160                 :            :  * here as this allows gcc to detect the nullify and fold away the
    2161                 :            :  * condition entirely.
    2162                 :            :  */
    2163                 :          1 : static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
    2164                 :            :                                   const bool nullify)
    2165                 :            : {
    2166                 :          1 :         if (WARN_ON_ONCE(!mem))
    2167                 :          1 :                 return;
    2168                 :          1 :         if (nullify)
    2169                 :          0 :                 kzfree(mem);
    2170                 :            :         else
    2171                 :          1 :                 kfree(mem);
    2172                 :          1 :         atomic_sub(size, &sk->sk_omem_alloc);
    2173                 :            : }
    2174                 :            : 
    2175                 :          1 : void sock_kfree_s(struct sock *sk, void *mem, int size)
    2176                 :            : {
    2177                 :          1 :         __sock_kfree_s(sk, mem, size, false);
    2178                 :          1 : }
    2179                 :            : EXPORT_SYMBOL(sock_kfree_s);
    2180                 :            : 
    2181                 :          0 : void sock_kzfree_s(struct sock *sk, void *mem, int size)
    2182                 :            : {
    2183                 :          0 :         __sock_kfree_s(sk, mem, size, true);
    2184                 :          0 : }
    2185                 :            : EXPORT_SYMBOL(sock_kzfree_s);
    2186                 :            : 
    2187                 :            : /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
    2188                 :            :    I think, these locks should be removed for datagram sockets.
    2189                 :            :  */
    2190                 :          0 : static long sock_wait_for_wmem(struct sock *sk, long timeo)
    2191                 :            : {
    2192                 :          0 :         DEFINE_WAIT(wait);
    2193                 :            : 
    2194                 :          0 :         sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
    2195                 :            :         for (;;) {
    2196                 :          0 :                 if (!timeo)
    2197                 :            :                         break;
    2198                 :          0 :                 if (signal_pending(current))
    2199                 :            :                         break;
    2200                 :          0 :                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
    2201                 :          0 :                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
    2202                 :          0 :                 if (refcount_read(&sk->sk_wmem_alloc) < READ_ONCE(sk->sk_sndbuf))
    2203                 :            :                         break;
    2204                 :          0 :                 if (sk->sk_shutdown & SEND_SHUTDOWN)
    2205                 :            :                         break;
    2206                 :          0 :                 if (sk->sk_err)
    2207                 :            :                         break;
    2208                 :          0 :                 timeo = schedule_timeout(timeo);
    2209                 :          0 :         }
    2210                 :          0 :         finish_wait(sk_sleep(sk), &wait);
    2211                 :          0 :         return timeo;
    2212                 :            : }
    2213                 :            : 
    2214                 :            : 
    2215                 :            : /*
    2216                 :            :  *      Generic send/receive buffer handlers
    2217                 :            :  */
    2218                 :            : 
    2219                 :          3 : struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
    2220                 :            :                                      unsigned long data_len, int noblock,
    2221                 :            :                                      int *errcode, int max_page_order)
    2222                 :            : {
    2223                 :            :         struct sk_buff *skb;
    2224                 :            :         long timeo;
    2225                 :            :         int err;
    2226                 :            : 
    2227                 :            :         timeo = sock_sndtimeo(sk, noblock);
    2228                 :            :         for (;;) {
    2229                 :          3 :                 err = sock_error(sk);
    2230                 :          3 :                 if (err != 0)
    2231                 :            :                         goto failure;
    2232                 :            : 
    2233                 :            :                 err = -EPIPE;
    2234                 :          3 :                 if (sk->sk_shutdown & SEND_SHUTDOWN)
    2235                 :            :                         goto failure;
    2236                 :            : 
    2237                 :          3 :                 if (sk_wmem_alloc_get(sk) < READ_ONCE(sk->sk_sndbuf))
    2238                 :            :                         break;
    2239                 :            : 
    2240                 :          1 :                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
    2241                 :          1 :                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
    2242                 :            :                 err = -EAGAIN;
    2243                 :          1 :                 if (!timeo)
    2244                 :            :                         goto failure;
    2245                 :          0 :                 if (signal_pending(current))
    2246                 :            :                         goto interrupted;
    2247                 :          0 :                 timeo = sock_wait_for_wmem(sk, timeo);
    2248                 :          0 :         }
    2249                 :          3 :         skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
    2250                 :            :                                    errcode, sk->sk_allocation);
    2251                 :          3 :         if (skb)
    2252                 :          3 :                 skb_set_owner_w(skb, sk);
    2253                 :          3 :         return skb;
    2254                 :            : 
    2255                 :            : interrupted:
    2256                 :            :         err = sock_intr_errno(timeo);
    2257                 :            : failure:
    2258                 :          3 :         *errcode = err;
    2259                 :          3 :         return NULL;
    2260                 :            : }
    2261                 :            : EXPORT_SYMBOL(sock_alloc_send_pskb);
    2262                 :            : 
    2263                 :          3 : struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
    2264                 :            :                                     int noblock, int *errcode)
    2265                 :            : {
    2266                 :          3 :         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode, 0);
    2267                 :            : }
    2268                 :            : EXPORT_SYMBOL(sock_alloc_send_skb);
    2269                 :            : 
    2270                 :          0 : int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
    2271                 :            :                      struct sockcm_cookie *sockc)
    2272                 :            : {
    2273                 :            :         u32 tsflags;
    2274                 :            : 
    2275                 :          0 :         switch (cmsg->cmsg_type) {
    2276                 :            :         case SO_MARK:
    2277                 :          0 :                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
    2278                 :            :                         return -EPERM;
    2279                 :          0 :                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
    2280                 :            :                         return -EINVAL;
    2281                 :          0 :                 sockc->mark = *(u32 *)CMSG_DATA(cmsg);
    2282                 :          0 :                 break;
    2283                 :            :         case SO_TIMESTAMPING_OLD:
    2284                 :          0 :                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
    2285                 :            :                         return -EINVAL;
    2286                 :            : 
    2287                 :          0 :                 tsflags = *(u32 *)CMSG_DATA(cmsg);
    2288                 :          0 :                 if (tsflags & ~SOF_TIMESTAMPING_TX_RECORD_MASK)
    2289                 :            :                         return -EINVAL;
    2290                 :            : 
    2291                 :          0 :                 sockc->tsflags &= ~SOF_TIMESTAMPING_TX_RECORD_MASK;
    2292                 :          0 :                 sockc->tsflags |= tsflags;
    2293                 :          0 :                 break;
    2294                 :            :         case SCM_TXTIME:
    2295                 :          0 :                 if (!sock_flag(sk, SOCK_TXTIME))
    2296                 :            :                         return -EINVAL;
    2297                 :          0 :                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u64)))
    2298                 :            :                         return -EINVAL;
    2299                 :          0 :                 sockc->transmit_time = get_unaligned((u64 *)CMSG_DATA(cmsg));
    2300                 :          0 :                 break;
    2301                 :            :         /* SCM_RIGHTS and SCM_CREDENTIALS are semantically in SOL_UNIX. */
    2302                 :            :         case SCM_RIGHTS:
    2303                 :            :         case SCM_CREDENTIALS:
    2304                 :            :                 break;
    2305                 :            :         default:
    2306                 :            :                 return -EINVAL;
    2307                 :            :         }
    2308                 :            :         return 0;
    2309                 :            : }
    2310                 :            : EXPORT_SYMBOL(__sock_cmsg_send);
    2311                 :            : 
    2312                 :          0 : int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
    2313                 :            :                    struct sockcm_cookie *sockc)
    2314                 :            : {
    2315                 :            :         struct cmsghdr *cmsg;
    2316                 :            :         int ret;
    2317                 :            : 
    2318                 :          0 :         for_each_cmsghdr(cmsg, msg) {
    2319                 :          0 :                 if (!CMSG_OK(msg, cmsg))
    2320                 :            :                         return -EINVAL;
    2321                 :          0 :                 if (cmsg->cmsg_level != SOL_SOCKET)
    2322                 :          0 :                         continue;
    2323                 :          0 :                 ret = __sock_cmsg_send(sk, msg, cmsg, sockc);
    2324                 :          0 :                 if (ret)
    2325                 :          0 :                         return ret;
    2326                 :            :         }
    2327                 :            :         return 0;
    2328                 :            : }
    2329                 :            : EXPORT_SYMBOL(sock_cmsg_send);
    2330                 :            : 
    2331                 :            : static void sk_enter_memory_pressure(struct sock *sk)
    2332                 :            : {
    2333                 :          0 :         if (!sk->sk_prot->enter_memory_pressure)
    2334                 :            :                 return;
    2335                 :            : 
    2336                 :          0 :         sk->sk_prot->enter_memory_pressure(sk);
    2337                 :            : }
    2338                 :            : 
    2339                 :          3 : static void sk_leave_memory_pressure(struct sock *sk)
    2340                 :            : {
    2341                 :          3 :         if (sk->sk_prot->leave_memory_pressure) {
    2342                 :          1 :                 sk->sk_prot->leave_memory_pressure(sk);
    2343                 :            :         } else {
    2344                 :          3 :                 unsigned long *memory_pressure = sk->sk_prot->memory_pressure;
    2345                 :            : 
    2346                 :          3 :                 if (memory_pressure && READ_ONCE(*memory_pressure))
    2347                 :            :                         WRITE_ONCE(*memory_pressure, 0);
    2348                 :            :         }
    2349                 :          3 : }
    2350                 :            : 
    2351                 :            : /* On 32bit arches, an skb frag is limited to 2^15 */
    2352                 :            : #define SKB_FRAG_PAGE_ORDER     get_order(32768)
    2353                 :            : DEFINE_STATIC_KEY_FALSE(net_high_order_alloc_disable_key);
    2354                 :            : 
    2355                 :            : /**
    2356                 :            :  * skb_page_frag_refill - check that a page_frag contains enough room
    2357                 :            :  * @sz: minimum size of the fragment we want to get
    2358                 :            :  * @pfrag: pointer to page_frag
    2359                 :            :  * @gfp: priority for memory allocation
    2360                 :            :  *
    2361                 :            :  * Note: While this allocator tries to use high order pages, there is
    2362                 :            :  * no guarantee that allocations succeed. Therefore, @sz MUST be
    2363                 :            :  * less or equal than PAGE_SIZE.
    2364                 :            :  */
    2365                 :          1 : bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
    2366                 :            : {
    2367                 :          1 :         if (pfrag->page) {
    2368                 :          1 :                 if (page_ref_count(pfrag->page) == 1) {
    2369                 :          1 :                         pfrag->offset = 0;
    2370                 :          1 :                         return true;
    2371                 :            :                 }
    2372                 :          1 :                 if (pfrag->offset + sz <= pfrag->size)
    2373                 :            :                         return true;
    2374                 :          0 :                 put_page(pfrag->page);
    2375                 :            :         }
    2376                 :            : 
    2377                 :          1 :         pfrag->offset = 0;
    2378                 :          1 :         if (SKB_FRAG_PAGE_ORDER &&
    2379                 :          1 :             !static_branch_unlikely(&net_high_order_alloc_disable_key)) {
    2380                 :            :                 /* Avoid direct reclaim but allow kswapd to wake */
    2381                 :          1 :                 pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) |
    2382                 :            :                                           __GFP_COMP | __GFP_NOWARN |
    2383                 :            :                                           __GFP_NORETRY,
    2384                 :            :                                           SKB_FRAG_PAGE_ORDER);
    2385                 :          1 :                 if (likely(pfrag->page)) {
    2386                 :          1 :                         pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
    2387                 :          1 :                         return true;
    2388                 :            :                 }
    2389                 :            :         }
    2390                 :          0 :         pfrag->page = alloc_page(gfp);
    2391                 :          0 :         if (likely(pfrag->page)) {
    2392                 :          0 :                 pfrag->size = PAGE_SIZE;
    2393                 :          0 :                 return true;
    2394                 :            :         }
    2395                 :            :         return false;
    2396                 :            : }
    2397                 :            : EXPORT_SYMBOL(skb_page_frag_refill);
    2398                 :            : 
    2399                 :          1 : bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
    2400                 :            : {
    2401                 :          1 :         if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
    2402                 :            :                 return true;
    2403                 :            : 
    2404                 :            :         sk_enter_memory_pressure(sk);
    2405                 :            :         sk_stream_moderate_sndbuf(sk);
    2406                 :            :         return false;
    2407                 :            : }
    2408                 :            : EXPORT_SYMBOL(sk_page_frag_refill);
    2409                 :            : 
    2410                 :          0 : static void __lock_sock(struct sock *sk)
    2411                 :            :         __releases(&sk->sk_lock.slock)
    2412                 :            :         __acquires(&sk->sk_lock.slock)
    2413                 :            : {
    2414                 :          0 :         DEFINE_WAIT(wait);
    2415                 :            : 
    2416                 :            :         for (;;) {
    2417                 :          0 :                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
    2418                 :            :                                         TASK_UNINTERRUPTIBLE);
    2419                 :            :                 spin_unlock_bh(&sk->sk_lock.slock);
    2420                 :          0 :                 schedule();
    2421                 :            :                 spin_lock_bh(&sk->sk_lock.slock);
    2422                 :          0 :                 if (!sock_owned_by_user(sk))
    2423                 :            :                         break;
    2424                 :            :         }
    2425                 :          0 :         finish_wait(&sk->sk_lock.wq, &wait);
    2426                 :          0 : }
    2427                 :            : 
    2428                 :          1 : void __release_sock(struct sock *sk)
    2429                 :            :         __releases(&sk->sk_lock.slock)
    2430                 :            :         __acquires(&sk->sk_lock.slock)
    2431                 :            : {
    2432                 :            :         struct sk_buff *skb, *next;
    2433                 :            : 
    2434                 :          1 :         while ((skb = sk->sk_backlog.head) != NULL) {
    2435                 :          1 :                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
    2436                 :            : 
    2437                 :            :                 spin_unlock_bh(&sk->sk_lock.slock);
    2438                 :            : 
    2439                 :            :                 do {
    2440                 :          1 :                         next = skb->next;
    2441                 :            :                         prefetch(next);
    2442                 :          1 :                         WARN_ON_ONCE(skb_dst_is_noref(skb));
    2443                 :            :                         skb_mark_not_on_list(skb);
    2444                 :          1 :                         sk_backlog_rcv(sk, skb);
    2445                 :            : 
    2446                 :          1 :                         cond_resched();
    2447                 :            : 
    2448                 :            :                         skb = next;
    2449                 :          1 :                 } while (skb != NULL);
    2450                 :            : 
    2451                 :            :                 spin_lock_bh(&sk->sk_lock.slock);
    2452                 :            :         }
    2453                 :            : 
    2454                 :            :         /*
    2455                 :            :          * Doing the zeroing here guarantee we can not loop forever
    2456                 :            :          * while a wild producer attempts to flood us.
    2457                 :            :          */
    2458                 :          1 :         sk->sk_backlog.len = 0;
    2459                 :          1 : }
    2460                 :            : 
    2461                 :          0 : void __sk_flush_backlog(struct sock *sk)
    2462                 :            : {
    2463                 :            :         spin_lock_bh(&sk->sk_lock.slock);
    2464                 :          0 :         __release_sock(sk);
    2465                 :            :         spin_unlock_bh(&sk->sk_lock.slock);
    2466                 :          0 : }
    2467                 :            : 
    2468                 :            : /**
    2469                 :            :  * sk_wait_data - wait for data to arrive at sk_receive_queue
    2470                 :            :  * @sk:    sock to wait on
    2471                 :            :  * @timeo: for how long
    2472                 :            :  * @skb:   last skb seen on sk_receive_queue
    2473                 :            :  *
    2474                 :            :  * Now socket state including sk->sk_err is changed only under lock,
    2475                 :            :  * hence we may omit checks after joining wait queue.
    2476                 :            :  * We check receive queue before schedule() only as optimization;
    2477                 :            :  * it is very likely that release_sock() added new data.
    2478                 :            :  */
    2479                 :          0 : int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
    2480                 :            : {
    2481                 :          0 :         DEFINE_WAIT_FUNC(wait, woken_wake_function);
    2482                 :            :         int rc;
    2483                 :            : 
    2484                 :          0 :         add_wait_queue(sk_sleep(sk), &wait);
    2485                 :          0 :         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
    2486                 :          0 :         rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
    2487                 :          0 :         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
    2488                 :          0 :         remove_wait_queue(sk_sleep(sk), &wait);
    2489                 :          0 :         return rc;
    2490                 :            : }
    2491                 :            : EXPORT_SYMBOL(sk_wait_data);
    2492                 :            : 
    2493                 :            : /**
    2494                 :            :  *      __sk_mem_raise_allocated - increase memory_allocated
    2495                 :            :  *      @sk: socket
    2496                 :            :  *      @size: memory size to allocate
    2497                 :            :  *      @amt: pages to allocate
    2498                 :            :  *      @kind: allocation type
    2499                 :            :  *
    2500                 :            :  *      Similar to __sk_mem_schedule(), but does not update sk_forward_alloc
    2501                 :            :  */
    2502                 :          3 : int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
    2503                 :            : {
    2504                 :          3 :         struct proto *prot = sk->sk_prot;
    2505                 :          3 :         long allocated = sk_memory_allocated_add(sk, amt);
    2506                 :            :         bool charged = true;
    2507                 :            : 
    2508                 :          3 :         if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
    2509                 :          0 :             !(charged = mem_cgroup_charge_skmem(sk->sk_memcg, amt)))
    2510                 :            :                 goto suppress_allocation;
    2511                 :            : 
    2512                 :            :         /* Under limit. */
    2513                 :          3 :         if (allocated <= sk_prot_mem_limits(sk, 0)) {
    2514                 :          3 :                 sk_leave_memory_pressure(sk);
    2515                 :          3 :                 return 1;
    2516                 :            :         }
    2517                 :            : 
    2518                 :            :         /* Under pressure. */
    2519                 :          0 :         if (allocated > sk_prot_mem_limits(sk, 1))
    2520                 :            :                 sk_enter_memory_pressure(sk);
    2521                 :            : 
    2522                 :            :         /* Over hard limit. */
    2523                 :          0 :         if (allocated > sk_prot_mem_limits(sk, 2))
    2524                 :            :                 goto suppress_allocation;
    2525                 :            : 
    2526                 :            :         /* guarantee minimum buffer size under pressure */
    2527                 :          0 :         if (kind == SK_MEM_RECV) {
    2528                 :          0 :                 if (atomic_read(&sk->sk_rmem_alloc) < sk_get_rmem0(sk, prot))
    2529                 :            :                         return 1;
    2530                 :            : 
    2531                 :            :         } else { /* SK_MEM_SEND */
    2532                 :            :                 int wmem0 = sk_get_wmem0(sk, prot);
    2533                 :            : 
    2534                 :          0 :                 if (sk->sk_type == SOCK_STREAM) {
    2535                 :          0 :                         if (sk->sk_wmem_queued < wmem0)
    2536                 :            :                                 return 1;
    2537                 :          0 :                 } else if (refcount_read(&sk->sk_wmem_alloc) < wmem0) {
    2538                 :            :                                 return 1;
    2539                 :            :                 }
    2540                 :            :         }
    2541                 :            : 
    2542                 :          0 :         if (sk_has_memory_pressure(sk)) {
    2543                 :            :                 u64 alloc;
    2544                 :            : 
    2545                 :          0 :                 if (!sk_under_memory_pressure(sk))
    2546                 :            :                         return 1;
    2547                 :            :                 alloc = sk_sockets_allocated_read_positive(sk);
    2548                 :          0 :                 if (sk_prot_mem_limits(sk, 2) > alloc *
    2549                 :          0 :                     sk_mem_pages(sk->sk_wmem_queued +
    2550                 :          0 :                                  atomic_read(&sk->sk_rmem_alloc) +
    2551                 :          0 :                                  sk->sk_forward_alloc))
    2552                 :            :                         return 1;
    2553                 :            :         }
    2554                 :            : 
    2555                 :            : suppress_allocation:
    2556                 :            : 
    2557                 :          0 :         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
    2558                 :            :                 sk_stream_moderate_sndbuf(sk);
    2559                 :            : 
    2560                 :            :                 /* Fail only if socket is _under_ its sndbuf.
    2561                 :            :                  * In this case we cannot block, so that we have to fail.
    2562                 :            :                  */
    2563                 :          0 :                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
    2564                 :            :                         return 1;
    2565                 :            :         }
    2566                 :            : 
    2567                 :          0 :         if (kind == SK_MEM_SEND || (kind == SK_MEM_RECV && charged))
    2568                 :          0 :                 trace_sock_exceed_buf_limit(sk, prot, allocated, kind);
    2569                 :            : 
    2570                 :          0 :         sk_memory_allocated_sub(sk, amt);
    2571                 :            : 
    2572                 :          0 :         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
    2573                 :          0 :                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amt);
    2574                 :            : 
    2575                 :            :         return 0;
    2576                 :            : }
    2577                 :            : EXPORT_SYMBOL(__sk_mem_raise_allocated);
    2578                 :            : 
    2579                 :            : /**
    2580                 :            :  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
    2581                 :            :  *      @sk: socket
    2582                 :            :  *      @size: memory size to allocate
    2583                 :            :  *      @kind: allocation type
    2584                 :            :  *
    2585                 :            :  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
    2586                 :            :  *      rmem allocation. This function assumes that protocols which have
    2587                 :            :  *      memory_pressure use sk_wmem_queued as write buffer accounting.
    2588                 :            :  */
    2589                 :          1 : int __sk_mem_schedule(struct sock *sk, int size, int kind)
    2590                 :            : {
    2591                 :            :         int ret, amt = sk_mem_pages(size);
    2592                 :            : 
    2593                 :          1 :         sk->sk_forward_alloc += amt << SK_MEM_QUANTUM_SHIFT;
    2594                 :          1 :         ret = __sk_mem_raise_allocated(sk, size, amt, kind);
    2595                 :          1 :         if (!ret)
    2596                 :          0 :                 sk->sk_forward_alloc -= amt << SK_MEM_QUANTUM_SHIFT;
    2597                 :          1 :         return ret;
    2598                 :            : }
    2599                 :            : EXPORT_SYMBOL(__sk_mem_schedule);
    2600                 :            : 
    2601                 :            : /**
    2602                 :            :  *      __sk_mem_reduce_allocated - reclaim memory_allocated
    2603                 :            :  *      @sk: socket
    2604                 :            :  *      @amount: number of quanta
    2605                 :            :  *
    2606                 :            :  *      Similar to __sk_mem_reclaim(), but does not update sk_forward_alloc
    2607                 :            :  */
    2608                 :          3 : void __sk_mem_reduce_allocated(struct sock *sk, int amount)
    2609                 :            : {
    2610                 :          3 :         sk_memory_allocated_sub(sk, amount);
    2611                 :            : 
    2612                 :          3 :         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
    2613                 :          0 :                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amount);
    2614                 :            : 
    2615                 :          3 :         if (sk_under_memory_pressure(sk) &&
    2616                 :            :             (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
    2617                 :          0 :                 sk_leave_memory_pressure(sk);
    2618                 :          3 : }
    2619                 :            : EXPORT_SYMBOL(__sk_mem_reduce_allocated);
    2620                 :            : 
    2621                 :            : /**
    2622                 :            :  *      __sk_mem_reclaim - reclaim sk_forward_alloc and memory_allocated
    2623                 :            :  *      @sk: socket
    2624                 :            :  *      @amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)
    2625                 :            :  */
    2626                 :          1 : void __sk_mem_reclaim(struct sock *sk, int amount)
    2627                 :            : {
    2628                 :          1 :         amount >>= SK_MEM_QUANTUM_SHIFT;
    2629                 :          1 :         sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
    2630                 :          1 :         __sk_mem_reduce_allocated(sk, amount);
    2631                 :          1 : }
    2632                 :            : EXPORT_SYMBOL(__sk_mem_reclaim);
    2633                 :            : 
    2634                 :          0 : int sk_set_peek_off(struct sock *sk, int val)
    2635                 :            : {
    2636                 :          0 :         sk->sk_peek_off = val;
    2637                 :          0 :         return 0;
    2638                 :            : }
    2639                 :            : EXPORT_SYMBOL_GPL(sk_set_peek_off);
    2640                 :            : 
    2641                 :            : /*
    2642                 :            :  * Set of default routines for initialising struct proto_ops when
    2643                 :            :  * the protocol does not support a particular function. In certain
    2644                 :            :  * cases where it makes no sense for a protocol to have a "do nothing"
    2645                 :            :  * function, some default processing is provided.
    2646                 :            :  */
    2647                 :            : 
    2648                 :          0 : int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
    2649                 :            : {
    2650                 :          0 :         return -EOPNOTSUPP;
    2651                 :            : }
    2652                 :            : EXPORT_SYMBOL(sock_no_bind);
    2653                 :            : 
    2654                 :          0 : int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
    2655                 :            :                     int len, int flags)
    2656                 :            : {
    2657                 :          0 :         return -EOPNOTSUPP;
    2658                 :            : }
    2659                 :            : EXPORT_SYMBOL(sock_no_connect);
    2660                 :            : 
    2661                 :          0 : int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
    2662                 :            : {
    2663                 :          0 :         return -EOPNOTSUPP;
    2664                 :            : }
    2665                 :            : EXPORT_SYMBOL(sock_no_socketpair);
    2666                 :            : 
    2667                 :          0 : int sock_no_accept(struct socket *sock, struct socket *newsock, int flags,
    2668                 :            :                    bool kern)
    2669                 :            : {
    2670                 :          0 :         return -EOPNOTSUPP;
    2671                 :            : }
    2672                 :            : EXPORT_SYMBOL(sock_no_accept);
    2673                 :            : 
    2674                 :          0 : int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
    2675                 :            :                     int peer)
    2676                 :            : {
    2677                 :          0 :         return -EOPNOTSUPP;
    2678                 :            : }
    2679                 :            : EXPORT_SYMBOL(sock_no_getname);
    2680                 :            : 
    2681                 :          0 : int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
    2682                 :            : {
    2683                 :          0 :         return -EOPNOTSUPP;
    2684                 :            : }
    2685                 :            : EXPORT_SYMBOL(sock_no_ioctl);
    2686                 :            : 
    2687                 :          0 : int sock_no_listen(struct socket *sock, int backlog)
    2688                 :            : {
    2689                 :          0 :         return -EOPNOTSUPP;
    2690                 :            : }
    2691                 :            : EXPORT_SYMBOL(sock_no_listen);
    2692                 :            : 
    2693                 :          0 : int sock_no_shutdown(struct socket *sock, int how)
    2694                 :            : {
    2695                 :          0 :         return -EOPNOTSUPP;
    2696                 :            : }
    2697                 :            : EXPORT_SYMBOL(sock_no_shutdown);
    2698                 :            : 
    2699                 :          0 : int sock_no_setsockopt(struct socket *sock, int level, int optname,
    2700                 :            :                     char __user *optval, unsigned int optlen)
    2701                 :            : {
    2702                 :          0 :         return -EOPNOTSUPP;
    2703                 :            : }
    2704                 :            : EXPORT_SYMBOL(sock_no_setsockopt);
    2705                 :            : 
    2706                 :          0 : int sock_no_getsockopt(struct socket *sock, int level, int optname,
    2707                 :            :                     char __user *optval, int __user *optlen)
    2708                 :            : {
    2709                 :          0 :         return -EOPNOTSUPP;
    2710                 :            : }
    2711                 :            : EXPORT_SYMBOL(sock_no_getsockopt);
    2712                 :            : 
    2713                 :          0 : int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
    2714                 :            : {
    2715                 :          0 :         return -EOPNOTSUPP;
    2716                 :            : }
    2717                 :            : EXPORT_SYMBOL(sock_no_sendmsg);
    2718                 :            : 
    2719                 :          0 : int sock_no_sendmsg_locked(struct sock *sk, struct msghdr *m, size_t len)
    2720                 :            : {
    2721                 :          0 :         return -EOPNOTSUPP;
    2722                 :            : }
    2723                 :            : EXPORT_SYMBOL(sock_no_sendmsg_locked);
    2724                 :            : 
    2725                 :          0 : int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
    2726                 :            :                     int flags)
    2727                 :            : {
    2728                 :          0 :         return -EOPNOTSUPP;
    2729                 :            : }
    2730                 :            : EXPORT_SYMBOL(sock_no_recvmsg);
    2731                 :            : 
    2732                 :          0 : int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
    2733                 :            : {
    2734                 :            :         /* Mirror missing mmap method error code */
    2735                 :          0 :         return -ENODEV;
    2736                 :            : }
    2737                 :            : EXPORT_SYMBOL(sock_no_mmap);
    2738                 :            : 
    2739                 :            : /*
    2740                 :            :  * When a file is received (via SCM_RIGHTS, etc), we must bump the
    2741                 :            :  * various sock-based usage counts.
    2742                 :            :  */
    2743                 :          0 : void __receive_sock(struct file *file)
    2744                 :            : {
    2745                 :            :         struct socket *sock;
    2746                 :            :         int error;
    2747                 :            : 
    2748                 :            :         /*
    2749                 :            :          * The resulting value of "error" is ignored here since we only
    2750                 :            :          * need to take action when the file is a socket and testing
    2751                 :            :          * "sock" for NULL is sufficient.
    2752                 :            :          */
    2753                 :          0 :         sock = sock_from_file(file, &error);
    2754                 :          0 :         if (sock) {
    2755                 :          0 :                 sock_update_netprioidx(&sock->sk->sk_cgrp_data);
    2756                 :          0 :                 sock_update_classid(&sock->sk->sk_cgrp_data);
    2757                 :            :         }
    2758                 :          0 : }
    2759                 :            : 
    2760                 :          0 : ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
    2761                 :            : {
    2762                 :            :         ssize_t res;
    2763                 :          0 :         struct msghdr msg = {.msg_flags = flags};
    2764                 :            :         struct kvec iov;
    2765                 :          0 :         char *kaddr = kmap(page);
    2766                 :          0 :         iov.iov_base = kaddr + offset;
    2767                 :          0 :         iov.iov_len = size;
    2768                 :          0 :         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
    2769                 :            :         kunmap(page);
    2770                 :          0 :         return res;
    2771                 :            : }
    2772                 :            : EXPORT_SYMBOL(sock_no_sendpage);
    2773                 :            : 
    2774                 :          0 : ssize_t sock_no_sendpage_locked(struct sock *sk, struct page *page,
    2775                 :            :                                 int offset, size_t size, int flags)
    2776                 :            : {
    2777                 :            :         ssize_t res;
    2778                 :          0 :         struct msghdr msg = {.msg_flags = flags};
    2779                 :            :         struct kvec iov;
    2780                 :          0 :         char *kaddr = kmap(page);
    2781                 :            : 
    2782                 :          0 :         iov.iov_base = kaddr + offset;
    2783                 :          0 :         iov.iov_len = size;
    2784                 :          0 :         res = kernel_sendmsg_locked(sk, &msg, &iov, 1, size);
    2785                 :            :         kunmap(page);
    2786                 :          0 :         return res;
    2787                 :            : }
    2788                 :            : EXPORT_SYMBOL(sock_no_sendpage_locked);
    2789                 :            : 
    2790                 :            : /*
    2791                 :            :  *      Default Socket Callbacks
    2792                 :            :  */
    2793                 :            : 
    2794                 :          3 : static void sock_def_wakeup(struct sock *sk)
    2795                 :            : {
    2796                 :            :         struct socket_wq *wq;
    2797                 :            : 
    2798                 :            :         rcu_read_lock();
    2799                 :          3 :         wq = rcu_dereference(sk->sk_wq);
    2800                 :          3 :         if (skwq_has_sleeper(wq))
    2801                 :          3 :                 wake_up_interruptible_all(&wq->wait);
    2802                 :            :         rcu_read_unlock();
    2803                 :          3 : }
    2804                 :            : 
    2805                 :          0 : static void sock_def_error_report(struct sock *sk)
    2806                 :            : {
    2807                 :            :         struct socket_wq *wq;
    2808                 :            : 
    2809                 :            :         rcu_read_lock();
    2810                 :          0 :         wq = rcu_dereference(sk->sk_wq);
    2811                 :          0 :         if (skwq_has_sleeper(wq))
    2812                 :          0 :                 wake_up_interruptible_poll(&wq->wait, EPOLLERR);
    2813                 :          0 :         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
    2814                 :            :         rcu_read_unlock();
    2815                 :          0 : }
    2816                 :            : 
    2817                 :          3 : static void sock_def_readable(struct sock *sk)
    2818                 :            : {
    2819                 :            :         struct socket_wq *wq;
    2820                 :            : 
    2821                 :            :         rcu_read_lock();
    2822                 :          3 :         wq = rcu_dereference(sk->sk_wq);
    2823                 :          3 :         if (skwq_has_sleeper(wq))
    2824                 :          3 :                 wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
    2825                 :            :                                                 EPOLLRDNORM | EPOLLRDBAND);
    2826                 :          3 :         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
    2827                 :            :         rcu_read_unlock();
    2828                 :          3 : }
    2829                 :            : 
    2830                 :          3 : static void sock_def_write_space(struct sock *sk)
    2831                 :            : {
    2832                 :            :         struct socket_wq *wq;
    2833                 :            : 
    2834                 :            :         rcu_read_lock();
    2835                 :            : 
    2836                 :            :         /* Do not wake up a writer until he can make "significant"
    2837                 :            :          * progress.  --DaveM
    2838                 :            :          */
    2839                 :          3 :         if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= READ_ONCE(sk->sk_sndbuf)) {
    2840                 :          3 :                 wq = rcu_dereference(sk->sk_wq);
    2841                 :          3 :                 if (skwq_has_sleeper(wq))
    2842                 :          3 :                         wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
    2843                 :            :                                                 EPOLLWRNORM | EPOLLWRBAND);
    2844                 :            : 
    2845                 :            :                 /* Should agree with poll, otherwise some programs break */
    2846                 :          3 :                 if (sock_writeable(sk))
    2847                 :          3 :                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
    2848                 :            :         }
    2849                 :            : 
    2850                 :            :         rcu_read_unlock();
    2851                 :          3 : }
    2852                 :            : 
    2853                 :          0 : static void sock_def_destruct(struct sock *sk)
    2854                 :            : {
    2855                 :          0 : }
    2856                 :            : 
    2857                 :          0 : void sk_send_sigurg(struct sock *sk)
    2858                 :            : {
    2859                 :          0 :         if (sk->sk_socket && sk->sk_socket->file)
    2860                 :          0 :                 if (send_sigurg(&sk->sk_socket->file->f_owner))
    2861                 :          0 :                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
    2862                 :          0 : }
    2863                 :            : EXPORT_SYMBOL(sk_send_sigurg);
    2864                 :            : 
    2865                 :          1 : void sk_reset_timer(struct sock *sk, struct timer_list* timer,
    2866                 :            :                     unsigned long expires)
    2867                 :            : {
    2868                 :          1 :         if (!mod_timer(timer, expires))
    2869                 :            :                 sock_hold(sk);
    2870                 :          1 : }
    2871                 :            : EXPORT_SYMBOL(sk_reset_timer);
    2872                 :            : 
    2873                 :          1 : void sk_stop_timer(struct sock *sk, struct timer_list* timer)
    2874                 :            : {
    2875                 :          1 :         if (del_timer(timer))
    2876                 :            :                 __sock_put(sk);
    2877                 :          1 : }
    2878                 :            : EXPORT_SYMBOL(sk_stop_timer);
    2879                 :            : 
    2880                 :          3 : void sock_init_data(struct socket *sock, struct sock *sk)
    2881                 :            : {
    2882                 :            :         sk_init_common(sk);
    2883                 :          3 :         sk->sk_send_head     =       NULL;
    2884                 :            : 
    2885                 :          3 :         timer_setup(&sk->sk_timer, NULL, 0);
    2886                 :            : 
    2887                 :          3 :         sk->sk_allocation    =       GFP_KERNEL;
    2888                 :          3 :         sk->sk_rcvbuf                =       sysctl_rmem_default;
    2889                 :          3 :         sk->sk_sndbuf                =       sysctl_wmem_default;
    2890                 :          3 :         sk->sk_state         =       TCP_CLOSE;
    2891                 :            :         sk_set_socket(sk, sock);
    2892                 :            : 
    2893                 :            :         sock_set_flag(sk, SOCK_ZAPPED);
    2894                 :            : 
    2895                 :          3 :         if (sock) {
    2896                 :          3 :                 sk->sk_type  =       sock->type;
    2897                 :          3 :                 RCU_INIT_POINTER(sk->sk_wq, &sock->wq);
    2898                 :          3 :                 sock->sk     =       sk;
    2899                 :          3 :                 sk->sk_uid   =       SOCK_INODE(sock)->i_uid;
    2900                 :            :         } else {
    2901                 :            :                 RCU_INIT_POINTER(sk->sk_wq, NULL);
    2902                 :          3 :                 sk->sk_uid   =       make_kuid(sock_net(sk)->user_ns, 0);
    2903                 :            :         }
    2904                 :            : 
    2905                 :          3 :         rwlock_init(&sk->sk_callback_lock);
    2906                 :            :         if (sk->sk_kern_sock)
    2907                 :            :                 lockdep_set_class_and_name(
    2908                 :            :                         &sk->sk_callback_lock,
    2909                 :            :                         af_kern_callback_keys + sk->sk_family,
    2910                 :            :                         af_family_kern_clock_key_strings[sk->sk_family]);
    2911                 :            :         else
    2912                 :            :                 lockdep_set_class_and_name(
    2913                 :            :                         &sk->sk_callback_lock,
    2914                 :            :                         af_callback_keys + sk->sk_family,
    2915                 :            :                         af_family_clock_key_strings[sk->sk_family]);
    2916                 :            : 
    2917                 :          3 :         sk->sk_state_change  =       sock_def_wakeup;
    2918                 :          3 :         sk->sk_data_ready    =       sock_def_readable;
    2919                 :          3 :         sk->sk_write_space   =       sock_def_write_space;
    2920                 :          3 :         sk->sk_error_report  =       sock_def_error_report;
    2921                 :          3 :         sk->sk_destruct              =       sock_def_destruct;
    2922                 :            : 
    2923                 :          3 :         sk->sk_frag.page     =       NULL;
    2924                 :          3 :         sk->sk_frag.offset   =       0;
    2925                 :          3 :         sk->sk_peek_off              =       -1;
    2926                 :            : 
    2927                 :          3 :         sk->sk_peer_pid      =       NULL;
    2928                 :          3 :         sk->sk_peer_cred     =       NULL;
    2929                 :          3 :         sk->sk_write_pending =       0;
    2930                 :          3 :         sk->sk_rcvlowat              =       1;
    2931                 :          3 :         sk->sk_rcvtimeo              =       MAX_SCHEDULE_TIMEOUT;
    2932                 :          3 :         sk->sk_sndtimeo              =       MAX_SCHEDULE_TIMEOUT;
    2933                 :            : 
    2934                 :          3 :         sk->sk_stamp = SK_DEFAULT_STAMP;
    2935                 :            : #if BITS_PER_LONG==32
    2936                 :          3 :         seqlock_init(&sk->sk_stamp_seq);
    2937                 :            : #endif
    2938                 :            :         atomic_set(&sk->sk_zckey, 0);
    2939                 :            : 
    2940                 :            : #ifdef CONFIG_NET_RX_BUSY_POLL
    2941                 :          3 :         sk->sk_napi_id               =       0;
    2942                 :          3 :         sk->sk_ll_usec               =       sysctl_net_busy_read;
    2943                 :            : #endif
    2944                 :            : 
    2945                 :          3 :         sk->sk_max_pacing_rate = ~0UL;
    2946                 :          3 :         sk->sk_pacing_rate = ~0UL;
    2947                 :            :         WRITE_ONCE(sk->sk_pacing_shift, 10);
    2948                 :          3 :         sk->sk_incoming_cpu = -1;
    2949                 :            : 
    2950                 :            :         sk_rx_queue_clear(sk);
    2951                 :            :         /*
    2952                 :            :          * Before updating sk_refcnt, we must commit prior changes to memory
    2953                 :            :          * (Documentation/RCU/rculist_nulls.txt for details)
    2954                 :            :          */
    2955                 :          3 :         smp_wmb();
    2956                 :            :         refcount_set(&sk->sk_refcnt, 1);
    2957                 :            :         atomic_set(&sk->sk_drops, 0);
    2958                 :          3 : }
    2959                 :            : EXPORT_SYMBOL(sock_init_data);
    2960                 :            : 
    2961                 :          3 : void lock_sock_nested(struct sock *sk, int subclass)
    2962                 :            : {
    2963                 :          3 :         might_sleep();
    2964                 :            :         spin_lock_bh(&sk->sk_lock.slock);
    2965                 :          3 :         if (sk->sk_lock.owned)
    2966                 :          0 :                 __lock_sock(sk);
    2967                 :          3 :         sk->sk_lock.owned = 1;
    2968                 :            :         spin_unlock(&sk->sk_lock.slock);
    2969                 :            :         /*
    2970                 :            :          * The sk_lock has mutex_lock() semantics here:
    2971                 :            :          */
    2972                 :            :         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
    2973                 :            :         local_bh_enable();
    2974                 :          3 : }
    2975                 :            : EXPORT_SYMBOL(lock_sock_nested);
    2976                 :            : 
    2977                 :          3 : void release_sock(struct sock *sk)
    2978                 :            : {
    2979                 :            :         spin_lock_bh(&sk->sk_lock.slock);
    2980                 :          3 :         if (sk->sk_backlog.tail)
    2981                 :          1 :                 __release_sock(sk);
    2982                 :            : 
    2983                 :            :         /* Warning : release_cb() might need to release sk ownership,
    2984                 :            :          * ie call sock_release_ownership(sk) before us.
    2985                 :            :          */
    2986                 :          3 :         if (sk->sk_prot->release_cb)
    2987                 :          3 :                 sk->sk_prot->release_cb(sk);
    2988                 :            : 
    2989                 :            :         sock_release_ownership(sk);
    2990                 :          3 :         if (waitqueue_active(&sk->sk_lock.wq))
    2991                 :          0 :                 wake_up(&sk->sk_lock.wq);
    2992                 :            :         spin_unlock_bh(&sk->sk_lock.slock);
    2993                 :          3 : }
    2994                 :            : EXPORT_SYMBOL(release_sock);
    2995                 :            : 
    2996                 :            : /**
    2997                 :            :  * lock_sock_fast - fast version of lock_sock
    2998                 :            :  * @sk: socket
    2999                 :            :  *
    3000                 :            :  * This version should be used for very small section, where process wont block
    3001                 :            :  * return false if fast path is taken:
    3002                 :            :  *
    3003                 :            :  *   sk_lock.slock locked, owned = 0, BH disabled
    3004                 :            :  *
    3005                 :            :  * return true if slow path is taken:
    3006                 :            :  *
    3007                 :            :  *   sk_lock.slock unlocked, owned = 1, BH enabled
    3008                 :            :  */
    3009                 :          3 : bool lock_sock_fast(struct sock *sk)
    3010                 :            : {
    3011                 :          3 :         might_sleep();
    3012                 :            :         spin_lock_bh(&sk->sk_lock.slock);
    3013                 :            : 
    3014                 :          3 :         if (!sk->sk_lock.owned)
    3015                 :            :                 /*
    3016                 :            :                  * Note : We must disable BH
    3017                 :            :                  */
    3018                 :            :                 return false;
    3019                 :            : 
    3020                 :          0 :         __lock_sock(sk);
    3021                 :          0 :         sk->sk_lock.owned = 1;
    3022                 :            :         spin_unlock(&sk->sk_lock.slock);
    3023                 :            :         /*
    3024                 :            :          * The sk_lock has mutex_lock() semantics here:
    3025                 :            :          */
    3026                 :            :         mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
    3027                 :            :         local_bh_enable();
    3028                 :          0 :         return true;
    3029                 :            : }
    3030                 :            : EXPORT_SYMBOL(lock_sock_fast);
    3031                 :            : 
    3032                 :          0 : int sock_gettstamp(struct socket *sock, void __user *userstamp,
    3033                 :            :                    bool timeval, bool time32)
    3034                 :            : {
    3035                 :          0 :         struct sock *sk = sock->sk;
    3036                 :            :         struct timespec64 ts;
    3037                 :            : 
    3038                 :          0 :         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
    3039                 :          0 :         ts = ktime_to_timespec64(sock_read_timestamp(sk));
    3040                 :          0 :         if (ts.tv_sec == -1)
    3041                 :            :                 return -ENOENT;
    3042                 :          0 :         if (ts.tv_sec == 0) {
    3043                 :            :                 ktime_t kt = ktime_get_real();
    3044                 :          0 :                 sock_write_timestamp(sk, kt);;
    3045                 :          0 :                 ts = ktime_to_timespec64(kt);
    3046                 :            :         }
    3047                 :            : 
    3048                 :          0 :         if (timeval)
    3049                 :          0 :                 ts.tv_nsec /= 1000;
    3050                 :            : 
    3051                 :            : #ifdef CONFIG_COMPAT_32BIT_TIME
    3052                 :          0 :         if (time32)
    3053                 :          0 :                 return put_old_timespec32(&ts, userstamp);
    3054                 :            : #endif
    3055                 :            : #ifdef CONFIG_SPARC64
    3056                 :            :         /* beware of padding in sparc64 timeval */
    3057                 :            :         if (timeval && !in_compat_syscall()) {
    3058                 :            :                 struct __kernel_old_timeval __user tv = {
    3059                 :            :                         .tv_sec = ts.tv_sec,
    3060                 :            :                         .tv_usec = ts.tv_nsec,
    3061                 :            :                 };
    3062                 :            :                 if (copy_to_user(userstamp, &tv, sizeof(tv)))
    3063                 :            :                         return -EFAULT;
    3064                 :            :                 return 0;
    3065                 :            :         }
    3066                 :            : #endif
    3067                 :          0 :         return put_timespec64(&ts, userstamp);
    3068                 :            : }
    3069                 :            : EXPORT_SYMBOL(sock_gettstamp);
    3070                 :            : 
    3071                 :          3 : void sock_enable_timestamp(struct sock *sk, int flag)
    3072                 :            : {
    3073                 :          3 :         if (!sock_flag(sk, flag)) {
    3074                 :          3 :                 unsigned long previous_flags = sk->sk_flags;
    3075                 :            : 
    3076                 :            :                 sock_set_flag(sk, flag);
    3077                 :            :                 /*
    3078                 :            :                  * we just set one of the two flags which require net
    3079                 :            :                  * time stamping, but time stamping might have been on
    3080                 :            :                  * already because of the other one
    3081                 :            :                  */
    3082                 :          3 :                 if (sock_needs_netstamp(sk) &&
    3083                 :          3 :                     !(previous_flags & SK_FLAGS_TIMESTAMP))
    3084                 :          3 :                         net_enable_timestamp();
    3085                 :            :         }
    3086                 :          3 : }
    3087                 :            : 
    3088                 :          0 : int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
    3089                 :            :                        int level, int type)
    3090                 :            : {
    3091                 :            :         struct sock_exterr_skb *serr;
    3092                 :            :         struct sk_buff *skb;
    3093                 :            :         int copied, err;
    3094                 :            : 
    3095                 :            :         err = -EAGAIN;
    3096                 :          0 :         skb = sock_dequeue_err_skb(sk);
    3097                 :          0 :         if (skb == NULL)
    3098                 :            :                 goto out;
    3099                 :            : 
    3100                 :          0 :         copied = skb->len;
    3101                 :          0 :         if (copied > len) {
    3102                 :          0 :                 msg->msg_flags |= MSG_TRUNC;
    3103                 :            :                 copied = len;
    3104                 :            :         }
    3105                 :            :         err = skb_copy_datagram_msg(skb, 0, msg, copied);
    3106                 :          0 :         if (err)
    3107                 :            :                 goto out_free_skb;
    3108                 :            : 
    3109                 :          0 :         sock_recv_timestamp(msg, sk, skb);
    3110                 :            : 
    3111                 :            :         serr = SKB_EXT_ERR(skb);
    3112                 :          0 :         put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
    3113                 :            : 
    3114                 :          0 :         msg->msg_flags |= MSG_ERRQUEUE;
    3115                 :            :         err = copied;
    3116                 :            : 
    3117                 :            : out_free_skb:
    3118                 :          0 :         kfree_skb(skb);
    3119                 :            : out:
    3120                 :          0 :         return err;
    3121                 :            : }
    3122                 :            : EXPORT_SYMBOL(sock_recv_errqueue);
    3123                 :            : 
    3124                 :            : /*
    3125                 :            :  *      Get a socket option on an socket.
    3126                 :            :  *
    3127                 :            :  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
    3128                 :            :  *      asynchronous errors should be reported by getsockopt. We assume
    3129                 :            :  *      this means if you specify SO_ERROR (otherwise whats the point of it).
    3130                 :            :  */
    3131                 :          1 : int sock_common_getsockopt(struct socket *sock, int level, int optname,
    3132                 :            :                            char __user *optval, int __user *optlen)
    3133                 :            : {
    3134                 :          1 :         struct sock *sk = sock->sk;
    3135                 :            : 
    3136                 :          1 :         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
    3137                 :            : }
    3138                 :            : EXPORT_SYMBOL(sock_common_getsockopt);
    3139                 :            : 
    3140                 :            : #ifdef CONFIG_COMPAT
    3141                 :            : int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
    3142                 :            :                                   char __user *optval, int __user *optlen)
    3143                 :            : {
    3144                 :            :         struct sock *sk = sock->sk;
    3145                 :            : 
    3146                 :            :         if (sk->sk_prot->compat_getsockopt != NULL)
    3147                 :            :                 return sk->sk_prot->compat_getsockopt(sk, level, optname,
    3148                 :            :                                                       optval, optlen);
    3149                 :            :         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
    3150                 :            : }
    3151                 :            : EXPORT_SYMBOL(compat_sock_common_getsockopt);
    3152                 :            : #endif
    3153                 :            : 
    3154                 :          1 : int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
    3155                 :            :                         int flags)
    3156                 :            : {
    3157                 :          1 :         struct sock *sk = sock->sk;
    3158                 :          1 :         int addr_len = 0;
    3159                 :            :         int err;
    3160                 :            : 
    3161                 :          1 :         err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
    3162                 :            :                                    flags & ~MSG_DONTWAIT, &addr_len);
    3163                 :          1 :         if (err >= 0)
    3164                 :          1 :                 msg->msg_namelen = addr_len;
    3165                 :          1 :         return err;
    3166                 :            : }
    3167                 :            : EXPORT_SYMBOL(sock_common_recvmsg);
    3168                 :            : 
    3169                 :            : /*
    3170                 :            :  *      Set socket options on an inet socket.
    3171                 :            :  */
    3172                 :          3 : int sock_common_setsockopt(struct socket *sock, int level, int optname,
    3173                 :            :                            char __user *optval, unsigned int optlen)
    3174                 :            : {
    3175                 :          3 :         struct sock *sk = sock->sk;
    3176                 :            : 
    3177                 :          3 :         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
    3178                 :            : }
    3179                 :            : EXPORT_SYMBOL(sock_common_setsockopt);
    3180                 :            : 
    3181                 :            : #ifdef CONFIG_COMPAT
    3182                 :            : int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
    3183                 :            :                                   char __user *optval, unsigned int optlen)
    3184                 :            : {
    3185                 :            :         struct sock *sk = sock->sk;
    3186                 :            : 
    3187                 :            :         if (sk->sk_prot->compat_setsockopt != NULL)
    3188                 :            :                 return sk->sk_prot->compat_setsockopt(sk, level, optname,
    3189                 :            :                                                       optval, optlen);
    3190                 :            :         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
    3191                 :            : }
    3192                 :            : EXPORT_SYMBOL(compat_sock_common_setsockopt);
    3193                 :            : #endif
    3194                 :            : 
    3195                 :          3 : void sk_common_release(struct sock *sk)
    3196                 :            : {
    3197                 :          3 :         if (sk->sk_prot->destroy)
    3198                 :          3 :                 sk->sk_prot->destroy(sk);
    3199                 :            : 
    3200                 :            :         /*
    3201                 :            :          * Observation: when sock_common_release is called, processes have
    3202                 :            :          * no access to socket. But net still has.
    3203                 :            :          * Step one, detach it from networking:
    3204                 :            :          *
    3205                 :            :          * A. Remove from hash tables.
    3206                 :            :          */
    3207                 :            : 
    3208                 :          3 :         sk->sk_prot->unhash(sk);
    3209                 :            : 
    3210                 :            :         /*
    3211                 :            :          * In this point socket cannot receive new packets, but it is possible
    3212                 :            :          * that some packets are in flight because some CPU runs receiver and
    3213                 :            :          * did hash table lookup before we unhashed socket. They will achieve
    3214                 :            :          * receive queue and will be purged by socket destructor.
    3215                 :            :          *
    3216                 :            :          * Also we still have packets pending on receive queue and probably,
    3217                 :            :          * our own packets waiting in device queues. sock_destroy will drain
    3218                 :            :          * receive queue, but transmitted packets will delay socket destruction
    3219                 :            :          * until the last reference will be released.
    3220                 :            :          */
    3221                 :            : 
    3222                 :          3 :         sock_orphan(sk);
    3223                 :            : 
    3224                 :          3 :         xfrm_sk_free_policy(sk);
    3225                 :            : 
    3226                 :            :         sk_refcnt_debug_release(sk);
    3227                 :            : 
    3228                 :          3 :         sock_put(sk);
    3229                 :          3 : }
    3230                 :            : EXPORT_SYMBOL(sk_common_release);
    3231                 :            : 
    3232                 :          0 : void sk_get_meminfo(const struct sock *sk, u32 *mem)
    3233                 :            : {
    3234                 :          0 :         memset(mem, 0, sizeof(*mem) * SK_MEMINFO_VARS);
    3235                 :            : 
    3236                 :          0 :         mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk);
    3237                 :          0 :         mem[SK_MEMINFO_RCVBUF] = READ_ONCE(sk->sk_rcvbuf);
    3238                 :          0 :         mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk);
    3239                 :          0 :         mem[SK_MEMINFO_SNDBUF] = READ_ONCE(sk->sk_sndbuf);
    3240                 :          0 :         mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc;
    3241                 :          0 :         mem[SK_MEMINFO_WMEM_QUEUED] = READ_ONCE(sk->sk_wmem_queued);
    3242                 :          0 :         mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc);
    3243                 :          0 :         mem[SK_MEMINFO_BACKLOG] = READ_ONCE(sk->sk_backlog.len);
    3244                 :          0 :         mem[SK_MEMINFO_DROPS] = atomic_read(&sk->sk_drops);
    3245                 :          0 : }
    3246                 :            : 
    3247                 :            : #ifdef CONFIG_PROC_FS
    3248                 :            : #define PROTO_INUSE_NR  64      /* should be enough for the first time */
    3249                 :            : struct prot_inuse {
    3250                 :            :         int val[PROTO_INUSE_NR];
    3251                 :            : };
    3252                 :            : 
    3253                 :            : static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
    3254                 :            : 
    3255                 :          3 : void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
    3256                 :            : {
    3257                 :          3 :         __this_cpu_add(net->core.prot_inuse->val[prot->inuse_idx], val);
    3258                 :          3 : }
    3259                 :            : EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
    3260                 :            : 
    3261                 :          0 : int sock_prot_inuse_get(struct net *net, struct proto *prot)
    3262                 :            : {
    3263                 :          0 :         int cpu, idx = prot->inuse_idx;
    3264                 :            :         int res = 0;
    3265                 :            : 
    3266                 :          0 :         for_each_possible_cpu(cpu)
    3267                 :          0 :                 res += per_cpu_ptr(net->core.prot_inuse, cpu)->val[idx];
    3268                 :            : 
    3269                 :          0 :         return res >= 0 ? res : 0;
    3270                 :            : }
    3271                 :            : EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
    3272                 :            : 
    3273                 :            : static void sock_inuse_add(struct net *net, int val)
    3274                 :            : {
    3275                 :          3 :         this_cpu_add(*net->core.sock_inuse, val);
    3276                 :            : }
    3277                 :            : 
    3278                 :          0 : int sock_inuse_get(struct net *net)
    3279                 :            : {
    3280                 :            :         int cpu, res = 0;
    3281                 :            : 
    3282                 :          0 :         for_each_possible_cpu(cpu)
    3283                 :          0 :                 res += *per_cpu_ptr(net->core.sock_inuse, cpu);
    3284                 :            : 
    3285                 :          0 :         return res;
    3286                 :            : }
    3287                 :            : 
    3288                 :            : EXPORT_SYMBOL_GPL(sock_inuse_get);
    3289                 :            : 
    3290                 :          3 : static int __net_init sock_inuse_init_net(struct net *net)
    3291                 :            : {
    3292                 :          3 :         net->core.prot_inuse = alloc_percpu(struct prot_inuse);
    3293                 :          3 :         if (net->core.prot_inuse == NULL)
    3294                 :            :                 return -ENOMEM;
    3295                 :            : 
    3296                 :          3 :         net->core.sock_inuse = alloc_percpu(int);
    3297                 :          3 :         if (net->core.sock_inuse == NULL)
    3298                 :            :                 goto out;
    3299                 :            : 
    3300                 :            :         return 0;
    3301                 :            : 
    3302                 :            : out:
    3303                 :          0 :         free_percpu(net->core.prot_inuse);
    3304                 :          0 :         return -ENOMEM;
    3305                 :            : }
    3306                 :            : 
    3307                 :          1 : static void __net_exit sock_inuse_exit_net(struct net *net)
    3308                 :            : {
    3309                 :          1 :         free_percpu(net->core.prot_inuse);
    3310                 :          1 :         free_percpu(net->core.sock_inuse);
    3311                 :          1 : }
    3312                 :            : 
    3313                 :            : static struct pernet_operations net_inuse_ops = {
    3314                 :            :         .init = sock_inuse_init_net,
    3315                 :            :         .exit = sock_inuse_exit_net,
    3316                 :            : };
    3317                 :            : 
    3318                 :          3 : static __init int net_inuse_init(void)
    3319                 :            : {
    3320                 :          3 :         if (register_pernet_subsys(&net_inuse_ops))
    3321                 :          0 :                 panic("Cannot initialize net inuse counters");
    3322                 :            : 
    3323                 :          3 :         return 0;
    3324                 :            : }
    3325                 :            : 
    3326                 :            : core_initcall(net_inuse_init);
    3327                 :            : 
    3328                 :          3 : static int assign_proto_idx(struct proto *prot)
    3329                 :            : {
    3330                 :          3 :         prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
    3331                 :            : 
    3332                 :          3 :         if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
    3333                 :          0 :                 pr_err("PROTO_INUSE_NR exhausted\n");
    3334                 :          0 :                 return -ENOSPC;
    3335                 :            :         }
    3336                 :            : 
    3337                 :          3 :         set_bit(prot->inuse_idx, proto_inuse_idx);
    3338                 :          3 :         return 0;
    3339                 :            : }
    3340                 :            : 
    3341                 :            : static void release_proto_idx(struct proto *prot)
    3342                 :            : {
    3343                 :          0 :         if (prot->inuse_idx != PROTO_INUSE_NR - 1)
    3344                 :          0 :                 clear_bit(prot->inuse_idx, proto_inuse_idx);
    3345                 :            : }
    3346                 :            : #else
    3347                 :            : static inline int assign_proto_idx(struct proto *prot)
    3348                 :            : {
    3349                 :            :         return 0;
    3350                 :            : }
    3351                 :            : 
    3352                 :            : static inline void release_proto_idx(struct proto *prot)
    3353                 :            : {
    3354                 :            : }
    3355                 :            : 
    3356                 :            : static void sock_inuse_add(struct net *net, int val)
    3357                 :            : {
    3358                 :            : }
    3359                 :            : #endif
    3360                 :            : 
    3361                 :          0 : static void tw_prot_cleanup(struct timewait_sock_ops *twsk_prot)
    3362                 :            : {
    3363                 :          0 :         if (!twsk_prot)
    3364                 :          0 :                 return;
    3365                 :          0 :         kfree(twsk_prot->twsk_slab_name);
    3366                 :          0 :         twsk_prot->twsk_slab_name = NULL;
    3367                 :          0 :         kmem_cache_destroy(twsk_prot->twsk_slab);
    3368                 :          0 :         twsk_prot->twsk_slab = NULL;
    3369                 :            : }
    3370                 :            : 
    3371                 :          0 : static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
    3372                 :            : {
    3373                 :          0 :         if (!rsk_prot)
    3374                 :          0 :                 return;
    3375                 :          0 :         kfree(rsk_prot->slab_name);
    3376                 :          0 :         rsk_prot->slab_name = NULL;
    3377                 :          0 :         kmem_cache_destroy(rsk_prot->slab);
    3378                 :          0 :         rsk_prot->slab = NULL;
    3379                 :            : }
    3380                 :            : 
    3381                 :          3 : static int req_prot_init(const struct proto *prot)
    3382                 :            : {
    3383                 :          3 :         struct request_sock_ops *rsk_prot = prot->rsk_prot;
    3384                 :            : 
    3385                 :          3 :         if (!rsk_prot)
    3386                 :            :                 return 0;
    3387                 :            : 
    3388                 :          3 :         rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
    3389                 :          3 :                                         prot->name);
    3390                 :          3 :         if (!rsk_prot->slab_name)
    3391                 :            :                 return -ENOMEM;
    3392                 :            : 
    3393                 :          3 :         rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
    3394                 :            :                                            rsk_prot->obj_size, 0,
    3395                 :          3 :                                            SLAB_ACCOUNT | prot->slab_flags,
    3396                 :            :                                            NULL);
    3397                 :            : 
    3398                 :          3 :         if (!rsk_prot->slab) {
    3399                 :          0 :                 pr_crit("%s: Can't create request sock SLAB cache!\n",
    3400                 :            :                         prot->name);
    3401                 :          0 :                 return -ENOMEM;
    3402                 :            :         }
    3403                 :            :         return 0;
    3404                 :            : }
    3405                 :            : 
    3406                 :          3 : int proto_register(struct proto *prot, int alloc_slab)
    3407                 :            : {
    3408                 :            :         int ret = -ENOBUFS;
    3409                 :            : 
    3410                 :          3 :         if (alloc_slab) {
    3411                 :          3 :                 prot->slab = kmem_cache_create_usercopy(prot->name,
    3412                 :            :                                         prot->obj_size, 0,
    3413                 :            :                                         SLAB_HWCACHE_ALIGN | SLAB_ACCOUNT |
    3414                 :          3 :                                         prot->slab_flags,
    3415                 :            :                                         prot->useroffset, prot->usersize,
    3416                 :            :                                         NULL);
    3417                 :            : 
    3418                 :          3 :                 if (prot->slab == NULL) {
    3419                 :          0 :                         pr_crit("%s: Can't create sock SLAB cache!\n",
    3420                 :            :                                 prot->name);
    3421                 :          0 :                         goto out;
    3422                 :            :                 }
    3423                 :            : 
    3424                 :          3 :                 if (req_prot_init(prot))
    3425                 :            :                         goto out_free_request_sock_slab;
    3426                 :            : 
    3427                 :          3 :                 if (prot->twsk_prot != NULL) {
    3428                 :          3 :                         prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
    3429                 :            : 
    3430                 :          3 :                         if (prot->twsk_prot->twsk_slab_name == NULL)
    3431                 :            :                                 goto out_free_request_sock_slab;
    3432                 :            : 
    3433                 :          3 :                         prot->twsk_prot->twsk_slab =
    3434                 :          3 :                                 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
    3435                 :            :                                                   prot->twsk_prot->twsk_obj_size,
    3436                 :            :                                                   0,
    3437                 :            :                                                   SLAB_ACCOUNT |
    3438                 :          3 :                                                   prot->slab_flags,
    3439                 :            :                                                   NULL);
    3440                 :          3 :                         if (prot->twsk_prot->twsk_slab == NULL)
    3441                 :            :                                 goto out_free_timewait_sock_slab;
    3442                 :            :                 }
    3443                 :            :         }
    3444                 :            : 
    3445                 :          3 :         mutex_lock(&proto_list_mutex);
    3446                 :          3 :         ret = assign_proto_idx(prot);
    3447                 :          3 :         if (ret) {
    3448                 :          0 :                 mutex_unlock(&proto_list_mutex);
    3449                 :          0 :                 goto out_free_timewait_sock_slab;
    3450                 :            :         }
    3451                 :          3 :         list_add(&prot->node, &proto_list);
    3452                 :          3 :         mutex_unlock(&proto_list_mutex);
    3453                 :          3 :         return ret;
    3454                 :            : 
    3455                 :            : out_free_timewait_sock_slab:
    3456                 :          0 :         if (alloc_slab && prot->twsk_prot)
    3457                 :          0 :                 tw_prot_cleanup(prot->twsk_prot);
    3458                 :            : out_free_request_sock_slab:
    3459                 :          0 :         if (alloc_slab) {
    3460                 :          0 :                 req_prot_cleanup(prot->rsk_prot);
    3461                 :            : 
    3462                 :          0 :                 kmem_cache_destroy(prot->slab);
    3463                 :          0 :                 prot->slab = NULL;
    3464                 :            :         }
    3465                 :            : out:
    3466                 :          0 :         return ret;
    3467                 :            : }
    3468                 :            : EXPORT_SYMBOL(proto_register);
    3469                 :            : 
    3470                 :          0 : void proto_unregister(struct proto *prot)
    3471                 :            : {
    3472                 :          0 :         mutex_lock(&proto_list_mutex);
    3473                 :            :         release_proto_idx(prot);
    3474                 :            :         list_del(&prot->node);
    3475                 :          0 :         mutex_unlock(&proto_list_mutex);
    3476                 :            : 
    3477                 :          0 :         kmem_cache_destroy(prot->slab);
    3478                 :          0 :         prot->slab = NULL;
    3479                 :            : 
    3480                 :          0 :         req_prot_cleanup(prot->rsk_prot);
    3481                 :          0 :         tw_prot_cleanup(prot->twsk_prot);
    3482                 :          0 : }
    3483                 :            : EXPORT_SYMBOL(proto_unregister);
    3484                 :            : 
    3485                 :          0 : int sock_load_diag_module(int family, int protocol)
    3486                 :            : {
    3487                 :          0 :         if (!protocol) {
    3488                 :          0 :                 if (!sock_is_registered(family))
    3489                 :            :                         return -ENOENT;
    3490                 :            : 
    3491                 :          0 :                 return request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
    3492                 :            :                                       NETLINK_SOCK_DIAG, family);
    3493                 :            :         }
    3494                 :            : 
    3495                 :            : #ifdef CONFIG_INET
    3496                 :          0 :         if (family == AF_INET &&
    3497                 :          0 :             protocol != IPPROTO_RAW &&
    3498                 :          0 :             !rcu_access_pointer(inet_protos[protocol]))
    3499                 :            :                 return -ENOENT;
    3500                 :            : #endif
    3501                 :            : 
    3502                 :          0 :         return request_module("net-pf-%d-proto-%d-type-%d-%d", PF_NETLINK,
    3503                 :            :                               NETLINK_SOCK_DIAG, family, protocol);
    3504                 :            : }
    3505                 :            : EXPORT_SYMBOL(sock_load_diag_module);
    3506                 :            : 
    3507                 :            : #ifdef CONFIG_PROC_FS
    3508                 :          0 : static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
    3509                 :            :         __acquires(proto_list_mutex)
    3510                 :            : {
    3511                 :          0 :         mutex_lock(&proto_list_mutex);
    3512                 :          0 :         return seq_list_start_head(&proto_list, *pos);
    3513                 :            : }
    3514                 :            : 
    3515                 :          0 : static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
    3516                 :            : {
    3517                 :          0 :         return seq_list_next(v, &proto_list, pos);
    3518                 :            : }
    3519                 :            : 
    3520                 :          0 : static void proto_seq_stop(struct seq_file *seq, void *v)
    3521                 :            :         __releases(proto_list_mutex)
    3522                 :            : {
    3523                 :          0 :         mutex_unlock(&proto_list_mutex);
    3524                 :          0 : }
    3525                 :            : 
    3526                 :            : static char proto_method_implemented(const void *method)
    3527                 :            : {
    3528                 :          0 :         return method == NULL ? 'n' : 'y';
    3529                 :            : }
    3530                 :            : static long sock_prot_memory_allocated(struct proto *proto)
    3531                 :            : {
    3532                 :          0 :         return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
    3533                 :            : }
    3534                 :            : 
    3535                 :            : static const char *sock_prot_memory_pressure(struct proto *proto)
    3536                 :            : {
    3537                 :          0 :         return proto->memory_pressure != NULL ?
    3538                 :          0 :         proto_memory_pressure(proto) ? "yes" : "no" : "NI";
    3539                 :            : }
    3540                 :            : 
    3541                 :          0 : static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
    3542                 :            : {
    3543                 :            : 
    3544                 :          0 :         seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
    3545                 :            :                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
    3546                 :          0 :                    proto->name,
    3547                 :            :                    proto->obj_size,
    3548                 :            :                    sock_prot_inuse_get(seq_file_net(seq), proto),
    3549                 :            :                    sock_prot_memory_allocated(proto),
    3550                 :            :                    sock_prot_memory_pressure(proto),
    3551                 :            :                    proto->max_header,
    3552                 :          0 :                    proto->slab == NULL ? "no" : "yes",
    3553                 :          0 :                    module_name(proto->owner),
    3554                 :          0 :                    proto_method_implemented(proto->close),
    3555                 :          0 :                    proto_method_implemented(proto->connect),
    3556                 :          0 :                    proto_method_implemented(proto->disconnect),
    3557                 :          0 :                    proto_method_implemented(proto->accept),
    3558                 :          0 :                    proto_method_implemented(proto->ioctl),
    3559                 :          0 :                    proto_method_implemented(proto->init),
    3560                 :          0 :                    proto_method_implemented(proto->destroy),
    3561                 :          0 :                    proto_method_implemented(proto->shutdown),
    3562                 :          0 :                    proto_method_implemented(proto->setsockopt),
    3563                 :          0 :                    proto_method_implemented(proto->getsockopt),
    3564                 :          0 :                    proto_method_implemented(proto->sendmsg),
    3565                 :          0 :                    proto_method_implemented(proto->recvmsg),
    3566                 :          0 :                    proto_method_implemented(proto->sendpage),
    3567                 :          0 :                    proto_method_implemented(proto->bind),
    3568                 :          0 :                    proto_method_implemented(proto->backlog_rcv),
    3569                 :          0 :                    proto_method_implemented(proto->hash),
    3570                 :          0 :                    proto_method_implemented(proto->unhash),
    3571                 :          0 :                    proto_method_implemented(proto->get_port),
    3572                 :          0 :                    proto_method_implemented(proto->enter_memory_pressure));
    3573                 :          0 : }
    3574                 :            : 
    3575                 :          0 : static int proto_seq_show(struct seq_file *seq, void *v)
    3576                 :            : {
    3577                 :          0 :         if (v == &proto_list)
    3578                 :          0 :                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
    3579                 :            :                            "protocol",
    3580                 :            :                            "size",
    3581                 :            :                            "sockets",
    3582                 :            :                            "memory",
    3583                 :            :                            "press",
    3584                 :            :                            "maxhdr",
    3585                 :            :                            "slab",
    3586                 :            :                            "module",
    3587                 :            :                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
    3588                 :            :         else
    3589                 :          0 :                 proto_seq_printf(seq, list_entry(v, struct proto, node));
    3590                 :          0 :         return 0;
    3591                 :            : }
    3592                 :            : 
    3593                 :            : static const struct seq_operations proto_seq_ops = {
    3594                 :            :         .start  = proto_seq_start,
    3595                 :            :         .next   = proto_seq_next,
    3596                 :            :         .stop   = proto_seq_stop,
    3597                 :            :         .show   = proto_seq_show,
    3598                 :            : };
    3599                 :            : 
    3600                 :          3 : static __net_init int proto_init_net(struct net *net)
    3601                 :            : {
    3602                 :          3 :         if (!proc_create_net("protocols", 0444, net->proc_net, &proto_seq_ops,
    3603                 :            :                         sizeof(struct seq_net_private)))
    3604                 :            :                 return -ENOMEM;
    3605                 :            : 
    3606                 :          3 :         return 0;
    3607                 :            : }
    3608                 :            : 
    3609                 :          1 : static __net_exit void proto_exit_net(struct net *net)
    3610                 :            : {
    3611                 :          1 :         remove_proc_entry("protocols", net->proc_net);
    3612                 :          1 : }
    3613                 :            : 
    3614                 :            : 
    3615                 :            : static __net_initdata struct pernet_operations proto_net_ops = {
    3616                 :            :         .init = proto_init_net,
    3617                 :            :         .exit = proto_exit_net,
    3618                 :            : };
    3619                 :            : 
    3620                 :          3 : static int __init proto_init(void)
    3621                 :            : {
    3622                 :          3 :         return register_pernet_subsys(&proto_net_ops);
    3623                 :            : }
    3624                 :            : 
    3625                 :            : subsys_initcall(proto_init);
    3626                 :            : 
    3627                 :            : #endif /* PROC_FS */
    3628                 :            : 
    3629                 :            : #ifdef CONFIG_NET_RX_BUSY_POLL
    3630                 :          0 : bool sk_busy_loop_end(void *p, unsigned long start_time)
    3631                 :            : {
    3632                 :            :         struct sock *sk = p;
    3633                 :            : 
    3634                 :          0 :         return !skb_queue_empty_lockless(&sk->sk_receive_queue) ||
    3635                 :          0 :                sk_busy_loop_timeout(sk, start_time);
    3636                 :            : }
    3637                 :            : EXPORT_SYMBOL(sk_busy_loop_end);
    3638                 :            : #endif /* CONFIG_NET_RX_BUSY_POLL */
    

Generated by: LCOV version 1.14