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