net/core/sock.c

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