net/core/sock.c

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