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, <waltje@uWalt.NL.Mugnet.ORG>
  12  *              Florian La Roche, <flla@stud.uni-sb.de>
  13  *              Alan Cox, <A.Cox@swansea.ac.uk>
  14  *
  15  * Fixes:
  16  *              Alan Cox        :       Numerous verify_area() problems
  17  *              Alan Cox        :       Connecting on a connecting socket
  18  *                                      now returns an error for tcp.
  19  *              Alan Cox        :       sock->protocol is set correctly.
  20  *                                      and is not sometimes left as 0.
  21  *              Alan Cox        :       connect handles icmp errors on a
  22  *                                      connect properly. Unfortunately there
  23  *                                      is a restart syscall nasty there. I
  24  *                                      can't match BSD without hacking the C
  25  *                                      library. Ideas urgently sought!
  26  *              Alan Cox        :       Disallow bind() to addresses that are
  27  *                                      not ours - especially broadcast ones!!
  28  *              Alan Cox        :       Socket 1024 _IS_ ok for users. (fencepost)
  29  *              Alan Cox        :       sock_wfree/sock_rfree don't destroy sockets,
  30  *                                      instead they leave that for the DESTROY timer.
  31  *              Alan Cox        :       Clean up error flag in accept
  32  *              Alan Cox        :       TCP ack handling is buggy, the DESTROY timer
  33  *                                      was buggy. Put a remove_sock() in the handler
  34  *                                      for memory when we hit 0. Also altered the timer
  35  *                                      code. The ACK stuff can wait and needs major
  36  *                                      TCP layer surgery.
  37  *              Alan Cox        :       Fixed TCP ack bug, removed remove sock
  38  *                                      and fixed timer/inet_bh race.
  39  *              Alan Cox        :       Added zapped flag for TCP
  40  *              Alan Cox        :       Move kfree_skb into skbuff.c and tidied up surplus code
  41  *              Alan Cox        :       for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
  42  *              Alan Cox        :       kfree_s calls now are kfree_skbmem so we can track skb resources
  43  *              Alan Cox        :       Supports socket option broadcast now as does udp. Packet and raw need fixing.
  44  *              Alan Cox        :       Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
  45  *              Rick Sladkey    :       Relaxed UDP rules for matching packets.
  46  *              C.E.Hawkins     :       IFF_PROMISC/SIOCGHWADDR support
  47  *      Pauline Middelink       :       identd support
  48  *              Alan Cox        :       Fixed connect() taking signals I think.
  49  *              Alan Cox        :       SO_LINGER supported
  50  *              Alan Cox        :       Error reporting fixes
  51  *              Anonymous       :       inet_create tidied up (sk->reuse setting)
  52  *              Alan Cox        :       inet sockets don't set sk->type!
  53  *              Alan Cox        :       Split socket option code
  54  *              Alan Cox        :       Callbacks
  55  *              Alan Cox        :       Nagle flag for Charles & Johannes stuff
  56  *              Alex            :       Removed restriction on inet fioctl
  57  *              Alan Cox        :       Splitting INET from NET core
  58  *              Alan Cox        :       Fixed bogus SO_TYPE handling in getsockopt()
  59  *              Adam Caldwell   :       Missing return in SO_DONTROUTE/SO_DEBUG code
  60  *              Alan Cox        :       Split IP from generic code
  61  *              Alan Cox        :       New kfree_skbmem()
  62  *              Alan Cox        :       Make SO_DEBUG superuser only.
  63  *              Alan Cox        :       Allow anyone to clear SO_DEBUG
  64  *                                      (compatibility fix)
  65  *              Alan Cox        :       Added optimistic memory grabbing for AF_UNIX throughput.
  66  *              Alan Cox        :       Allocator for a socket is settable.
  67  *              Alan Cox        :       SO_ERROR includes soft errors.
  68  *              Alan Cox        :       Allow NULL arguments on some SO_ opts
  69  *              Alan Cox        :       Generic socket allocation to make hooks
  70  *                                      easier (suggested by Craig Metz).
  71  *              Michael Pall    :       SO_ERROR returns positive errno again
  72  *              Steve Whitehouse:       Added default destructor to free
  73  *                                      protocol private data.
  74  *              Steve Whitehouse:       Added various other default routines
  75  *                                      common to several socket families.
  76  *              Chris Evans     :       Call suser() check last on F_SETOWN
  77  *              Jay Schulist    :       Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
  78  *              Andi Kleen      :       Add sock_kmalloc()/sock_kfree_s()
  79  *              Andi Kleen      :       Fix write_space callback
  80  *              Chris Evans     :       Security fixes - signedness again
  81  *              Arnaldo C. Melo :       cleanups, use skb_queue_purge
  82  *
  83  * To Fix:
  84  */
  85
  86 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
  87
  88 #include <asm/unaligned.h>
  89 #include <linux/capability.h>
  90 #include <linux/errno.h>
  91 #include <linux/errqueue.h>
  92 #include <linux/types.h>
  93 #include <linux/socket.h>
  94 #include <linux/in.h>
  95 #include <linux/kernel.h>
  96 #include <linux/module.h>
  97 #include <linux/proc_fs.h>
  98 #include <linux/seq_file.h>
  99 #include <linux/sched.h>
 100 #include <linux/sched/mm.h>
 101 #include <linux/timer.h>
 102 #include <linux/string.h>
 103 #include <linux/sockios.h>
 104 #include <linux/net.h>
 105 #include <linux/mm.h>
 106 #include <linux/slab.h>
 107 #include <linux/interrupt.h>
 108 #include <linux/poll.h>
 109 #include <linux/tcp.h>
 110 #include <linux/init.h>
 111 #include <linux/highmem.h>
 112 #include <linux/user_namespace.h>
 113 #include <linux/static_key.h>
 114 #include <linux/memcontrol.h>
 115 #include <linux/prefetch.h>
 116 #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                 sock_valbool_flag(sk, SOCK_RCVMARK, valbool);
1359                 break;
1360
1361         case SO_RXQ_OVFL:
1362                 sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
1363                 break;
1364
1365         case SO_WIFI_STATUS:
1366                 sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
1367                 break;
1368
1369         case SO_PEEK_OFF:
1370                 if (sock->ops->set_peek_off)
1371                         ret = sock->ops->set_peek_off(sk, val);
1372                 else
1373                         ret = -EOPNOTSUPP;
1374                 break;
1375
1376         case SO_NOFCS:
1377                 sock_valbool_flag(sk, SOCK_NOFCS, valbool);
1378                 break;
1379
1380         case SO_SELECT_ERR_QUEUE:
1381                 sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
1382                 break;
1383
1384 #ifdef CONFIG_NET_RX_BUSY_POLL
1385         case SO_BUSY_POLL:
1386                 /* allow unprivileged users to decrease the value */
1387                 if ((val > sk->sk_ll_usec) && !sockopt_capable(CAP_NET_ADMIN))
1388                         ret = -EPERM;
1389                 else {
1390                         if (val < 0)
1391                                 ret = -EINVAL;
1392                         else
1393                                 WRITE_ONCE(sk->sk_ll_usec, val);
1394                 }
1395                 break;
1396         case SO_PREFER_BUSY_POLL:
1397                 if (valbool && !sockopt_capable(CAP_NET_ADMIN))
1398                         ret = -EPERM;
1399                 else
1400                         WRITE_ONCE(sk->sk_prefer_busy_poll, valbool);
1401                 break;
1402         case SO_BUSY_POLL_BUDGET:
1403                 if (val > READ_ONCE(sk->sk_busy_poll_budget) && !sockopt_capable(CAP_NET_ADMIN)) {
1404                         ret = -EPERM;
1405                 } else {
1406                         if (val < 0 || val > U16_MAX)
1407                                 ret = -EINVAL;
1408                         else
1409                                 WRITE_ONCE(sk->sk_busy_poll_budget, val);
1410                 }
1411                 break;
1412 #endif
1413
1414         case SO_MAX_PACING_RATE:
1415                 {
1416                 unsigned long ulval = (val == ~0U) ? ~0UL : (unsigned int)val;
1417
1418                 if (sizeof(ulval) != sizeof(val) &&
1419                     optlen >= sizeof(ulval) &&
1420                     copy_from_sockptr(&ulval, optval, sizeof(ulval))) {
1421                         ret = -EFAULT;
1422                         break;
1423                 }
1424                 if (ulval != ~0UL)
1425                         cmpxchg(&sk->sk_pacing_status,
1426                                 SK_PACING_NONE,
1427                                 SK_PACING_NEEDED);
1428                 sk->sk_max_pacing_rate = ulval;
1429                 sk->sk_pacing_rate = min(sk->sk_pacing_rate, ulval);
1430                 break;
1431                 }
1432         case SO_INCOMING_CPU:
1433                 reuseport_update_incoming_cpu(sk, val);
1434                 break;
1435
1436         case SO_CNX_ADVICE:
1437                 if (val == 1)
1438                         dst_negative_advice(sk);
1439                 break;
1440
1441         case SO_ZEROCOPY:
1442                 if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6) {
1443                         if (!(sk_is_tcp(sk) ||
1444                               (sk->sk_type == SOCK_DGRAM &&
1445                                sk->sk_protocol == IPPROTO_UDP)))
1446                                 ret = -EOPNOTSUPP;
1447                 } else if (sk->sk_family != PF_RDS) {
1448                         ret = -EOPNOTSUPP;
1449                 }
1450                 if (!ret) {
1451                         if (val < 0 || val > 1)
1452                                 ret = -EINVAL;
1453                         else
1454                                 sock_valbool_flag(sk, SOCK_ZEROCOPY, valbool);
1455                 }
1456                 break;
1457
1458         case SO_TXTIME:
1459                 if (optlen != sizeof(struct sock_txtime)) {
1460                         ret = -EINVAL;
1461                         break;
1462                 } else if (copy_from_sockptr(&sk_txtime, optval,
1463                            sizeof(struct sock_txtime))) {
1464                         ret = -EFAULT;
1465                         break;
1466                 } else if (sk_txtime.flags & ~SOF_TXTIME_FLAGS_MASK) {
1467                         ret = -EINVAL;
1468                         break;
1469                 }
1470                 /* CLOCK_MONOTONIC is only used by sch_fq, and this packet
1471                  * scheduler has enough safe guards.
1472                  */
1473                 if (sk_txtime.clockid != CLOCK_MONOTONIC &&
1474                     !sockopt_ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
1475                         ret = -EPERM;
1476                         break;
1477                 }
1478                 sock_valbool_flag(sk, SOCK_TXTIME, true);
1479                 sk->sk_clockid = sk_txtime.clockid;
1480                 sk->sk_txtime_deadline_mode =
1481                         !!(sk_txtime.flags & SOF_TXTIME_DEADLINE_MODE);
1482                 sk->sk_txtime_report_errors =
1483                         !!(sk_txtime.flags & SOF_TXTIME_REPORT_ERRORS);
1484                 break;
1485
1486         case SO_BINDTOIFINDEX:
1487                 ret = sock_bindtoindex_locked(sk, val);
1488                 break;
1489
1490         case SO_BUF_LOCK:
1491                 if (val & ~SOCK_BUF_LOCK_MASK) {
1492                         ret = -EINVAL;
1493                         break;
1494                 }
1495                 sk->sk_userlocks = val | (sk->sk_userlocks &
1496                                           ~SOCK_BUF_LOCK_MASK);
1497                 break;
1498
1499         case SO_RESERVE_MEM:
1500         {
1501                 int delta;
1502
1503                 if (val < 0) {
1504                         ret = -EINVAL;
1505                         break;
1506                 }
1507
1508                 delta = val - sk->sk_reserved_mem;
1509                 if (delta < 0)
1510                         sock_release_reserved_memory(sk, -delta);
1511                 else
1512                         ret = sock_reserve_memory(sk, delta);
1513                 break;
1514         }
1515
1516         case SO_TXREHASH:
1517                 if (val < -1 || val > 1) {
1518                         ret = -EINVAL;
1519                         break;
1520                 }
1521                 if ((u8)val == SOCK_TXREHASH_DEFAULT)
1522                         val = READ_ONCE(sock_net(sk)->core.sysctl_txrehash);
1523                 /* Paired with READ_ONCE() in tcp_rtx_synack() */
1524                 WRITE_ONCE(sk->sk_txrehash, (u8)val);
1525                 break;
1526
1527         default:
1528                 ret = -ENOPROTOOPT;
1529                 break;
1530         }
1531         sockopt_release_sock(sk);
1532         return ret;
1533 }
1534
1535 int sock_setsockopt(struct socket *sock, int level, int optname,
1536                     sockptr_t optval, unsigned int optlen)
1537 {
1538         return sk_setsockopt(sock->sk, level, optname,
1539                              optval, optlen);
1540 }
1541 EXPORT_SYMBOL(sock_setsockopt);
1542
1543 static const struct cred *sk_get_peer_cred(struct sock *sk)
1544 {
1545         const struct cred *cred;
1546
1547         spin_lock(&sk->sk_peer_lock);
1548         cred = get_cred(sk->sk_peer_cred);
1549         spin_unlock(&sk->sk_peer_lock);
1550
1551         return cred;
1552 }
1553
1554 static void cred_to_ucred(struct pid *pid, const struct cred *cred,
1555                           struct ucred *ucred)
1556 {
1557         ucred->pid = pid_vnr(pid);
1558         ucred->uid = ucred->gid = -1;
1559         if (cred) {
1560                 struct user_namespace *current_ns = current_user_ns();
1561
1562                 ucred->uid = from_kuid_munged(current_ns, cred->euid);
1563                 ucred->gid = from_kgid_munged(current_ns, cred->egid);
1564         }
1565 }
1566
1567 static int groups_to_user(sockptr_t dst, const struct group_info *src)
1568 {
1569         struct user_namespace *user_ns = current_user_ns();
1570         int i;
1571
1572         for (i = 0; i < src->ngroups; i++) {
1573                 gid_t gid = from_kgid_munged(user_ns, src->gid[i]);
1574
1575                 if (copy_to_sockptr_offset(dst, i * sizeof(gid), &gid, sizeof(gid)))
1576                         return -EFAULT;
1577         }
1578
1579         return 0;
1580 }
1581
1582 int sk_getsockopt(struct sock *sk, int level, int optname,
1583                   sockptr_t optval, sockptr_t optlen)
1584 {
1585         struct socket *sock = sk->sk_socket;
1586
1587         union {
1588                 int val;
1589                 u64 val64;
1590                 unsigned long ulval;
1591                 struct linger ling;
1592                 struct old_timeval32 tm32;
1593                 struct __kernel_old_timeval tm;
1594                 struct  __kernel_sock_timeval stm;
1595                 struct sock_txtime txtime;
1596                 struct so_timestamping timestamping;
1597         } v;
1598
1599         int lv = sizeof(int);
1600         int len;
1601
1602         if (copy_from_sockptr(&len, optlen, sizeof(int)))
1603                 return -EFAULT;
1604         if (len < 0)
1605                 return -EINVAL;
1606
1607         memset(&v, 0, sizeof(v));
1608
1609         switch (optname) {
1610         case SO_DEBUG:
1611                 v.val = sock_flag(sk, SOCK_DBG);
1612                 break;
1613
1614         case SO_DONTROUTE:
1615                 v.val = sock_flag(sk, SOCK_LOCALROUTE);
1616                 break;
1617
1618         case SO_BROADCAST:
1619                 v.val = sock_flag(sk, SOCK_BROADCAST);
1620                 break;
1621
1622         case SO_SNDBUF:
1623                 v.val = sk->sk_sndbuf;
1624                 break;
1625
1626         case SO_RCVBUF:
1627                 v.val = sk->sk_rcvbuf;
1628                 break;
1629
1630         case SO_REUSEADDR:
1631                 v.val = sk->sk_reuse;
1632                 break;
1633
1634         case SO_REUSEPORT:
1635                 v.val = sk->sk_reuseport;
1636                 break;
1637
1638         case SO_KEEPALIVE:
1639                 v.val = sock_flag(sk, SOCK_KEEPOPEN);
1640                 break;
1641
1642         case SO_TYPE:
1643                 v.val = sk->sk_type;
1644                 break;
1645
1646         case SO_PROTOCOL:
1647                 v.val = sk->sk_protocol;
1648                 break;
1649
1650         case SO_DOMAIN:
1651                 v.val = sk->sk_family;
1652                 break;
1653
1654         case SO_ERROR:
1655                 v.val = -sock_error(sk);
1656                 if (v.val == 0)
1657                         v.val = xchg(&sk->sk_err_soft, 0);
1658                 break;
1659
1660         case SO_OOBINLINE:
1661                 v.val = sock_flag(sk, SOCK_URGINLINE);
1662                 break;
1663
1664         case SO_NO_CHECK:
1665                 v.val = sk->sk_no_check_tx;
1666                 break;
1667
1668         case SO_PRIORITY:
1669                 v.val = sk->sk_priority;
1670                 break;
1671
1672         case SO_LINGER:
1673                 lv              = sizeof(v.ling);
1674                 v.ling.l_onoff  = sock_flag(sk, SOCK_LINGER);
1675                 v.ling.l_linger = sk->sk_lingertime / HZ;
1676                 break;
1677
1678         case SO_BSDCOMPAT:
1679                 break;
1680
1681         case SO_TIMESTAMP_OLD:
1682                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
1683                                 !sock_flag(sk, SOCK_TSTAMP_NEW) &&
1684                                 !sock_flag(sk, SOCK_RCVTSTAMPNS);
1685                 break;
1686
1687         case SO_TIMESTAMPNS_OLD:
1688                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS) && !sock_flag(sk, SOCK_TSTAMP_NEW);
1689                 break;
1690
1691         case SO_TIMESTAMP_NEW:
1692                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) && sock_flag(sk, SOCK_TSTAMP_NEW);
1693                 break;
1694
1695         case SO_TIMESTAMPNS_NEW:
1696                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS) && sock_flag(sk, SOCK_TSTAMP_NEW);
1697                 break;
1698
1699         case SO_TIMESTAMPING_OLD:
1700                 lv = sizeof(v.timestamping);
1701                 v.timestamping.flags = sk->sk_tsflags;
1702                 v.timestamping.bind_phc = sk->sk_bind_phc;
1703                 break;
1704
1705         case SO_RCVTIMEO_OLD:
1706         case SO_RCVTIMEO_NEW:
1707                 lv = sock_get_timeout(sk->sk_rcvtimeo, &v, SO_RCVTIMEO_OLD == optname);
1708                 break;
1709
1710         case SO_SNDTIMEO_OLD:
1711         case SO_SNDTIMEO_NEW:
1712                 lv = sock_get_timeout(sk->sk_sndtimeo, &v, SO_SNDTIMEO_OLD == optname);
1713                 break;
1714
1715         case SO_RCVLOWAT:
1716                 v.val = sk->sk_rcvlowat;
1717                 break;
1718
1719         case SO_SNDLOWAT:
1720                 v.val = 1;
1721                 break;
1722
1723         case SO_PASSCRED:
1724                 v.val = !!test_bit(SOCK_PASSCRED, &sock->flags);
1725                 break;
1726
1727         case SO_PEERCRED:
1728         {
1729                 struct ucred peercred;
1730                 if (len > sizeof(peercred))
1731                         len = sizeof(peercred);
1732
1733                 spin_lock(&sk->sk_peer_lock);
1734                 cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
1735                 spin_unlock(&sk->sk_peer_lock);
1736
1737                 if (copy_to_sockptr(optval, &peercred, len))
1738                         return -EFAULT;
1739                 goto lenout;
1740         }
1741
1742         case SO_PEERGROUPS:
1743         {
1744                 const struct cred *cred;
1745                 int ret, n;
1746
1747                 cred = sk_get_peer_cred(sk);
1748                 if (!cred)
1749                         return -ENODATA;
1750
1751                 n = cred->group_info->ngroups;
1752                 if (len < n * sizeof(gid_t)) {
1753                         len = n * sizeof(gid_t);
1754                         put_cred(cred);
1755                         return copy_to_sockptr(optlen, &len, sizeof(int)) ? -EFAULT : -ERANGE;
1756                 }
1757                 len = n * sizeof(gid_t);
1758
1759                 ret = groups_to_user(optval, cred->group_info);
1760                 put_cred(cred);
1761                 if (ret)
1762                         return ret;
1763                 goto lenout;
1764         }
1765
1766         case SO_PEERNAME:
1767         {
1768                 char address[128];
1769
1770                 lv = sock->ops->getname(sock, (struct sockaddr *)address, 2);
1771                 if (lv < 0)
1772                         return -ENOTCONN;
1773                 if (lv < len)
1774                         return -EINVAL;
1775                 if (copy_to_sockptr(optval, address, len))
1776                         return -EFAULT;
1777                 goto lenout;
1778         }
1779
1780         /* Dubious BSD thing... Probably nobody even uses it, but
1781          * the UNIX standard wants it for whatever reason... -DaveM
1782          */
1783         case SO_ACCEPTCONN:
1784                 v.val = sk->sk_state == TCP_LISTEN;
1785                 break;
1786
1787         case SO_PASSSEC:
1788                 v.val = !!test_bit(SOCK_PASSSEC, &sock->flags);
1789                 break;
1790
1791         case SO_PEERSEC:
1792                 return security_socket_getpeersec_stream(sock, optval.user, optlen.user, len);
1793
1794         case SO_MARK:
1795                 v.val = sk->sk_mark;
1796                 break;
1797
1798         case SO_RCVMARK:
1799                 v.val = sock_flag(sk, SOCK_RCVMARK);
1800                 break;
1801
1802         case SO_RXQ_OVFL:
1803                 v.val = sock_flag(sk, SOCK_RXQ_OVFL);
1804                 break;
1805
1806         case SO_WIFI_STATUS:
1807                 v.val = sock_flag(sk, SOCK_WIFI_STATUS);
1808                 break;
1809
1810         case SO_PEEK_OFF:
1811                 if (!sock->ops->set_peek_off)
1812                         return -EOPNOTSUPP;
1813
1814                 v.val = sk->sk_peek_off;
1815                 break;
1816         case SO_NOFCS:
1817                 v.val = sock_flag(sk, SOCK_NOFCS);
1818                 break;
1819
1820         case SO_BINDTODEVICE:
1821                 return sock_getbindtodevice(sk, optval, optlen, len);
1822
1823         case SO_GET_FILTER:
1824                 len = sk_get_filter(sk, optval, len);
1825                 if (len < 0)
1826                         return len;
1827
1828                 goto lenout;
1829
1830         case SO_LOCK_FILTER:
1831                 v.val = sock_flag(sk, SOCK_FILTER_LOCKED);
1832                 break;
1833
1834         case SO_BPF_EXTENSIONS:
1835                 v.val = bpf_tell_extensions();
1836                 break;
1837
1838         case SO_SELECT_ERR_QUEUE:
1839                 v.val = sock_flag(sk, SOCK_SELECT_ERR_QUEUE);
1840                 break;
1841
1842 #ifdef CONFIG_NET_RX_BUSY_POLL
1843         case SO_BUSY_POLL:
1844                 v.val = sk->sk_ll_usec;
1845                 break;
1846         case SO_PREFER_BUSY_POLL:
1847                 v.val = READ_ONCE(sk->sk_prefer_busy_poll);
1848                 break;
1849 #endif
1850
1851         case SO_MAX_PACING_RATE:
1852                 if (sizeof(v.ulval) != sizeof(v.val) && len >= sizeof(v.ulval)) {
1853                         lv = sizeof(v.ulval);
1854                         v.ulval = sk->sk_max_pacing_rate;
1855                 } else {
1856                         /* 32bit version */
1857                         v.val = min_t(unsigned long, sk->sk_max_pacing_rate, ~0U);
1858                 }
1859                 break;
1860
1861         case SO_INCOMING_CPU:
1862                 v.val = READ_ONCE(sk->sk_incoming_cpu);
1863                 break;
1864
1865         case SO_MEMINFO:
1866         {
1867                 u32 meminfo[SK_MEMINFO_VARS];
1868
1869                 sk_get_meminfo(sk, meminfo);
1870
1871                 len = min_t(unsigned int, len, sizeof(meminfo));
1872                 if (copy_to_sockptr(optval, &meminfo, len))
1873                         return -EFAULT;
1874
1875                 goto lenout;
1876         }
1877
1878 #ifdef CONFIG_NET_RX_BUSY_POLL
1879         case SO_INCOMING_NAPI_ID:
1880                 v.val = READ_ONCE(sk->sk_napi_id);
1881
1882                 /* aggregate non-NAPI IDs down to 0 */
1883                 if (v.val < MIN_NAPI_ID)
1884                         v.val = 0;
1885
1886                 break;
1887 #endif
1888
1889         case SO_COOKIE:
1890                 lv = sizeof(u64);
1891                 if (len < lv)
1892                         return -EINVAL;
1893                 v.val64 = sock_gen_cookie(sk);
1894                 break;
1895
1896         case SO_ZEROCOPY:
1897                 v.val = sock_flag(sk, SOCK_ZEROCOPY);
1898                 break;
1899
1900         case SO_TXTIME:
1901                 lv = sizeof(v.txtime);
1902                 v.txtime.clockid = sk->sk_clockid;
1903                 v.txtime.flags |= sk->sk_txtime_deadline_mode ?
1904                                   SOF_TXTIME_DEADLINE_MODE : 0;
1905                 v.txtime.flags |= sk->sk_txtime_report_errors ?
1906                                   SOF_TXTIME_REPORT_ERRORS : 0;
1907                 break;
1908
1909         case SO_BINDTOIFINDEX:
1910                 v.val = READ_ONCE(sk->sk_bound_dev_if);
1911                 break;
1912
1913         case SO_NETNS_COOKIE:
1914                 lv = sizeof(u64);
1915                 if (len != lv)
1916                         return -EINVAL;
1917                 v.val64 = sock_net(sk)->net_cookie;
1918                 break;
1919
1920         case SO_BUF_LOCK:
1921                 v.val = sk->sk_userlocks & SOCK_BUF_LOCK_MASK;
1922                 break;
1923
1924         case SO_RESERVE_MEM:
1925                 v.val = sk->sk_reserved_mem;
1926                 break;
1927
1928         case SO_TXREHASH:
1929                 v.val = sk->sk_txrehash;
1930                 break;
1931
1932         default:
1933                 /* We implement the SO_SNDLOWAT etc to not be settable
1934                  * (1003.1g 7).
1935                  */
1936                 return -ENOPROTOOPT;
1937         }
1938
1939         if (len > lv)
1940                 len = lv;
1941         if (copy_to_sockptr(optval, &v, len))
1942                 return -EFAULT;
1943 lenout:
1944         if (copy_to_sockptr(optlen, &len, sizeof(int)))
1945                 return -EFAULT;
1946         return 0;
1947 }
1948
1949 int sock_getsockopt(struct socket *sock, int level, int optname,
1950                     char __user *optval, int __user *optlen)
1951 {
1952         return sk_getsockopt(sock->sk, level, optname,
1953                              USER_SOCKPTR(optval),
1954                              USER_SOCKPTR(optlen));
1955 }
1956
1957 /*
1958  * Initialize an sk_lock.
1959  *
1960  * (We also register the sk_lock with the lock validator.)
1961  */
1962 static inline void sock_lock_init(struct sock *sk)
1963 {
1964         if (sk->sk_kern_sock)
1965                 sock_lock_init_class_and_name(
1966                         sk,
1967                         af_family_kern_slock_key_strings[sk->sk_family],
1968                         af_family_kern_slock_keys + sk->sk_family,
1969                         af_family_kern_key_strings[sk->sk_family],
1970                         af_family_kern_keys + sk->sk_family);
1971         else
1972                 sock_lock_init_class_and_name(
1973                         sk,
1974                         af_family_slock_key_strings[sk->sk_family],
1975                         af_family_slock_keys + sk->sk_family,
1976                         af_family_key_strings[sk->sk_family],
1977                         af_family_keys + sk->sk_family);
1978 }
1979
1980 /*
1981  * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
1982  * even temporarly, because of RCU lookups. sk_node should also be left as is.
1983  * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
1984  */
1985 static void sock_copy(struct sock *nsk, const struct sock *osk)
1986 {
1987         const struct proto *prot = READ_ONCE(osk->sk_prot);
1988 #ifdef CONFIG_SECURITY_NETWORK
1989         void *sptr = nsk->sk_security;
1990 #endif
1991
1992         /* If we move sk_tx_queue_mapping out of the private section,
1993          * we must check if sk_tx_queue_clear() is called after
1994          * sock_copy() in sk_clone_lock().
1995          */
1996         BUILD_BUG_ON(offsetof(struct sock, sk_tx_queue_mapping) <
1997                      offsetof(struct sock, sk_dontcopy_begin) ||
1998                      offsetof(struct sock, sk_tx_queue_mapping) >=
1999                      offsetof(struct sock, sk_dontcopy_end));
2000
2001         memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
2002
2003         memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
2004                prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
2005
2006 #ifdef CONFIG_SECURITY_NETWORK
2007         nsk->sk_security = sptr;
2008         security_sk_clone(osk, nsk);
2009 #endif
2010 }
2011
2012 static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
2013                 int family)
2014 {
2015         struct sock *sk;
2016         struct kmem_cache *slab;
2017
2018         slab = prot->slab;
2019         if (slab != NULL) {
2020                 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
2021                 if (!sk)
2022                         return sk;
2023                 if (want_init_on_alloc(priority))
2024                         sk_prot_clear_nulls(sk, prot->obj_size);
2025         } else
2026                 sk = kmalloc(prot->obj_size, priority);
2027
2028         if (sk != NULL) {
2029                 if (security_sk_alloc(sk, family, priority))
2030                         goto out_free;
2031
2032                 if (!try_module_get(prot->owner))
2033                         goto out_free_sec;
2034         }
2035
2036         return sk;
2037
2038 out_free_sec:
2039         security_sk_free(sk);
2040 out_free:
2041         if (slab != NULL)
2042                 kmem_cache_free(slab, sk);
2043         else
2044                 kfree(sk);
2045         return NULL;
2046 }
2047
2048 static void sk_prot_free(struct proto *prot, struct sock *sk)
2049 {
2050         struct kmem_cache *slab;
2051         struct module *owner;
2052
2053         owner = prot->owner;
2054         slab = prot->slab;
2055
2056         cgroup_sk_free(&sk->sk_cgrp_data);
2057         mem_cgroup_sk_free(sk);
2058         security_sk_free(sk);
2059         if (slab != NULL)
2060                 kmem_cache_free(slab, sk);
2061         else
2062                 kfree(sk);
2063         module_put(owner);
2064 }
2065
2066 /**
2067  *      sk_alloc - All socket objects are allocated here
2068  *      @net: the applicable net namespace
2069  *      @family: protocol family
2070  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
2071  *      @prot: struct proto associated with this new sock instance
2072  *      @kern: is this to be a kernel socket?
2073  */
2074 struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
2075                       struct proto *prot, int kern)
2076 {
2077         struct sock *sk;
2078
2079         sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
2080         if (sk) {
2081                 sk->sk_family = family;
2082                 /*
2083                  * See comment in struct sock definition to understand
2084                  * why we need sk_prot_creator -acme
2085                  */
2086                 sk->sk_prot = sk->sk_prot_creator = prot;
2087                 sk->sk_kern_sock = kern;
2088                 sock_lock_init(sk);
2089                 sk->sk_net_refcnt = kern ? 0 : 1;
2090                 if (likely(sk->sk_net_refcnt)) {
2091                         get_net_track(net, &sk->ns_tracker, priority);
2092                         sock_inuse_add(net, 1);
2093                 }
2094
2095                 sock_net_set(sk, net);
2096                 refcount_set(&sk->sk_wmem_alloc, 1);
2097
2098                 mem_cgroup_sk_alloc(sk);
2099                 cgroup_sk_alloc(&sk->sk_cgrp_data);
2100                 sock_update_classid(&sk->sk_cgrp_data);
2101                 sock_update_netprioidx(&sk->sk_cgrp_data);
2102                 sk_tx_queue_clear(sk);
2103         }
2104
2105         return sk;
2106 }
2107 EXPORT_SYMBOL(sk_alloc);
2108
2109 /* Sockets having SOCK_RCU_FREE will call this function after one RCU
2110  * grace period. This is the case for UDP sockets and TCP listeners.
2111  */
2112 static void __sk_destruct(struct rcu_head *head)
2113 {
2114         struct sock *sk = container_of(head, struct sock, sk_rcu);
2115         struct sk_filter *filter;
2116
2117         if (sk->sk_destruct)
2118                 sk->sk_destruct(sk);
2119
2120         filter = rcu_dereference_check(sk->sk_filter,
2121                                        refcount_read(&sk->sk_wmem_alloc) == 0);
2122         if (filter) {
2123                 sk_filter_uncharge(sk, filter);
2124                 RCU_INIT_POINTER(sk->sk_filter, NULL);
2125         }
2126
2127         sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
2128
2129 #ifdef CONFIG_BPF_SYSCALL
2130         bpf_sk_storage_free(sk);
2131 #endif
2132
2133         if (atomic_read(&sk->sk_omem_alloc))
2134                 pr_debug("%s: optmem leakage (%d bytes) detected\n",
2135                          __func__, atomic_read(&sk->sk_omem_alloc));
2136
2137         if (sk->sk_frag.page) {
2138                 put_page(sk->sk_frag.page);
2139                 sk->sk_frag.page = NULL;
2140         }
2141
2142         /* We do not need to acquire sk->sk_peer_lock, we are the last user. */
2143         put_cred(sk->sk_peer_cred);
2144         put_pid(sk->sk_peer_pid);
2145
2146         if (likely(sk->sk_net_refcnt))
2147                 put_net_track(sock_net(sk), &sk->ns_tracker);
2148         sk_prot_free(sk->sk_prot_creator, sk);
2149 }
2150
2151 void sk_destruct(struct sock *sk)
2152 {
2153         bool use_call_rcu = sock_flag(sk, SOCK_RCU_FREE);
2154
2155         if (rcu_access_pointer(sk->sk_reuseport_cb)) {
2156                 reuseport_detach_sock(sk);
2157                 use_call_rcu = true;
2158         }
2159
2160         if (use_call_rcu)
2161                 call_rcu(&sk->sk_rcu, __sk_destruct);
2162         else
2163                 __sk_destruct(&sk->sk_rcu);
2164 }
2165
2166 static void __sk_free(struct sock *sk)
2167 {
2168         if (likely(sk->sk_net_refcnt))
2169                 sock_inuse_add(sock_net(sk), -1);
2170
2171         if (unlikely(sk->sk_net_refcnt && sock_diag_has_destroy_listeners(sk)))
2172                 sock_diag_broadcast_destroy(sk);
2173         else
2174                 sk_destruct(sk);
2175 }
2176
2177 void sk_free(struct sock *sk)
2178 {
2179         /*
2180          * We subtract one from sk_wmem_alloc and can know if
2181          * some packets are still in some tx queue.
2182          * If not null, sock_wfree() will call __sk_free(sk) later
2183          */
2184         if (refcount_dec_and_test(&sk->sk_wmem_alloc))
2185                 __sk_free(sk);
2186 }
2187 EXPORT_SYMBOL(sk_free);
2188
2189 static void sk_init_common(struct sock *sk)
2190 {
2191         skb_queue_head_init(&sk->sk_receive_queue);
2192         skb_queue_head_init(&sk->sk_write_queue);
2193         skb_queue_head_init(&sk->sk_error_queue);
2194
2195         rwlock_init(&sk->sk_callback_lock);
2196         lockdep_set_class_and_name(&sk->sk_receive_queue.lock,
2197                         af_rlock_keys + sk->sk_family,
2198                         af_family_rlock_key_strings[sk->sk_family]);
2199         lockdep_set_class_and_name(&sk->sk_write_queue.lock,
2200                         af_wlock_keys + sk->sk_family,
2201                         af_family_wlock_key_strings[sk->sk_family]);
2202         lockdep_set_class_and_name(&sk->sk_error_queue.lock,
2203                         af_elock_keys + sk->sk_family,
2204                         af_family_elock_key_strings[sk->sk_family]);
2205         lockdep_set_class_and_name(&sk->sk_callback_lock,
2206                         af_callback_keys + sk->sk_family,
2207                         af_family_clock_key_strings[sk->sk_family]);
2208 }
2209
2210 /**
2211  *      sk_clone_lock - clone a socket, and lock its clone
2212  *      @sk: the socket to clone
2213  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
2214  *
2215  *      Caller must unlock socket even in error path (bh_unlock_sock(newsk))
2216  */
2217 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
2218 {
2219         struct proto *prot = READ_ONCE(sk->sk_prot);
2220         struct sk_filter *filter;
2221         bool is_charged = true;
2222         struct sock *newsk;
2223
2224         newsk = sk_prot_alloc(prot, priority, sk->sk_family);
2225         if (!newsk)
2226                 goto out;
2227
2228         sock_copy(newsk, sk);
2229
2230         newsk->sk_prot_creator = prot;
2231
2232         /* SANITY */
2233         if (likely(newsk->sk_net_refcnt)) {
2234                 get_net_track(sock_net(newsk), &newsk->ns_tracker, priority);
2235                 sock_inuse_add(sock_net(newsk), 1);
2236         }
2237         sk_node_init(&newsk->sk_node);
2238         sock_lock_init(newsk);
2239         bh_lock_sock(newsk);
2240         newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
2241         newsk->sk_backlog.len = 0;
2242
2243         atomic_set(&newsk->sk_rmem_alloc, 0);
2244
2245         /* sk_wmem_alloc set to one (see sk_free() and sock_wfree()) */
2246         refcount_set(&newsk->sk_wmem_alloc, 1);
2247
2248         atomic_set(&newsk->sk_omem_alloc, 0);
2249         sk_init_common(newsk);
2250
2251         newsk->sk_dst_cache     = NULL;
2252         newsk->sk_dst_pending_confirm = 0;
2253         newsk->sk_wmem_queued   = 0;
2254         newsk->sk_forward_alloc = 0;
2255         newsk->sk_reserved_mem  = 0;
2256         atomic_set(&newsk->sk_drops, 0);
2257         newsk->sk_send_head     = NULL;
2258         newsk->sk_userlocks     = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
2259         atomic_set(&newsk->sk_zckey, 0);
2260
2261         sock_reset_flag(newsk, SOCK_DONE);
2262
2263         /* sk->sk_memcg will be populated at accept() time */
2264         newsk->sk_memcg = NULL;
2265
2266         cgroup_sk_clone(&newsk->sk_cgrp_data);
2267
2268         rcu_read_lock();
2269         filter = rcu_dereference(sk->sk_filter);
2270         if (filter != NULL)
2271                 /* though it's an empty new sock, the charging may fail
2272                  * if sysctl_optmem_max was changed between creation of
2273                  * original socket and cloning
2274                  */
2275                 is_charged = sk_filter_charge(newsk, filter);
2276         RCU_INIT_POINTER(newsk->sk_filter, filter);
2277         rcu_read_unlock();
2278
2279         if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk, sk))) {
2280                 /* We need to make sure that we don't uncharge the new
2281                  * socket if we couldn't charge it in the first place
2282                  * as otherwise we uncharge the parent's filter.
2283                  */
2284                 if (!is_charged)
2285                         RCU_INIT_POINTER(newsk->sk_filter, NULL);
2286                 sk_free_unlock_clone(newsk);
2287                 newsk = NULL;
2288                 goto out;
2289         }
2290         RCU_INIT_POINTER(newsk->sk_reuseport_cb, NULL);
2291
2292         if (bpf_sk_storage_clone(sk, newsk)) {
2293                 sk_free_unlock_clone(newsk);
2294                 newsk = NULL;
2295                 goto out;
2296         }
2297
2298         /* Clear sk_user_data if parent had the pointer tagged
2299          * as not suitable for copying when cloning.
2300          */
2301         if (sk_user_data_is_nocopy(newsk))
2302                 newsk->sk_user_data = NULL;
2303
2304         newsk->sk_err      = 0;
2305         newsk->sk_err_soft = 0;
2306         newsk->sk_priority = 0;
2307         newsk->sk_incoming_cpu = raw_smp_processor_id();
2308
2309         /* Before updating sk_refcnt, we must commit prior changes to memory
2310          * (Documentation/RCU/rculist_nulls.rst for details)
2311          */
2312         smp_wmb();
2313         refcount_set(&newsk->sk_refcnt, 2);
2314
2315         /* Increment the counter in the same struct proto as the master
2316          * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
2317          * is the same as sk->sk_prot->socks, as this field was copied
2318          * with memcpy).
2319          *
2320          * This _changes_ the previous behaviour, where
2321          * tcp_create_openreq_child always was incrementing the
2322          * equivalent to tcp_prot->socks (inet_sock_nr), so this have
2323          * to be taken into account in all callers. -acme
2324          */
2325         sk_refcnt_debug_inc(newsk);
2326         sk_set_socket(newsk, NULL);
2327         sk_tx_queue_clear(newsk);
2328         RCU_INIT_POINTER(newsk->sk_wq, NULL);
2329
2330         if (newsk->sk_prot->sockets_allocated)
2331                 sk_sockets_allocated_inc(newsk);
2332
2333         if (sock_needs_netstamp(sk) && newsk->sk_flags & SK_FLAGS_TIMESTAMP)
2334                 net_enable_timestamp();
2335 out:
2336         return newsk;
2337 }
2338 EXPORT_SYMBOL_GPL(sk_clone_lock);
2339
2340 void sk_free_unlock_clone(struct sock *sk)
2341 {
2342         /* It is still raw copy of parent, so invalidate
2343          * destructor and make plain sk_free() */
2344         sk->sk_destruct = NULL;
2345         bh_unlock_sock(sk);
2346         sk_free(sk);
2347 }
2348 EXPORT_SYMBOL_GPL(sk_free_unlock_clone);
2349
2350 static void sk_trim_gso_size(struct sock *sk)
2351 {
2352         if (sk->sk_gso_max_size <= GSO_LEGACY_MAX_SIZE)
2353                 return;
2354 #if IS_ENABLED(CONFIG_IPV6)
2355         if (sk->sk_family == AF_INET6 &&
2356             sk_is_tcp(sk) &&
2357             !ipv6_addr_v4mapped(&sk->sk_v6_rcv_saddr))
2358                 return;
2359 #endif
2360         sk->sk_gso_max_size = GSO_LEGACY_MAX_SIZE;
2361 }
2362
2363 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
2364 {
2365         u32 max_segs = 1;
2366
2367         sk->sk_route_caps = dst->dev->features;
2368         if (sk_is_tcp(sk))
2369                 sk->sk_route_caps |= NETIF_F_GSO;
2370         if (sk->sk_route_caps & NETIF_F_GSO)
2371                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
2372         if (unlikely(sk->sk_gso_disabled))
2373                 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
2374         if (sk_can_gso(sk)) {
2375                 if (dst->header_len && !xfrm_dst_offload_ok(dst)) {
2376                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
2377                 } else {
2378                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
2379                         /* pairs with the WRITE_ONCE() in netif_set_gso_max_size() */
2380                         sk->sk_gso_max_size = READ_ONCE(dst->dev->gso_max_size);
2381                         sk_trim_gso_size(sk);
2382                         sk->sk_gso_max_size -= (MAX_TCP_HEADER + 1);
2383                         /* pairs with the WRITE_ONCE() in netif_set_gso_max_segs() */
2384                         max_segs = max_t(u32, READ_ONCE(dst->dev->gso_max_segs), 1);
2385                 }
2386         }
2387         sk->sk_gso_max_segs = max_segs;
2388         sk_dst_set(sk, dst);
2389 }
2390 EXPORT_SYMBOL_GPL(sk_setup_caps);
2391
2392 /*
2393  *      Simple resource managers for sockets.
2394  */
2395
2396
2397 /*
2398  * Write buffer destructor automatically called from kfree_skb.
2399  */
2400 void sock_wfree(struct sk_buff *skb)
2401 {
2402         struct sock *sk = skb->sk;
2403         unsigned int len = skb->truesize;
2404         bool free;
2405
2406         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
2407                 if (sock_flag(sk, SOCK_RCU_FREE) &&
2408                     sk->sk_write_space == sock_def_write_space) {
2409                         rcu_read_lock();
2410                         free = refcount_sub_and_test(len, &sk->sk_wmem_alloc);
2411                         sock_def_write_space_wfree(sk);
2412                         rcu_read_unlock();
2413                         if (unlikely(free))
2414                                 __sk_free(sk);
2415                         return;
2416                 }
2417
2418                 /*
2419                  * Keep a reference on sk_wmem_alloc, this will be released
2420                  * after sk_write_space() call
2421                  */
2422                 WARN_ON(refcount_sub_and_test(len - 1, &sk->sk_wmem_alloc));
2423                 sk->sk_write_space(sk);
2424                 len = 1;
2425         }
2426         /*
2427          * if sk_wmem_alloc reaches 0, we must finish what sk_free()
2428          * could not do because of in-flight packets
2429          */
2430         if (refcount_sub_and_test(len, &sk->sk_wmem_alloc))
2431                 __sk_free(sk);
2432 }
2433 EXPORT_SYMBOL(sock_wfree);
2434
2435 /* This variant of sock_wfree() is used by TCP,
2436  * since it sets SOCK_USE_WRITE_QUEUE.
2437  */
2438 void __sock_wfree(struct sk_buff *skb)
2439 {
2440         struct sock *sk = skb->sk;
2441
2442         if (refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc))
2443                 __sk_free(sk);
2444 }
2445
2446 void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
2447 {
2448         skb_orphan(skb);
2449         skb->sk = sk;
2450 #ifdef CONFIG_INET
2451         if (unlikely(!sk_fullsock(sk))) {
2452                 skb->destructor = sock_edemux;
2453                 sock_hold(sk);
2454                 return;
2455         }
2456 #endif
2457         skb->destructor = sock_wfree;
2458         skb_set_hash_from_sk(skb, sk);
2459         /*
2460          * We used to take a refcount on sk, but following operation
2461          * is enough to guarantee sk_free() wont free this sock until
2462          * all in-flight packets are completed
2463          */
2464         refcount_add(skb->truesize, &sk->sk_wmem_alloc);
2465 }
2466 EXPORT_SYMBOL(skb_set_owner_w);
2467
2468 static bool can_skb_orphan_partial(const struct sk_buff *skb)
2469 {
2470 #ifdef CONFIG_TLS_DEVICE
2471         /* Drivers depend on in-order delivery for crypto offload,
2472          * partial orphan breaks out-of-order-OK logic.
2473          */
2474         if (skb->decrypted)
2475                 return false;
2476 #endif
2477         return (skb->destructor == sock_wfree ||
2478                 (IS_ENABLED(CONFIG_INET) && skb->destructor == tcp_wfree));
2479 }
2480
2481 /* This helper is used by netem, as it can hold packets in its
2482  * delay queue. We want to allow the owner socket to send more
2483  * packets, as if they were already TX completed by a typical driver.
2484  * But we also want to keep skb->sk set because some packet schedulers
2485  * rely on it (sch_fq for example).
2486  */
2487 void skb_orphan_partial(struct sk_buff *skb)
2488 {
2489         if (skb_is_tcp_pure_ack(skb))
2490                 return;
2491
2492         if (can_skb_orphan_partial(skb) && skb_set_owner_sk_safe(skb, skb->sk))
2493                 return;
2494
2495         skb_orphan(skb);
2496 }
2497 EXPORT_SYMBOL(skb_orphan_partial);
2498
2499 /*
2500  * Read buffer destructor automatically called from kfree_skb.
2501  */
2502 void sock_rfree(struct sk_buff *skb)
2503 {
2504         struct sock *sk = skb->sk;
2505         unsigned int len = skb->truesize;
2506
2507         atomic_sub(len, &sk->sk_rmem_alloc);
2508         sk_mem_uncharge(sk, len);
2509 }
2510 EXPORT_SYMBOL(sock_rfree);
2511
2512 /*
2513  * Buffer destructor for skbs that are not used directly in read or write
2514  * path, e.g. for error handler skbs. Automatically called from kfree_skb.
2515  */
2516 void sock_efree(struct sk_buff *skb)
2517 {
2518         sock_put(skb->sk);
2519 }
2520 EXPORT_SYMBOL(sock_efree);
2521
2522 /* Buffer destructor for prefetch/receive path where reference count may
2523  * not be held, e.g. for listen sockets.
2524  */
2525 #ifdef CONFIG_INET
2526 void sock_pfree(struct sk_buff *skb)
2527 {
2528         if (sk_is_refcounted(skb->sk))
2529                 sock_gen_put(skb->sk);
2530 }
2531 EXPORT_SYMBOL(sock_pfree);
2532 #endif /* CONFIG_INET */
2533
2534 kuid_t sock_i_uid(struct sock *sk)
2535 {
2536         kuid_t uid;
2537
2538         read_lock_bh(&sk->sk_callback_lock);
2539         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
2540         read_unlock_bh(&sk->sk_callback_lock);
2541         return uid;
2542 }
2543 EXPORT_SYMBOL(sock_i_uid);
2544
2545 unsigned long __sock_i_ino(struct sock *sk)
2546 {
2547         unsigned long ino;
2548
2549         read_lock(&sk->sk_callback_lock);
2550         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
2551         read_unlock(&sk->sk_callback_lock);
2552         return ino;
2553 }
2554 EXPORT_SYMBOL(__sock_i_ino);
2555
2556 unsigned long sock_i_ino(struct sock *sk)
2557 {
2558         unsigned long ino;
2559
2560         local_bh_disable();
2561         ino = __sock_i_ino(sk);
2562         local_bh_enable();
2563         return ino;
2564 }
2565 EXPORT_SYMBOL(sock_i_ino);
2566
2567 /*
2568  * Allocate a skb from the socket's send buffer.
2569  */
2570 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
2571                              gfp_t priority)
2572 {
2573         if (force ||
2574             refcount_read(&sk->sk_wmem_alloc) < READ_ONCE(sk->sk_sndbuf)) {
2575                 struct sk_buff *skb = alloc_skb(size, priority);
2576
2577                 if (skb) {
2578                         skb_set_owner_w(skb, sk);
2579                         return skb;
2580                 }
2581         }
2582         return NULL;
2583 }
2584 EXPORT_SYMBOL(sock_wmalloc);
2585
2586 static void sock_ofree(struct sk_buff *skb)
2587 {
2588         struct sock *sk = skb->sk;
2589
2590         atomic_sub(skb->truesize, &sk->sk_omem_alloc);
2591 }
2592
2593 struct sk_buff *sock_omalloc(struct sock *sk, unsigned long size,
2594                              gfp_t priority)
2595 {
2596         struct sk_buff *skb;
2597
2598         /* small safe race: SKB_TRUESIZE may differ from final skb->truesize */
2599         if (atomic_read(&sk->sk_omem_alloc) + SKB_TRUESIZE(size) >
2600             READ_ONCE(sysctl_optmem_max))
2601                 return NULL;
2602
2603         skb = alloc_skb(size, priority);
2604         if (!skb)
2605                 return NULL;
2606
2607         atomic_add(skb->truesize, &sk->sk_omem_alloc);
2608         skb->sk = sk;
2609         skb->destructor = sock_ofree;
2610         return skb;
2611 }
2612
2613 /*
2614  * Allocate a memory block from the socket's option memory buffer.
2615  */
2616 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
2617 {
2618         int optmem_max = READ_ONCE(sysctl_optmem_max);
2619
2620         if ((unsigned int)size <= optmem_max &&
2621             atomic_read(&sk->sk_omem_alloc) + size < optmem_max) {
2622                 void *mem;
2623                 /* First do the add, to avoid the race if kmalloc
2624                  * might sleep.
2625                  */
2626                 atomic_add(size, &sk->sk_omem_alloc);
2627                 mem = kmalloc(size, priority);
2628                 if (mem)
2629                         return mem;
2630                 atomic_sub(size, &sk->sk_omem_alloc);
2631         }
2632         return NULL;
2633 }
2634 EXPORT_SYMBOL(sock_kmalloc);
2635
2636 /* Free an option memory block. Note, we actually want the inline
2637  * here as this allows gcc to detect the nullify and fold away the
2638  * condition entirely.
2639  */
2640 static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
2641                                   const bool nullify)
2642 {
2643         if (WARN_ON_ONCE(!mem))
2644                 return;
2645         if (nullify)
2646                 kfree_sensitive(mem);
2647         else
2648                 kfree(mem);
2649         atomic_sub(size, &sk->sk_omem_alloc);
2650 }
2651
2652 void sock_kfree_s(struct sock *sk, void *mem, int size)
2653 {
2654         __sock_kfree_s(sk, mem, size, false);
2655 }
2656 EXPORT_SYMBOL(sock_kfree_s);
2657
2658 void sock_kzfree_s(struct sock *sk, void *mem, int size)
2659 {
2660         __sock_kfree_s(sk, mem, size, true);
2661 }
2662 EXPORT_SYMBOL(sock_kzfree_s);
2663
2664 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
2665    I think, these locks should be removed for datagram sockets.
2666  */
2667 static long sock_wait_for_wmem(struct sock *sk, long timeo)
2668 {
2669         DEFINE_WAIT(wait);
2670
2671         sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2672         for (;;) {
2673                 if (!timeo)
2674                         break;
2675                 if (signal_pending(current))
2676                         break;
2677                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
2678                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2679                 if (refcount_read(&sk->sk_wmem_alloc) < READ_ONCE(sk->sk_sndbuf))
2680                         break;
2681                 if (sk->sk_shutdown & SEND_SHUTDOWN)
2682                         break;
2683                 if (sk->sk_err)
2684                         break;
2685                 timeo = schedule_timeout(timeo);
2686         }
2687         finish_wait(sk_sleep(sk), &wait);
2688         return timeo;
2689 }
2690
2691
2692 /*
2693  *      Generic send/receive buffer handlers
2694  */
2695
2696 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
2697                                      unsigned long data_len, int noblock,
2698                                      int *errcode, int max_page_order)
2699 {
2700         struct sk_buff *skb;
2701         long timeo;
2702         int err;
2703
2704         timeo = sock_sndtimeo(sk, noblock);
2705         for (;;) {
2706                 err = sock_error(sk);
2707                 if (err != 0)
2708                         goto failure;
2709
2710                 err = -EPIPE;
2711                 if (sk->sk_shutdown & SEND_SHUTDOWN)
2712                         goto failure;
2713
2714                 if (sk_wmem_alloc_get(sk) < READ_ONCE(sk->sk_sndbuf))
2715                         break;
2716
2717                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2718                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
2719                 err = -EAGAIN;
2720                 if (!timeo)
2721                         goto failure;
2722                 if (signal_pending(current))
2723                         goto interrupted;
2724                 timeo = sock_wait_for_wmem(sk, timeo);
2725         }
2726         skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
2727                                    errcode, sk->sk_allocation);
2728         if (skb)
2729                 skb_set_owner_w(skb, sk);
2730         return skb;
2731
2732 interrupted:
2733         err = sock_intr_errno(timeo);
2734 failure:
2735         *errcode = err;
2736         return NULL;
2737 }
2738 EXPORT_SYMBOL(sock_alloc_send_pskb);
2739
2740 int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
2741                      struct sockcm_cookie *sockc)
2742 {
2743         u32 tsflags;
2744
2745         switch (cmsg->cmsg_type) {
2746         case SO_MARK:
2747                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_RAW) &&
2748                     !ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
2749                         return -EPERM;
2750                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
2751                         return -EINVAL;
2752                 sockc->mark = *(u32 *)CMSG_DATA(cmsg);
2753                 break;
2754         case SO_TIMESTAMPING_OLD:
2755                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
2756                         return -EINVAL;
2757
2758                 tsflags = *(u32 *)CMSG_DATA(cmsg);
2759                 if (tsflags & ~SOF_TIMESTAMPING_TX_RECORD_MASK)
2760                         return -EINVAL;
2761
2762                 sockc->tsflags &= ~SOF_TIMESTAMPING_TX_RECORD_MASK;
2763                 sockc->tsflags |= tsflags;
2764                 break;
2765         case SCM_TXTIME:
2766                 if (!sock_flag(sk, SOCK_TXTIME))
2767                         return -EINVAL;
2768                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u64)))
2769                         return -EINVAL;
2770                 sockc->transmit_time = get_unaligned((u64 *)CMSG_DATA(cmsg));
2771                 break;
2772         /* SCM_RIGHTS and SCM_CREDENTIALS are semantically in SOL_UNIX. */
2773         case SCM_RIGHTS:
2774         case SCM_CREDENTIALS:
2775                 break;
2776         default:
2777                 return -EINVAL;
2778         }
2779         return 0;
2780 }
2781 EXPORT_SYMBOL(__sock_cmsg_send);
2782
2783 int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
2784                    struct sockcm_cookie *sockc)
2785 {
2786         struct cmsghdr *cmsg;
2787         int ret;
2788
2789         for_each_cmsghdr(cmsg, msg) {
2790                 if (!CMSG_OK(msg, cmsg))
2791                         return -EINVAL;
2792                 if (cmsg->cmsg_level != SOL_SOCKET)
2793                         continue;
2794                 ret = __sock_cmsg_send(sk, msg, cmsg, sockc);
2795                 if (ret)
2796                         return ret;
2797         }
2798         return 0;
2799 }
2800 EXPORT_SYMBOL(sock_cmsg_send);
2801
2802 static void sk_enter_memory_pressure(struct sock *sk)
2803 {
2804         if (!sk->sk_prot->enter_memory_pressure)
2805                 return;
2806
2807         sk->sk_prot->enter_memory_pressure(sk);
2808 }
2809
2810 static void sk_leave_memory_pressure(struct sock *sk)
2811 {
2812         if (sk->sk_prot->leave_memory_pressure) {
2813                 INDIRECT_CALL_INET_1(sk->sk_prot->leave_memory_pressure,
2814                                      tcp_leave_memory_pressure, sk);
2815         } else {
2816                 unsigned long *memory_pressure = sk->sk_prot->memory_pressure;
2817
2818                 if (memory_pressure && READ_ONCE(*memory_pressure))
2819                         WRITE_ONCE(*memory_pressure, 0);
2820         }
2821 }
2822
2823 DEFINE_STATIC_KEY_FALSE(net_high_order_alloc_disable_key);
2824
2825 /**
2826  * skb_page_frag_refill - check that a page_frag contains enough room
2827  * @sz: minimum size of the fragment we want to get
2828  * @pfrag: pointer to page_frag
2829  * @gfp: priority for memory allocation
2830  *
2831  * Note: While this allocator tries to use high order pages, there is
2832  * no guarantee that allocations succeed. Therefore, @sz MUST be
2833  * less or equal than PAGE_SIZE.
2834  */
2835 bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
2836 {
2837         if (pfrag->page) {
2838                 if (page_ref_count(pfrag->page) == 1) {
2839                         pfrag->offset = 0;
2840                         return true;
2841                 }
2842                 if (pfrag->offset + sz <= pfrag->size)
2843                         return true;
2844                 put_page(pfrag->page);
2845         }
2846
2847         pfrag->offset = 0;
2848         if (SKB_FRAG_PAGE_ORDER &&
2849             !static_branch_unlikely(&net_high_order_alloc_disable_key)) {
2850                 /* Avoid direct reclaim but allow kswapd to wake */
2851                 pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) |
2852                                           __GFP_COMP | __GFP_NOWARN |
2853                                           __GFP_NORETRY,
2854                                           SKB_FRAG_PAGE_ORDER);
2855                 if (likely(pfrag->page)) {
2856                         pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
2857                         return true;
2858                 }
2859         }
2860         pfrag->page = alloc_page(gfp);
2861         if (likely(pfrag->page)) {
2862                 pfrag->size = PAGE_SIZE;
2863                 return true;
2864         }
2865         return false;
2866 }
2867 EXPORT_SYMBOL(skb_page_frag_refill);
2868
2869 bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
2870 {
2871         if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
2872                 return true;
2873
2874         sk_enter_memory_pressure(sk);
2875         sk_stream_moderate_sndbuf(sk);
2876         return false;
2877 }
2878 EXPORT_SYMBOL(sk_page_frag_refill);
2879
2880 void __lock_sock(struct sock *sk)
2881         __releases(&sk->sk_lock.slock)
2882         __acquires(&sk->sk_lock.slock)
2883 {
2884         DEFINE_WAIT(wait);
2885
2886         for (;;) {
2887                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
2888                                         TASK_UNINTERRUPTIBLE);
2889                 spin_unlock_bh(&sk->sk_lock.slock);
2890                 schedule();
2891                 spin_lock_bh(&sk->sk_lock.slock);
2892                 if (!sock_owned_by_user(sk))
2893                         break;
2894         }
2895         finish_wait(&sk->sk_lock.wq, &wait);
2896 }
2897
2898 void __release_sock(struct sock *sk)
2899         __releases(&sk->sk_lock.slock)
2900         __acquires(&sk->sk_lock.slock)
2901 {
2902         struct sk_buff *skb, *next;
2903
2904         while ((skb = sk->sk_backlog.head) != NULL) {
2905                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
2906
2907                 spin_unlock_bh(&sk->sk_lock.slock);
2908
2909                 do {
2910                         next = skb->next;
2911                         prefetch(next);
2912                         DEBUG_NET_WARN_ON_ONCE(skb_dst_is_noref(skb));
2913                         skb_mark_not_on_list(skb);
2914                         sk_backlog_rcv(sk, skb);
2915
2916                         cond_resched();
2917
2918                         skb = next;
2919                 } while (skb != NULL);
2920
2921                 spin_lock_bh(&sk->sk_lock.slock);
2922         }
2923
2924         /*
2925          * Doing the zeroing here guarantee we can not loop forever
2926          * while a wild producer attempts to flood us.
2927          */
2928         sk->sk_backlog.len = 0;
2929 }
2930
2931 void __sk_flush_backlog(struct sock *sk)
2932 {
2933         spin_lock_bh(&sk->sk_lock.slock);
2934         __release_sock(sk);
2935         spin_unlock_bh(&sk->sk_lock.slock);
2936 }
2937 EXPORT_SYMBOL_GPL(__sk_flush_backlog);
2938
2939 /**
2940  * sk_wait_data - wait for data to arrive at sk_receive_queue
2941  * @sk:    sock to wait on
2942  * @timeo: for how long
2943  * @skb:   last skb seen on sk_receive_queue
2944  *
2945  * Now socket state including sk->sk_err is changed only under lock,
2946  * hence we may omit checks after joining wait queue.
2947  * We check receive queue before schedule() only as optimization;
2948  * it is very likely that release_sock() added new data.
2949  */
2950 int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
2951 {
2952         DEFINE_WAIT_FUNC(wait, woken_wake_function);
2953         int rc;
2954
2955         add_wait_queue(sk_sleep(sk), &wait);
2956         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2957         rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
2958         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2959         remove_wait_queue(sk_sleep(sk), &wait);
2960         return rc;
2961 }
2962 EXPORT_SYMBOL(sk_wait_data);
2963
2964 /**
2965  *      __sk_mem_raise_allocated - increase memory_allocated
2966  *      @sk: socket
2967  *      @size: memory size to allocate
2968  *      @amt: pages to allocate
2969  *      @kind: allocation type
2970  *
2971  *      Similar to __sk_mem_schedule(), but does not update sk_forward_alloc
2972  */
2973 int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
2974 {
2975         bool memcg_charge = mem_cgroup_sockets_enabled && sk->sk_memcg;
2976         struct proto *prot = sk->sk_prot;
2977         bool charged = true;
2978         long allocated;
2979
2980         sk_memory_allocated_add(sk, amt);
2981         allocated = sk_memory_allocated(sk);
2982         if (memcg_charge &&
2983             !(charged = mem_cgroup_charge_skmem(sk->sk_memcg, amt,
2984                                                 gfp_memcg_charge())))
2985                 goto suppress_allocation;
2986
2987         /* Under limit. */
2988         if (allocated <= sk_prot_mem_limits(sk, 0)) {
2989                 sk_leave_memory_pressure(sk);
2990                 return 1;
2991         }
2992
2993         /* Under pressure. */
2994         if (allocated > sk_prot_mem_limits(sk, 1))
2995                 sk_enter_memory_pressure(sk);
2996
2997         /* Over hard limit. */
2998         if (allocated > sk_prot_mem_limits(sk, 2))
2999                 goto suppress_allocation;
3000
3001         /* guarantee minimum buffer size under pressure */
3002         if (kind == SK_MEM_RECV) {
3003                 if (atomic_read(&sk->sk_rmem_alloc) < sk_get_rmem0(sk, prot))
3004                         return 1;
3005
3006         } else { /* SK_MEM_SEND */
3007                 int wmem0 = sk_get_wmem0(sk, prot);
3008
3009                 if (sk->sk_type == SOCK_STREAM) {
3010                         if (sk->sk_wmem_queued < wmem0)
3011                                 return 1;
3012                 } else if (refcount_read(&sk->sk_wmem_alloc) < wmem0) {
3013                                 return 1;
3014                 }
3015         }
3016
3017         if (sk_has_memory_pressure(sk)) {
3018                 u64 alloc;
3019
3020                 if (!sk_under_memory_pressure(sk))
3021                         return 1;
3022                 alloc = sk_sockets_allocated_read_positive(sk);
3023                 if (sk_prot_mem_limits(sk, 2) > alloc *
3024                     sk_mem_pages(sk->sk_wmem_queued +
3025                                  atomic_read(&sk->sk_rmem_alloc) +
3026                                  sk->sk_forward_alloc))
3027                         return 1;
3028         }
3029
3030 suppress_allocation:
3031
3032         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
3033                 sk_stream_moderate_sndbuf(sk);
3034
3035                 /* Fail only if socket is _under_ its sndbuf.
3036                  * In this case we cannot block, so that we have to fail.
3037                  */
3038                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf) {
3039                         /* Force charge with __GFP_NOFAIL */
3040                         if (memcg_charge && !charged) {
3041                                 mem_cgroup_charge_skmem(sk->sk_memcg, amt,
3042                                         gfp_memcg_charge() | __GFP_NOFAIL);
3043                         }
3044                         return 1;
3045                 }
3046         }
3047
3048         if (kind == SK_MEM_SEND || (kind == SK_MEM_RECV && charged))
3049                 trace_sock_exceed_buf_limit(sk, prot, allocated, kind);
3050
3051         sk_memory_allocated_sub(sk, amt);
3052
3053         if (memcg_charge && charged)
3054                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amt);
3055
3056         return 0;
3057 }
3058
3059 /**
3060  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
3061  *      @sk: socket
3062  *      @size: memory size to allocate
3063  *      @kind: allocation type
3064  *
3065  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
3066  *      rmem allocation. This function assumes that protocols which have
3067  *      memory_pressure use sk_wmem_queued as write buffer accounting.
3068  */
3069 int __sk_mem_schedule(struct sock *sk, int size, int kind)
3070 {
3071         int ret, amt = sk_mem_pages(size);
3072
3073         sk->sk_forward_alloc += amt << PAGE_SHIFT;
3074         ret = __sk_mem_raise_allocated(sk, size, amt, kind);
3075         if (!ret)
3076                 sk->sk_forward_alloc -= amt << PAGE_SHIFT;
3077         return ret;
3078 }
3079 EXPORT_SYMBOL(__sk_mem_schedule);
3080
3081 /**
3082  *      __sk_mem_reduce_allocated - reclaim memory_allocated
3083  *      @sk: socket
3084  *      @amount: number of quanta
3085  *
3086  *      Similar to __sk_mem_reclaim(), but does not update sk_forward_alloc
3087  */
3088 void __sk_mem_reduce_allocated(struct sock *sk, int amount)
3089 {
3090         sk_memory_allocated_sub(sk, amount);
3091
3092         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
3093                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amount);
3094
3095         if (sk_under_memory_pressure(sk) &&
3096             (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
3097                 sk_leave_memory_pressure(sk);
3098 }
3099
3100 /**
3101  *      __sk_mem_reclaim - reclaim sk_forward_alloc and memory_allocated
3102  *      @sk: socket
3103  *      @amount: number of bytes (rounded down to a PAGE_SIZE multiple)
3104  */
3105 void __sk_mem_reclaim(struct sock *sk, int amount)
3106 {
3107         amount >>= PAGE_SHIFT;
3108         sk->sk_forward_alloc -= amount << PAGE_SHIFT;
3109         __sk_mem_reduce_allocated(sk, amount);
3110 }
3111 EXPORT_SYMBOL(__sk_mem_reclaim);
3112
3113 int sk_set_peek_off(struct sock *sk, int val)
3114 {
3115         sk->sk_peek_off = val;
3116         return 0;
3117 }
3118 EXPORT_SYMBOL_GPL(sk_set_peek_off);
3119
3120 /*
3121  * Set of default routines for initialising struct proto_ops when
3122  * the protocol does not support a particular function. In certain
3123  * cases where it makes no sense for a protocol to have a "do nothing"
3124  * function, some default processing is provided.
3125  */
3126
3127 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
3128 {
3129         return -EOPNOTSUPP;
3130 }
3131 EXPORT_SYMBOL(sock_no_bind);
3132
3133 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
3134                     int len, int flags)
3135 {
3136         return -EOPNOTSUPP;
3137 }
3138 EXPORT_SYMBOL(sock_no_connect);
3139
3140 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
3141 {
3142         return -EOPNOTSUPP;
3143 }
3144 EXPORT_SYMBOL(sock_no_socketpair);
3145
3146 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags,
3147                    bool kern)
3148 {
3149         return -EOPNOTSUPP;
3150 }
3151 EXPORT_SYMBOL(sock_no_accept);
3152
3153 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
3154                     int peer)
3155 {
3156         return -EOPNOTSUPP;
3157 }
3158 EXPORT_SYMBOL(sock_no_getname);
3159
3160 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
3161 {
3162         return -EOPNOTSUPP;
3163 }
3164 EXPORT_SYMBOL(sock_no_ioctl);
3165
3166 int sock_no_listen(struct socket *sock, int backlog)
3167 {
3168         return -EOPNOTSUPP;
3169 }
3170 EXPORT_SYMBOL(sock_no_listen);
3171
3172 int sock_no_shutdown(struct socket *sock, int how)
3173 {
3174         return -EOPNOTSUPP;
3175 }
3176 EXPORT_SYMBOL(sock_no_shutdown);
3177
3178 int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
3179 {
3180         return -EOPNOTSUPP;
3181 }
3182 EXPORT_SYMBOL(sock_no_sendmsg);
3183
3184 int sock_no_sendmsg_locked(struct sock *sk, struct msghdr *m, size_t len)
3185 {
3186         return -EOPNOTSUPP;
3187 }
3188 EXPORT_SYMBOL(sock_no_sendmsg_locked);
3189
3190 int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
3191                     int flags)
3192 {
3193         return -EOPNOTSUPP;
3194 }
3195 EXPORT_SYMBOL(sock_no_recvmsg);
3196
3197 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
3198 {
3199         /* Mirror missing mmap method error code */
3200         return -ENODEV;
3201 }
3202 EXPORT_SYMBOL(sock_no_mmap);
3203
3204 /*
3205  * When a file is received (via SCM_RIGHTS, etc), we must bump the
3206  * various sock-based usage counts.
3207  */
3208 void __receive_sock(struct file *file)
3209 {
3210         struct socket *sock;
3211
3212         sock = sock_from_file(file);
3213         if (sock) {
3214                 sock_update_netprioidx(&sock->sk->sk_cgrp_data);
3215                 sock_update_classid(&sock->sk->sk_cgrp_data);
3216         }
3217 }
3218
3219 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
3220 {
3221         ssize_t res;
3222         struct msghdr msg = {.msg_flags = flags};
3223         struct kvec iov;
3224         char *kaddr = kmap(page);
3225         iov.iov_base = kaddr + offset;
3226         iov.iov_len = size;
3227         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
3228         kunmap(page);
3229         return res;
3230 }
3231 EXPORT_SYMBOL(sock_no_sendpage);
3232
3233 ssize_t sock_no_sendpage_locked(struct sock *sk, struct page *page,
3234                                 int offset, size_t size, int flags)
3235 {
3236         ssize_t res;
3237         struct msghdr msg = {.msg_flags = flags};
3238         struct kvec iov;
3239         char *kaddr = kmap(page);
3240
3241         iov.iov_base = kaddr + offset;
3242         iov.iov_len = size;
3243         res = kernel_sendmsg_locked(sk, &msg, &iov, 1, size);
3244         kunmap(page);
3245         return res;
3246 }
3247 EXPORT_SYMBOL(sock_no_sendpage_locked);
3248
3249 /*
3250  *      Default Socket Callbacks
3251  */
3252
3253 static void sock_def_wakeup(struct sock *sk)
3254 {
3255         struct socket_wq *wq;
3256
3257         rcu_read_lock();
3258         wq = rcu_dereference(sk->sk_wq);
3259         if (skwq_has_sleeper(wq))
3260                 wake_up_interruptible_all(&wq->wait);
3261         rcu_read_unlock();
3262 }
3263
3264 static void sock_def_error_report(struct sock *sk)
3265 {
3266         struct socket_wq *wq;
3267
3268         rcu_read_lock();
3269         wq = rcu_dereference(sk->sk_wq);
3270         if (skwq_has_sleeper(wq))
3271                 wake_up_interruptible_poll(&wq->wait, EPOLLERR);
3272         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
3273         rcu_read_unlock();
3274 }
3275
3276 void sock_def_readable(struct sock *sk)
3277 {
3278         struct socket_wq *wq;
3279
3280         rcu_read_lock();
3281         wq = rcu_dereference(sk->sk_wq);
3282         if (skwq_has_sleeper(wq))
3283                 wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
3284                                                 EPOLLRDNORM | EPOLLRDBAND);
3285         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
3286         rcu_read_unlock();
3287 }
3288
3289 static void sock_def_write_space(struct sock *sk)
3290 {
3291         struct socket_wq *wq;
3292
3293         rcu_read_lock();
3294
3295         /* Do not wake up a writer until he can make "significant"
3296          * progress.  --DaveM
3297          */
3298         if (sock_writeable(sk)) {
3299                 wq = rcu_dereference(sk->sk_wq);
3300                 if (skwq_has_sleeper(wq))
3301                         wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
3302                                                 EPOLLWRNORM | EPOLLWRBAND);
3303
3304                 /* Should agree with poll, otherwise some programs break */
3305                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
3306         }
3307
3308         rcu_read_unlock();
3309 }
3310
3311 /* An optimised version of sock_def_write_space(), should only be called
3312  * for SOCK_RCU_FREE sockets under RCU read section and after putting
3313  * ->sk_wmem_alloc.
3314  */
3315 static void sock_def_write_space_wfree(struct sock *sk)
3316 {
3317         /* Do not wake up a writer until he can make "significant"
3318          * progress.  --DaveM
3319          */
3320         if (sock_writeable(sk)) {
3321                 struct socket_wq *wq = rcu_dereference(sk->sk_wq);
3322
3323                 /* rely on refcount_sub from sock_wfree() */
3324                 smp_mb__after_atomic();
3325                 if (wq && waitqueue_active(&wq->wait))
3326                         wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
3327                                                 EPOLLWRNORM | EPOLLWRBAND);
3328
3329                 /* Should agree with poll, otherwise some programs break */
3330                 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
3331         }
3332 }
3333
3334 static void sock_def_destruct(struct sock *sk)
3335 {
3336 }
3337
3338 void sk_send_sigurg(struct sock *sk)
3339 {
3340         if (sk->sk_socket && sk->sk_socket->file)
3341                 if (send_sigurg(&sk->sk_socket->file->f_owner))
3342                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
3343 }
3344 EXPORT_SYMBOL(sk_send_sigurg);
3345
3346 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
3347                     unsigned long expires)
3348 {
3349         if (!mod_timer(timer, expires))
3350                 sock_hold(sk);
3351 }
3352 EXPORT_SYMBOL(sk_reset_timer);
3353
3354 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
3355 {
3356         if (del_timer(timer))
3357                 __sock_put(sk);
3358 }
3359 EXPORT_SYMBOL(sk_stop_timer);
3360
3361 void sk_stop_timer_sync(struct sock *sk, struct timer_list *timer)
3362 {
3363         if (del_timer_sync(timer))
3364                 __sock_put(sk);
3365 }
3366 EXPORT_SYMBOL(sk_stop_timer_sync);
3367
3368 void sock_init_data_uid(struct socket *sock, struct sock *sk, kuid_t uid)
3369 {
3370         sk_init_common(sk);
3371         sk->sk_send_head        =       NULL;
3372
3373         timer_setup(&sk->sk_timer, NULL, 0);
3374
3375         sk->sk_allocation       =       GFP_KERNEL;
3376         sk->sk_rcvbuf           =       READ_ONCE(sysctl_rmem_default);
3377         sk->sk_sndbuf           =       READ_ONCE(sysctl_wmem_default);
3378         sk->sk_state            =       TCP_CLOSE;
3379         sk_set_socket(sk, sock);
3380
3381         sock_set_flag(sk, SOCK_ZAPPED);
3382
3383         if (sock) {
3384                 sk->sk_type     =       sock->type;
3385                 RCU_INIT_POINTER(sk->sk_wq, &sock->wq);
3386                 sock->sk        =       sk;
3387         } else {
3388                 RCU_INIT_POINTER(sk->sk_wq, NULL);
3389         }
3390         sk->sk_uid      =       uid;
3391
3392         rwlock_init(&sk->sk_callback_lock);
3393         if (sk->sk_kern_sock)
3394                 lockdep_set_class_and_name(
3395                         &sk->sk_callback_lock,
3396                         af_kern_callback_keys + sk->sk_family,
3397                         af_family_kern_clock_key_strings[sk->sk_family]);
3398         else
3399                 lockdep_set_class_and_name(
3400                         &sk->sk_callback_lock,
3401                         af_callback_keys + sk->sk_family,
3402                         af_family_clock_key_strings[sk->sk_family]);
3403
3404         sk->sk_state_change     =       sock_def_wakeup;
3405         sk->sk_data_ready       =       sock_def_readable;
3406         sk->sk_write_space      =       sock_def_write_space;
3407         sk->sk_error_report     =       sock_def_error_report;
3408         sk->sk_destruct         =       sock_def_destruct;
3409
3410         sk->sk_frag.page        =       NULL;
3411         sk->sk_frag.offset      =       0;
3412         sk->sk_peek_off         =       -1;
3413
3414         sk->sk_peer_pid         =       NULL;
3415         sk->sk_peer_cred        =       NULL;
3416         spin_lock_init(&sk->sk_peer_lock);
3417
3418         sk->sk_write_pending    =       0;
3419         sk->sk_rcvlowat         =       1;
3420         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
3421         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
3422
3423         sk->sk_stamp = SK_DEFAULT_STAMP;
3424 #if BITS_PER_LONG==32
3425         seqlock_init(&sk->sk_stamp_seq);
3426 #endif
3427         atomic_set(&sk->sk_zckey, 0);
3428
3429 #ifdef CONFIG_NET_RX_BUSY_POLL
3430         sk->sk_napi_id          =       0;
3431         sk->sk_ll_usec          =       READ_ONCE(sysctl_net_busy_read);
3432 #endif
3433
3434         sk->sk_max_pacing_rate = ~0UL;
3435         sk->sk_pacing_rate = ~0UL;
3436         WRITE_ONCE(sk->sk_pacing_shift, 10);
3437         sk->sk_incoming_cpu = -1;
3438
3439         sk_rx_queue_clear(sk);
3440         /*
3441          * Before updating sk_refcnt, we must commit prior changes to memory
3442          * (Documentation/RCU/rculist_nulls.rst for details)
3443          */
3444         smp_wmb();
3445         refcount_set(&sk->sk_refcnt, 1);
3446         atomic_set(&sk->sk_drops, 0);
3447 }
3448 EXPORT_SYMBOL(sock_init_data_uid);
3449
3450 void sock_init_data(struct socket *sock, struct sock *sk)
3451 {
3452         kuid_t uid = sock ?
3453                 SOCK_INODE(sock)->i_uid :
3454                 make_kuid(sock_net(sk)->user_ns, 0);
3455
3456         sock_init_data_uid(sock, sk, uid);
3457 }
3458 EXPORT_SYMBOL(sock_init_data);
3459
3460 void lock_sock_nested(struct sock *sk, int subclass)
3461 {
3462         /* The sk_lock has mutex_lock() semantics here. */
3463         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
3464
3465         might_sleep();
3466         spin_lock_bh(&sk->sk_lock.slock);
3467         if (sock_owned_by_user_nocheck(sk))
3468                 __lock_sock(sk);
3469         sk->sk_lock.owned = 1;
3470         spin_unlock_bh(&sk->sk_lock.slock);
3471 }
3472 EXPORT_SYMBOL(lock_sock_nested);
3473
3474 void release_sock(struct sock *sk)
3475 {
3476         spin_lock_bh(&sk->sk_lock.slock);
3477         if (sk->sk_backlog.tail)
3478                 __release_sock(sk);
3479
3480         /* Warning : release_cb() might need to release sk ownership,
3481          * ie call sock_release_ownership(sk) before us.
3482          */
3483         if (sk->sk_prot->release_cb)
3484                 sk->sk_prot->release_cb(sk);
3485
3486         sock_release_ownership(sk);
3487         if (waitqueue_active(&sk->sk_lock.wq))
3488                 wake_up(&sk->sk_lock.wq);
3489         spin_unlock_bh(&sk->sk_lock.slock);
3490 }
3491 EXPORT_SYMBOL(release_sock);
3492
3493 bool __lock_sock_fast(struct sock *sk) __acquires(&sk->sk_lock.slock)
3494 {
3495         might_sleep();
3496         spin_lock_bh(&sk->sk_lock.slock);
3497
3498         if (!sock_owned_by_user_nocheck(sk)) {
3499                 /*
3500                  * Fast path return with bottom halves disabled and
3501                  * sock::sk_lock.slock held.
3502                  *
3503                  * The 'mutex' is not contended and holding
3504                  * sock::sk_lock.slock prevents all other lockers to
3505                  * proceed so the corresponding unlock_sock_fast() can
3506                  * avoid the slow path of release_sock() completely and
3507                  * just release slock.
3508                  *
3509                  * From a semantical POV this is equivalent to 'acquiring'
3510                  * the 'mutex', hence the corresponding lockdep
3511                  * mutex_release() has to happen in the fast path of
3512                  * unlock_sock_fast().
3513                  */
3514                 return false;
3515         }
3516
3517         __lock_sock(sk);
3518         sk->sk_lock.owned = 1;
3519         __acquire(&sk->sk_lock.slock);
3520         spin_unlock_bh(&sk->sk_lock.slock);
3521         return true;
3522 }
3523 EXPORT_SYMBOL(__lock_sock_fast);
3524
3525 int sock_gettstamp(struct socket *sock, void __user *userstamp,
3526                    bool timeval, bool time32)
3527 {
3528         struct sock *sk = sock->sk;
3529         struct timespec64 ts;
3530
3531         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
3532         ts = ktime_to_timespec64(sock_read_timestamp(sk));
3533         if (ts.tv_sec == -1)
3534                 return -ENOENT;
3535         if (ts.tv_sec == 0) {
3536                 ktime_t kt = ktime_get_real();
3537                 sock_write_timestamp(sk, kt);
3538                 ts = ktime_to_timespec64(kt);
3539         }
3540
3541         if (timeval)
3542                 ts.tv_nsec /= 1000;
3543
3544 #ifdef CONFIG_COMPAT_32BIT_TIME
3545         if (time32)
3546                 return put_old_timespec32(&ts, userstamp);
3547 #endif
3548 #ifdef CONFIG_SPARC64
3549         /* beware of padding in sparc64 timeval */
3550         if (timeval && !in_compat_syscall()) {
3551                 struct __kernel_old_timeval __user tv = {
3552                         .tv_sec = ts.tv_sec,
3553                         .tv_usec = ts.tv_nsec,
3554                 };
3555                 if (copy_to_user(userstamp, &tv, sizeof(tv)))
3556                         return -EFAULT;
3557                 return 0;
3558         }
3559 #endif
3560         return put_timespec64(&ts, userstamp);
3561 }
3562 EXPORT_SYMBOL(sock_gettstamp);
3563
3564 void sock_enable_timestamp(struct sock *sk, enum sock_flags flag)
3565 {
3566         if (!sock_flag(sk, flag)) {
3567                 unsigned long previous_flags = sk->sk_flags;
3568
3569                 sock_set_flag(sk, flag);
3570                 /*
3571                  * we just set one of the two flags which require net
3572                  * time stamping, but time stamping might have been on
3573                  * already because of the other one
3574                  */
3575                 if (sock_needs_netstamp(sk) &&
3576                     !(previous_flags & SK_FLAGS_TIMESTAMP))
3577                         net_enable_timestamp();
3578         }
3579 }
3580
3581 int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
3582                        int level, int type)
3583 {
3584         struct sock_exterr_skb *serr;
3585         struct sk_buff *skb;
3586         int copied, err;
3587
3588         err = -EAGAIN;
3589         skb = sock_dequeue_err_skb(sk);
3590         if (skb == NULL)
3591                 goto out;
3592
3593         copied = skb->len;
3594         if (copied > len) {
3595                 msg->msg_flags |= MSG_TRUNC;
3596                 copied = len;
3597         }
3598         err = skb_copy_datagram_msg(skb, 0, msg, copied);
3599         if (err)
3600                 goto out_free_skb;
3601
3602         sock_recv_timestamp(msg, sk, skb);
3603
3604         serr = SKB_EXT_ERR(skb);
3605         put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
3606
3607         msg->msg_flags |= MSG_ERRQUEUE;
3608         err = copied;
3609
3610 out_free_skb:
3611         kfree_skb(skb);
3612 out:
3613         return err;
3614 }
3615 EXPORT_SYMBOL(sock_recv_errqueue);
3616
3617 /*
3618  *      Get a socket option on an socket.
3619  *
3620  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
3621  *      asynchronous errors should be reported by getsockopt. We assume
3622  *      this means if you specify SO_ERROR (otherwise whats the point of it).
3623  */
3624 int sock_common_getsockopt(struct socket *sock, int level, int optname,
3625                            char __user *optval, int __user *optlen)
3626 {
3627         struct sock *sk = sock->sk;
3628
3629         /* IPV6_ADDRFORM can change sk->sk_prot under us. */
3630         return READ_ONCE(sk->sk_prot)->getsockopt(sk, level, optname, optval, optlen);
3631 }
3632 EXPORT_SYMBOL(sock_common_getsockopt);
3633
3634 int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
3635                         int flags)
3636 {
3637         struct sock *sk = sock->sk;
3638         int addr_len = 0;
3639         int err;
3640
3641         err = sk->sk_prot->recvmsg(sk, msg, size, flags, &addr_len);
3642         if (err >= 0)
3643                 msg->msg_namelen = addr_len;
3644         return err;
3645 }
3646 EXPORT_SYMBOL(sock_common_recvmsg);
3647
3648 /*
3649  *      Set socket options on an inet socket.
3650  */
3651 int sock_common_setsockopt(struct socket *sock, int level, int optname,
3652                            sockptr_t optval, unsigned int optlen)
3653 {
3654         struct sock *sk = sock->sk;
3655
3656         /* IPV6_ADDRFORM can change sk->sk_prot under us. */
3657         return READ_ONCE(sk->sk_prot)->setsockopt(sk, level, optname, optval, optlen);
3658 }
3659 EXPORT_SYMBOL(sock_common_setsockopt);
3660
3661 void sk_common_release(struct sock *sk)
3662 {
3663         if (sk->sk_prot->destroy)
3664                 sk->sk_prot->destroy(sk);
3665
3666         /*
3667          * Observation: when sk_common_release is called, processes have
3668          * no access to socket. But net still has.
3669          * Step one, detach it from networking:
3670          *
3671          * A. Remove from hash tables.
3672          */
3673
3674         sk->sk_prot->unhash(sk);
3675
3676         /*
3677          * In this point socket cannot receive new packets, but it is possible
3678          * that some packets are in flight because some CPU runs receiver and
3679          * did hash table lookup before we unhashed socket. They will achieve
3680          * receive queue and will be purged by socket destructor.
3681          *
3682          * Also we still have packets pending on receive queue and probably,
3683          * our own packets waiting in device queues. sock_destroy will drain
3684          * receive queue, but transmitted packets will delay socket destruction
3685          * until the last reference will be released.
3686          */
3687
3688         sock_orphan(sk);
3689
3690         xfrm_sk_free_policy(sk);
3691
3692         sk_refcnt_debug_release(sk);
3693
3694         sock_put(sk);
3695 }
3696 EXPORT_SYMBOL(sk_common_release);
3697
3698 void sk_get_meminfo(const struct sock *sk, u32 *mem)
3699 {
3700         memset(mem, 0, sizeof(*mem) * SK_MEMINFO_VARS);
3701
3702         mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk);
3703         mem[SK_MEMINFO_RCVBUF] = READ_ONCE(sk->sk_rcvbuf);
3704         mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk);
3705         mem[SK_MEMINFO_SNDBUF] = READ_ONCE(sk->sk_sndbuf);
3706         mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc;
3707         mem[SK_MEMINFO_WMEM_QUEUED] = READ_ONCE(sk->sk_wmem_queued);
3708         mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc);
3709         mem[SK_MEMINFO_BACKLOG] = READ_ONCE(sk->sk_backlog.len);
3710         mem[SK_MEMINFO_DROPS] = atomic_read(&sk->sk_drops);
3711 }
3712
3713 #ifdef CONFIG_PROC_FS
3714 static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
3715
3716 int sock_prot_inuse_get(struct net *net, struct proto *prot)
3717 {
3718         int cpu, idx = prot->inuse_idx;
3719         int res = 0;
3720
3721         for_each_possible_cpu(cpu)
3722                 res += per_cpu_ptr(net->core.prot_inuse, cpu)->val[idx];
3723
3724         return res >= 0 ? res : 0;
3725 }
3726 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
3727
3728 int sock_inuse_get(struct net *net)
3729 {
3730         int cpu, res = 0;
3731
3732         for_each_possible_cpu(cpu)
3733                 res += per_cpu_ptr(net->core.prot_inuse, cpu)->all;
3734
3735         return res;
3736 }
3737
3738 EXPORT_SYMBOL_GPL(sock_inuse_get);
3739
3740 static int __net_init sock_inuse_init_net(struct net *net)
3741 {
3742         net->core.prot_inuse = alloc_percpu(struct prot_inuse);
3743         if (net->core.prot_inuse == NULL)
3744                 return -ENOMEM;
3745         return 0;
3746 }
3747
3748 static void __net_exit sock_inuse_exit_net(struct net *net)
3749 {
3750         free_percpu(net->core.prot_inuse);
3751 }
3752
3753 static struct pernet_operations net_inuse_ops = {
3754         .init = sock_inuse_init_net,
3755         .exit = sock_inuse_exit_net,
3756 };
3757
3758 static __init int net_inuse_init(void)
3759 {
3760         if (register_pernet_subsys(&net_inuse_ops))
3761                 panic("Cannot initialize net inuse counters");
3762
3763         return 0;
3764 }
3765
3766 core_initcall(net_inuse_init);
3767
3768 static int assign_proto_idx(struct proto *prot)
3769 {
3770         prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
3771
3772         if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
3773                 pr_err("PROTO_INUSE_NR exhausted\n");
3774                 return -ENOSPC;
3775         }
3776
3777         set_bit(prot->inuse_idx, proto_inuse_idx);
3778         return 0;
3779 }
3780
3781 static void release_proto_idx(struct proto *prot)
3782 {
3783         if (prot->inuse_idx != PROTO_INUSE_NR - 1)
3784                 clear_bit(prot->inuse_idx, proto_inuse_idx);
3785 }
3786 #else
3787 static inline int assign_proto_idx(struct proto *prot)
3788 {
3789         return 0;
3790 }
3791
3792 static inline void release_proto_idx(struct proto *prot)
3793 {
3794 }
3795
3796 #endif
3797
3798 static void tw_prot_cleanup(struct timewait_sock_ops *twsk_prot)
3799 {
3800         if (!twsk_prot)
3801                 return;
3802         kfree(twsk_prot->twsk_slab_name);
3803         twsk_prot->twsk_slab_name = NULL;
3804         kmem_cache_destroy(twsk_prot->twsk_slab);
3805         twsk_prot->twsk_slab = NULL;
3806 }
3807
3808 static int tw_prot_init(const struct proto *prot)
3809 {
3810         struct timewait_sock_ops *twsk_prot = prot->twsk_prot;
3811
3812         if (!twsk_prot)
3813                 return 0;
3814
3815         twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s",
3816                                               prot->name);
3817         if (!twsk_prot->twsk_slab_name)
3818                 return -ENOMEM;
3819
3820         twsk_prot->twsk_slab =
3821                 kmem_cache_create(twsk_prot->twsk_slab_name,
3822                                   twsk_prot->twsk_obj_size, 0,
3823                                   SLAB_ACCOUNT | prot->slab_flags,
3824                                   NULL);
3825         if (!twsk_prot->twsk_slab) {
3826                 pr_crit("%s: Can't create timewait sock SLAB cache!\n",
3827                         prot->name);
3828                 return -ENOMEM;
3829         }
3830
3831         return 0;
3832 }
3833
3834 static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
3835 {
3836         if (!rsk_prot)
3837                 return;
3838         kfree(rsk_prot->slab_name);
3839         rsk_prot->slab_name = NULL;
3840         kmem_cache_destroy(rsk_prot->slab);
3841         rsk_prot->slab = NULL;
3842 }
3843
3844 static int req_prot_init(const struct proto *prot)
3845 {
3846         struct request_sock_ops *rsk_prot = prot->rsk_prot;
3847
3848         if (!rsk_prot)
3849                 return 0;
3850
3851         rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
3852                                         prot->name);
3853         if (!rsk_prot->slab_name)
3854                 return -ENOMEM;
3855
3856         rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
3857                                            rsk_prot->obj_size, 0,
3858                                            SLAB_ACCOUNT | prot->slab_flags,
3859                                            NULL);
3860
3861         if (!rsk_prot->slab) {
3862                 pr_crit("%s: Can't create request sock SLAB cache!\n",
3863                         prot->name);
3864                 return -ENOMEM;
3865         }
3866         return 0;
3867 }
3868
3869 int proto_register(struct proto *prot, int alloc_slab)
3870 {
3871         int ret = -ENOBUFS;
3872
3873         if (prot->memory_allocated && !prot->sysctl_mem) {
3874                 pr_err("%s: missing sysctl_mem\n", prot->name);
3875                 return -EINVAL;
3876         }
3877         if (prot->memory_allocated && !prot->per_cpu_fw_alloc) {
3878                 pr_err("%s: missing per_cpu_fw_alloc\n", prot->name);
3879                 return -EINVAL;
3880         }
3881         if (alloc_slab) {
3882                 prot->slab = kmem_cache_create_usercopy(prot->name,
3883                                         prot->obj_size, 0,
3884                                         SLAB_HWCACHE_ALIGN | SLAB_ACCOUNT |
3885                                         prot->slab_flags,
3886                                         prot->useroffset, prot->usersize,
3887                                         NULL);
3888
3889                 if (prot->slab == NULL) {
3890                         pr_crit("%s: Can't create sock SLAB cache!\n",
3891                                 prot->name);
3892                         goto out;
3893                 }
3894
3895                 if (req_prot_init(prot))
3896                         goto out_free_request_sock_slab;
3897
3898                 if (tw_prot_init(prot))
3899                         goto out_free_timewait_sock_slab;
3900         }
3901
3902         mutex_lock(&proto_list_mutex);
3903         ret = assign_proto_idx(prot);
3904         if (ret) {
3905                 mutex_unlock(&proto_list_mutex);
3906                 goto out_free_timewait_sock_slab;
3907         }
3908         list_add(&prot->node, &proto_list);
3909         mutex_unlock(&proto_list_mutex);
3910         return ret;
3911
3912 out_free_timewait_sock_slab:
3913         if (alloc_slab)
3914                 tw_prot_cleanup(prot->twsk_prot);
3915 out_free_request_sock_slab:
3916         if (alloc_slab) {
3917                 req_prot_cleanup(prot->rsk_prot);
3918
3919                 kmem_cache_destroy(prot->slab);
3920                 prot->slab = NULL;
3921         }
3922 out:
3923         return ret;
3924 }
3925 EXPORT_SYMBOL(proto_register);
3926
3927 void proto_unregister(struct proto *prot)
3928 {
3929         mutex_lock(&proto_list_mutex);
3930         release_proto_idx(prot);
3931         list_del(&prot->node);
3932         mutex_unlock(&proto_list_mutex);
3933
3934         kmem_cache_destroy(prot->slab);
3935         prot->slab = NULL;
3936
3937         req_prot_cleanup(prot->rsk_prot);
3938         tw_prot_cleanup(prot->twsk_prot);
3939 }
3940 EXPORT_SYMBOL(proto_unregister);
3941
3942 int sock_load_diag_module(int family, int protocol)
3943 {
3944         if (!protocol) {
3945                 if (!sock_is_registered(family))
3946                         return -ENOENT;
3947
3948                 return request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
3949                                       NETLINK_SOCK_DIAG, family);
3950         }
3951
3952 #ifdef CONFIG_INET
3953         if (family == AF_INET &&
3954             protocol != IPPROTO_RAW &&
3955             protocol < MAX_INET_PROTOS &&
3956             !rcu_access_pointer(inet_protos[protocol]))
3957                 return -ENOENT;
3958 #endif
3959
3960         return request_module("net-pf-%d-proto-%d-type-%d-%d", PF_NETLINK,
3961                               NETLINK_SOCK_DIAG, family, protocol);
3962 }
3963 EXPORT_SYMBOL(sock_load_diag_module);
3964
3965 #ifdef CONFIG_PROC_FS
3966 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
3967         __acquires(proto_list_mutex)
3968 {
3969         mutex_lock(&proto_list_mutex);
3970         return seq_list_start_head(&proto_list, *pos);
3971 }
3972
3973 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3974 {
3975         return seq_list_next(v, &proto_list, pos);
3976 }
3977
3978 static void proto_seq_stop(struct seq_file *seq, void *v)
3979         __releases(proto_list_mutex)
3980 {
3981         mutex_unlock(&proto_list_mutex);
3982 }
3983
3984 static char proto_method_implemented(const void *method)
3985 {
3986         return method == NULL ? 'n' : 'y';
3987 }
3988 static long sock_prot_memory_allocated(struct proto *proto)
3989 {
3990         return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
3991 }
3992
3993 static const char *sock_prot_memory_pressure(struct proto *proto)
3994 {
3995         return proto->memory_pressure != NULL ?
3996         proto_memory_pressure(proto) ? "yes" : "no" : "NI";
3997 }
3998
3999 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
4000 {
4001
4002         seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
4003                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
4004                    proto->name,
4005                    proto->obj_size,
4006                    sock_prot_inuse_get(seq_file_net(seq), proto),
4007                    sock_prot_memory_allocated(proto),
4008                    sock_prot_memory_pressure(proto),
4009                    proto->max_header,
4010                    proto->slab == NULL ? "no" : "yes",
4011                    module_name(proto->owner),
4012                    proto_method_implemented(proto->close),
4013                    proto_method_implemented(proto->connect),
4014                    proto_method_implemented(proto->disconnect),
4015                    proto_method_implemented(proto->accept),
4016                    proto_method_implemented(proto->ioctl),
4017                    proto_method_implemented(proto->init),
4018                    proto_method_implemented(proto->destroy),
4019                    proto_method_implemented(proto->shutdown),
4020                    proto_method_implemented(proto->setsockopt),
4021                    proto_method_implemented(proto->getsockopt),
4022                    proto_method_implemented(proto->sendmsg),
4023                    proto_method_implemented(proto->recvmsg),
4024                    proto_method_implemented(proto->sendpage),
4025                    proto_method_implemented(proto->bind),
4026                    proto_method_implemented(proto->backlog_rcv),
4027                    proto_method_implemented(proto->hash),
4028                    proto_method_implemented(proto->unhash),
4029                    proto_method_implemented(proto->get_port),
4030                    proto_method_implemented(proto->enter_memory_pressure));
4031 }
4032
4033 static int proto_seq_show(struct seq_file *seq, void *v)
4034 {
4035         if (v == &proto_list)
4036                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
4037                            "protocol",
4038                            "size",
4039                            "sockets",
4040                            "memory",
4041                            "press",
4042                            "maxhdr",
4043                            "slab",
4044                            "module",
4045                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
4046         else
4047                 proto_seq_printf(seq, list_entry(v, struct proto, node));
4048         return 0;
4049 }
4050
4051 static const struct seq_operations proto_seq_ops = {
4052         .start  = proto_seq_start,
4053         .next   = proto_seq_next,
4054         .stop   = proto_seq_stop,
4055         .show   = proto_seq_show,
4056 };
4057
4058 static __net_init int proto_init_net(struct net *net)
4059 {
4060         if (!proc_create_net("protocols", 0444, net->proc_net, &proto_seq_ops,
4061                         sizeof(struct seq_net_private)))
4062                 return -ENOMEM;
4063
4064         return 0;
4065 }
4066
4067 static __net_exit void proto_exit_net(struct net *net)
4068 {
4069         remove_proc_entry("protocols", net->proc_net);
4070 }
4071
4072
4073 static __net_initdata struct pernet_operations proto_net_ops = {
4074         .init = proto_init_net,
4075         .exit = proto_exit_net,
4076 };
4077
4078 static int __init proto_init(void)
4079 {
4080         return register_pernet_subsys(&proto_net_ops);
4081 }
4082
4083 subsys_initcall(proto_init);
4084
4085 #endif /* PROC_FS */
4086
4087 #ifdef CONFIG_NET_RX_BUSY_POLL
4088 bool sk_busy_loop_end(void *p, unsigned long start_time)
4089 {
4090         struct sock *sk = p;
4091
4092         return !skb_queue_empty_lockless(&sk->sk_receive_queue) ||
4093                sk_busy_loop_timeout(sk, start_time);
4094 }
4095 EXPORT_SYMBOL(sk_busy_loop_end);
4096 #endif /* CONFIG_NET_RX_BUSY_POLL */
4097
4098 int sock_bind_add(struct sock *sk, struct sockaddr *addr, int addr_len)
4099 {
4100         if (!sk->sk_prot->bind_add)
4101                 return -EOPNOTSUPP;
4102         return sk->sk_prot->bind_add(sk, addr, addr_len);
4103 }
4104 EXPORT_SYMBOL(sock_bind_add);