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                 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         if (sk->sk_prot->rehash)
 571                 sk->sk_prot->rehash(sk);
 572         sk_dst_reset(sk);
 573         release_sock(sk);
 574
 575         ret = 0;
 576
 577 out:
 578 #endif
 579
 580         return ret;
 581 }
 582
 583 static int sock_getbindtodevice(struct sock *sk, char __user *optval,
 584                                 int __user *optlen, int len)
 585 {
 586         int ret = -ENOPROTOOPT;
 587 #ifdef CONFIG_NETDEVICES
 588         struct net *net = sock_net(sk);
 589         char devname[IFNAMSIZ];
 590
 591         if (sk->sk_bound_dev_if == 0) {
 592                 len = 0;
 593                 goto zero;
 594         }
 595
 596         ret = -EINVAL;
 597         if (len < IFNAMSIZ)
 598                 goto out;
 599
 600         ret = netdev_get_name(net, devname, sk->sk_bound_dev_if);
 601         if (ret)
 602                 goto out;
 603
 604         len = strlen(devname) + 1;
 605
 606         ret = -EFAULT;
 607         if (copy_to_user(optval, devname, len))
 608                 goto out;
 609
 610 zero:
 611         ret = -EFAULT;
 612         if (put_user(len, optlen))
 613                 goto out;
 614
 615         ret = 0;
 616
 617 out:
 618 #endif
 619
 620         return ret;
 621 }
 622
 623 static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
 624 {
 625         if (valbool)
 626                 sock_set_flag(sk, bit);
 627         else
 628                 sock_reset_flag(sk, bit);
 629 }
 630
 631 bool sk_mc_loop(struct sock *sk)
 632 {
 633         if (dev_recursion_level())
 634                 return false;
 635         if (!sk)
 636                 return true;
 637         switch (sk->sk_family) {
 638         case AF_INET:
 639                 return inet_sk(sk)->mc_loop;
 640 #if IS_ENABLED(CONFIG_IPV6)
 641         case AF_INET6:
 642                 return inet6_sk(sk)->mc_loop;
 643 #endif
 644         }
 645         WARN_ON(1);
 646         return true;
 647 }
 648 EXPORT_SYMBOL(sk_mc_loop);
 649
 650 /*
 651  *      This is meant for all protocols to use and covers goings on
 652  *      at the socket level. Everything here is generic.
 653  */
 654
 655 int sock_setsockopt(struct socket *sock, int level, int optname,
 656                     char __user *optval, unsigned int optlen)
 657 {
 658         struct sock_txtime sk_txtime;
 659         struct sock *sk = sock->sk;
 660         int val;
 661         int valbool;
 662         struct linger ling;
 663         int ret = 0;
 664
 665         /*
 666          *      Options without arguments
 667          */
 668
 669         if (optname == SO_BINDTODEVICE)
 670                 return sock_setbindtodevice(sk, optval, optlen);
 671
 672         if (optlen < sizeof(int))
 673                 return -EINVAL;
 674
 675         if (get_user(val, (int __user *)optval))
 676                 return -EFAULT;
 677
 678         valbool = val ? 1 : 0;
 679
 680         lock_sock(sk);
 681
 682         switch (optname) {
 683         case SO_DEBUG:
 684                 if (val && !capable(CAP_NET_ADMIN))
 685                         ret = -EACCES;
 686                 else
 687                         sock_valbool_flag(sk, SOCK_DBG, valbool);
 688                 break;
 689         case SO_REUSEADDR:
 690                 sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);
 691                 break;
 692         case SO_REUSEPORT:
 693                 sk->sk_reuseport = valbool;
 694                 break;
 695         case SO_TYPE:
 696         case SO_PROTOCOL:
 697         case SO_DOMAIN:
 698         case SO_ERROR:
 699                 ret = -ENOPROTOOPT;
 700                 break;
 701         case SO_DONTROUTE:
 702                 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
 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 if (val != sk->sk_mark) {
 958                         sk->sk_mark = val;
 959                         sk_dst_reset(sk);
 960                 }
 961                 break;
 962
 963         case SO_RXQ_OVFL:
 964                 sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
 965                 break;
 966
 967         case SO_WIFI_STATUS:
 968                 sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
 969                 break;
 970
 971         case SO_PEEK_OFF:
 972                 if (sock->ops->set_peek_off)
 973                         ret = sock->ops->set_peek_off(sk, val);
 974                 else
 975                         ret = -EOPNOTSUPP;
 976                 break;
 977
 978         case SO_NOFCS:
 979                 sock_valbool_flag(sk, SOCK_NOFCS, valbool);
 980                 break;
 981
 982         case SO_SELECT_ERR_QUEUE:
 983                 sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
 984                 break;
 985
 986 #ifdef CONFIG_NET_RX_BUSY_POLL
 987         case SO_BUSY_POLL:
 988                 /* allow unprivileged users to decrease the value */
 989                 if ((val > sk->sk_ll_usec) && !capable(CAP_NET_ADMIN))
 990                         ret = -EPERM;
 991                 else {
 992                         if (val < 0)
 993                                 ret = -EINVAL;
 994                         else
 995                                 sk->sk_ll_usec = val;
 996                 }
 997                 break;
 998 #endif
 999
1000         case SO_MAX_PACING_RATE:
1001                 if (val != ~0U)
1002                         cmpxchg(&sk->sk_pacing_status,
1003                                 SK_PACING_NONE,
1004                                 SK_PACING_NEEDED);
1005                 sk->sk_max_pacing_rate = (val == ~0U) ? ~0UL : val;
1006                 sk->sk_pacing_rate = min(sk->sk_pacing_rate,
1007                                          sk->sk_max_pacing_rate);
1008                 break;
1009
1010         case SO_INCOMING_CPU:
1011                 sk->sk_incoming_cpu = val;
1012                 break;
1013
1014         case SO_CNX_ADVICE:
1015                 if (val == 1)
1016                         dst_negative_advice(sk);
1017                 break;
1018
1019         case SO_ZEROCOPY:
1020                 if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6) {
1021                         if (sk->sk_protocol != IPPROTO_TCP)
1022                                 ret = -ENOTSUPP;
1023                 } else if (sk->sk_family != PF_RDS) {
1024                         ret = -ENOTSUPP;
1025                 }
1026                 if (!ret) {
1027                         if (val < 0 || val > 1)
1028                                 ret = -EINVAL;
1029                         else
1030                                 sock_valbool_flag(sk, SOCK_ZEROCOPY, valbool);
1031                 }
1032                 break;
1033
1034         case SO_TXTIME:
1035                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN)) {
1036                         ret = -EPERM;
1037                 } else if (optlen != sizeof(struct sock_txtime)) {
1038                         ret = -EINVAL;
1039                 } else if (copy_from_user(&sk_txtime, optval,
1040                            sizeof(struct sock_txtime))) {
1041                         ret = -EFAULT;
1042                 } else if (sk_txtime.flags & ~SOF_TXTIME_FLAGS_MASK) {
1043                         ret = -EINVAL;
1044                 } else {
1045                         sock_valbool_flag(sk, SOCK_TXTIME, true);
1046                         sk->sk_clockid = sk_txtime.clockid;
1047                         sk->sk_txtime_deadline_mode =
1048                                 !!(sk_txtime.flags & SOF_TXTIME_DEADLINE_MODE);
1049                         sk->sk_txtime_report_errors =
1050                                 !!(sk_txtime.flags & SOF_TXTIME_REPORT_ERRORS);
1051                 }
1052                 break;
1053
1054         default:
1055                 ret = -ENOPROTOOPT;
1056                 break;
1057         }
1058         release_sock(sk);
1059         return ret;
1060 }
1061 EXPORT_SYMBOL(sock_setsockopt);
1062
1063
1064 static void cred_to_ucred(struct pid *pid, const struct cred *cred,
1065                           struct ucred *ucred)
1066 {
1067         ucred->pid = pid_vnr(pid);
1068         ucred->uid = ucred->gid = -1;
1069         if (cred) {
1070                 struct user_namespace *current_ns = current_user_ns();
1071
1072                 ucred->uid = from_kuid_munged(current_ns, cred->euid);
1073                 ucred->gid = from_kgid_munged(current_ns, cred->egid);
1074         }
1075 }
1076
1077 static int groups_to_user(gid_t __user *dst, const struct group_info *src)
1078 {
1079         struct user_namespace *user_ns = current_user_ns();
1080         int i;
1081
1082         for (i = 0; i < src->ngroups; i++)
1083                 if (put_user(from_kgid_munged(user_ns, src->gid[i]), dst + i))
1084                         return -EFAULT;
1085
1086         return 0;
1087 }
1088
1089 int sock_getsockopt(struct socket *sock, int level, int optname,
1090                     char __user *optval, int __user *optlen)
1091 {
1092         struct sock *sk = sock->sk;
1093
1094         union {
1095                 int val;
1096                 u64 val64;
1097                 struct linger ling;
1098                 struct timeval tm;
1099                 struct sock_txtime txtime;
1100         } v;
1101
1102         int lv = sizeof(int);
1103         int len;
1104
1105         if (get_user(len, optlen))
1106                 return -EFAULT;
1107         if (len < 0)
1108                 return -EINVAL;
1109
1110         memset(&v, 0, sizeof(v));
1111
1112         switch (optname) {
1113         case SO_DEBUG:
1114                 v.val = sock_flag(sk, SOCK_DBG);
1115                 break;
1116
1117         case SO_DONTROUTE:
1118                 v.val = sock_flag(sk, SOCK_LOCALROUTE);
1119                 break;
1120
1121         case SO_BROADCAST:
1122                 v.val = sock_flag(sk, SOCK_BROADCAST);
1123                 break;
1124
1125         case SO_SNDBUF:
1126                 v.val = sk->sk_sndbuf;
1127                 break;
1128
1129         case SO_RCVBUF:
1130                 v.val = sk->sk_rcvbuf;
1131                 break;
1132
1133         case SO_REUSEADDR:
1134                 v.val = sk->sk_reuse;
1135                 break;
1136
1137         case SO_REUSEPORT:
1138                 v.val = sk->sk_reuseport;
1139                 break;
1140
1141         case SO_KEEPALIVE:
1142                 v.val = sock_flag(sk, SOCK_KEEPOPEN);
1143                 break;
1144
1145         case SO_TYPE:
1146                 v.val = sk->sk_type;
1147                 break;
1148
1149         case SO_PROTOCOL:
1150                 v.val = sk->sk_protocol;
1151                 break;
1152
1153         case SO_DOMAIN:
1154                 v.val = sk->sk_family;
1155                 break;
1156
1157         case SO_ERROR:
1158                 v.val = -sock_error(sk);
1159                 if (v.val == 0)
1160                         v.val = xchg(&sk->sk_err_soft, 0);
1161                 break;
1162
1163         case SO_OOBINLINE:
1164                 v.val = sock_flag(sk, SOCK_URGINLINE);
1165                 break;
1166
1167         case SO_NO_CHECK:
1168                 v.val = sk->sk_no_check_tx;
1169                 break;
1170
1171         case SO_PRIORITY:
1172                 v.val = sk->sk_priority;
1173                 break;
1174
1175         case SO_LINGER:
1176                 lv              = sizeof(v.ling);
1177                 v.ling.l_onoff  = sock_flag(sk, SOCK_LINGER);
1178                 v.ling.l_linger = sk->sk_lingertime / HZ;
1179                 break;
1180
1181         case SO_BSDCOMPAT:
1182                 sock_warn_obsolete_bsdism("getsockopt");
1183                 break;
1184
1185         case SO_TIMESTAMP:
1186                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
1187                                 !sock_flag(sk, SOCK_RCVTSTAMPNS);
1188                 break;
1189
1190         case SO_TIMESTAMPNS:
1191                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
1192                 break;
1193
1194         case SO_TIMESTAMPING:
1195                 v.val = sk->sk_tsflags;
1196                 break;
1197
1198         case SO_RCVTIMEO:
1199                 lv = sizeof(struct timeval);
1200                 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
1201                         v.tm.tv_sec = 0;
1202                         v.tm.tv_usec = 0;
1203                 } else {
1204                         v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
1205                         v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * USEC_PER_SEC) / HZ;
1206                 }
1207                 break;
1208
1209         case SO_SNDTIMEO:
1210                 lv = sizeof(struct timeval);
1211                 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
1212                         v.tm.tv_sec = 0;
1213                         v.tm.tv_usec = 0;
1214                 } else {
1215                         v.tm.tv_sec = sk->sk_sndtimeo / HZ;
1216                         v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * USEC_PER_SEC) / HZ;
1217                 }
1218                 break;
1219
1220         case SO_RCVLOWAT:
1221                 v.val = sk->sk_rcvlowat;
1222                 break;
1223
1224         case SO_SNDLOWAT:
1225                 v.val = 1;
1226                 break;
1227
1228         case SO_PASSCRED:
1229                 v.val = !!test_bit(SOCK_PASSCRED, &sock->flags);
1230                 break;
1231
1232         case SO_PEERCRED:
1233         {
1234                 struct ucred peercred;
1235                 if (len > sizeof(peercred))
1236                         len = sizeof(peercred);
1237                 cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
1238                 if (copy_to_user(optval, &peercred, len))
1239                         return -EFAULT;
1240                 goto lenout;
1241         }
1242
1243         case SO_PEERGROUPS:
1244         {
1245                 int ret, n;
1246
1247                 if (!sk->sk_peer_cred)
1248                         return -ENODATA;
1249
1250                 n = sk->sk_peer_cred->group_info->ngroups;
1251                 if (len < n * sizeof(gid_t)) {
1252                         len = n * sizeof(gid_t);
1253                         return put_user(len, optlen) ? -EFAULT : -ERANGE;
1254                 }
1255                 len = n * sizeof(gid_t);
1256
1257                 ret = groups_to_user((gid_t __user *)optval,
1258                                      sk->sk_peer_cred->group_info);
1259                 if (ret)
1260                         return ret;
1261                 goto lenout;
1262         }
1263
1264         case SO_PEERNAME:
1265         {
1266                 char address[128];
1267
1268                 lv = sock->ops->getname(sock, (struct sockaddr *)address, 2);
1269                 if (lv < 0)
1270                         return -ENOTCONN;
1271                 if (lv < len)
1272                         return -EINVAL;
1273                 if (copy_to_user(optval, address, len))
1274                         return -EFAULT;
1275                 goto lenout;
1276         }
1277
1278         /* Dubious BSD thing... Probably nobody even uses it, but
1279          * the UNIX standard wants it for whatever reason... -DaveM
1280          */
1281         case SO_ACCEPTCONN:
1282                 v.val = sk->sk_state == TCP_LISTEN;
1283                 break;
1284
1285         case SO_PASSSEC:
1286                 v.val = !!test_bit(SOCK_PASSSEC, &sock->flags);
1287                 break;
1288
1289         case SO_PEERSEC:
1290                 return security_socket_getpeersec_stream(sock, optval, optlen, len);
1291
1292         case SO_MARK:
1293                 v.val = sk->sk_mark;
1294                 break;
1295
1296         case SO_RXQ_OVFL:
1297                 v.val = sock_flag(sk, SOCK_RXQ_OVFL);
1298                 break;
1299
1300         case SO_WIFI_STATUS:
1301                 v.val = sock_flag(sk, SOCK_WIFI_STATUS);
1302                 break;
1303
1304         case SO_PEEK_OFF:
1305                 if (!sock->ops->set_peek_off)
1306                         return -EOPNOTSUPP;
1307
1308                 v.val = sk->sk_peek_off;
1309                 break;
1310         case SO_NOFCS:
1311                 v.val = sock_flag(sk, SOCK_NOFCS);
1312                 break;
1313
1314         case SO_BINDTODEVICE:
1315                 return sock_getbindtodevice(sk, optval, optlen, len);
1316
1317         case SO_GET_FILTER:
1318                 len = sk_get_filter(sk, (struct sock_filter __user *)optval, len);
1319                 if (len < 0)
1320                         return len;
1321
1322                 goto lenout;
1323
1324         case SO_LOCK_FILTER:
1325                 v.val = sock_flag(sk, SOCK_FILTER_LOCKED);
1326                 break;
1327
1328         case SO_BPF_EXTENSIONS:
1329                 v.val = bpf_tell_extensions();
1330                 break;
1331
1332         case SO_SELECT_ERR_QUEUE:
1333                 v.val = sock_flag(sk, SOCK_SELECT_ERR_QUEUE);
1334                 break;
1335
1336 #ifdef CONFIG_NET_RX_BUSY_POLL
1337         case SO_BUSY_POLL:
1338                 v.val = sk->sk_ll_usec;
1339                 break;
1340 #endif
1341
1342         case SO_MAX_PACING_RATE:
1343                 /* 32bit version */
1344                 v.val = min_t(unsigned long, sk->sk_max_pacing_rate, ~0U);
1345                 break;
1346
1347         case SO_INCOMING_CPU:
1348                 v.val = sk->sk_incoming_cpu;
1349                 break;
1350
1351         case SO_MEMINFO:
1352         {
1353                 u32 meminfo[SK_MEMINFO_VARS];
1354
1355                 if (get_user(len, optlen))
1356                         return -EFAULT;
1357
1358                 sk_get_meminfo(sk, meminfo);
1359
1360                 len = min_t(unsigned int, len, sizeof(meminfo));
1361                 if (copy_to_user(optval, &meminfo, len))
1362                         return -EFAULT;
1363
1364                 goto lenout;
1365         }
1366
1367 #ifdef CONFIG_NET_RX_BUSY_POLL
1368         case SO_INCOMING_NAPI_ID:
1369                 v.val = READ_ONCE(sk->sk_napi_id);
1370
1371                 /* aggregate non-NAPI IDs down to 0 */
1372                 if (v.val < MIN_NAPI_ID)
1373                         v.val = 0;
1374
1375                 break;
1376 #endif
1377
1378         case SO_COOKIE:
1379                 lv = sizeof(u64);
1380                 if (len < lv)
1381                         return -EINVAL;
1382                 v.val64 = sock_gen_cookie(sk);
1383                 break;
1384
1385         case SO_ZEROCOPY:
1386                 v.val = sock_flag(sk, SOCK_ZEROCOPY);
1387                 break;
1388
1389         case SO_TXTIME:
1390                 lv = sizeof(v.txtime);
1391                 v.txtime.clockid = sk->sk_clockid;
1392                 v.txtime.flags |= sk->sk_txtime_deadline_mode ?
1393                                   SOF_TXTIME_DEADLINE_MODE : 0;
1394                 v.txtime.flags |= sk->sk_txtime_report_errors ?
1395                                   SOF_TXTIME_REPORT_ERRORS : 0;
1396                 break;
1397
1398         default:
1399                 /* We implement the SO_SNDLOWAT etc to not be settable
1400                  * (1003.1g 7).
1401                  */
1402                 return -ENOPROTOOPT;
1403         }
1404
1405         if (len > lv)
1406                 len = lv;
1407         if (copy_to_user(optval, &v, len))
1408                 return -EFAULT;
1409 lenout:
1410         if (put_user(len, optlen))
1411                 return -EFAULT;
1412         return 0;
1413 }
1414
1415 /*
1416  * Initialize an sk_lock.
1417  *
1418  * (We also register the sk_lock with the lock validator.)
1419  */
1420 static inline void sock_lock_init(struct sock *sk)
1421 {
1422         if (sk->sk_kern_sock)
1423                 sock_lock_init_class_and_name(
1424                         sk,
1425                         af_family_kern_slock_key_strings[sk->sk_family],
1426                         af_family_kern_slock_keys + sk->sk_family,
1427                         af_family_kern_key_strings[sk->sk_family],
1428                         af_family_kern_keys + sk->sk_family);
1429         else
1430                 sock_lock_init_class_and_name(
1431                         sk,
1432                         af_family_slock_key_strings[sk->sk_family],
1433                         af_family_slock_keys + sk->sk_family,
1434                         af_family_key_strings[sk->sk_family],
1435                         af_family_keys + sk->sk_family);
1436 }
1437
1438 /*
1439  * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
1440  * even temporarly, because of RCU lookups. sk_node should also be left as is.
1441  * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
1442  */
1443 static void sock_copy(struct sock *nsk, const struct sock *osk)
1444 {
1445 #ifdef CONFIG_SECURITY_NETWORK
1446         void *sptr = nsk->sk_security;
1447 #endif
1448         memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
1449
1450         memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
1451                osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
1452
1453 #ifdef CONFIG_SECURITY_NETWORK
1454         nsk->sk_security = sptr;
1455         security_sk_clone(osk, nsk);
1456 #endif
1457 }
1458
1459 static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
1460                 int family)
1461 {
1462         struct sock *sk;
1463         struct kmem_cache *slab;
1464
1465         slab = prot->slab;
1466         if (slab != NULL) {
1467                 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
1468                 if (!sk)
1469                         return sk;
1470                 if (priority & __GFP_ZERO)
1471                         sk_prot_clear_nulls(sk, prot->obj_size);
1472         } else
1473                 sk = kmalloc(prot->obj_size, priority);
1474
1475         if (sk != NULL) {
1476                 if (security_sk_alloc(sk, family, priority))
1477                         goto out_free;
1478
1479                 if (!try_module_get(prot->owner))
1480                         goto out_free_sec;
1481                 sk_tx_queue_clear(sk);
1482         }
1483
1484         return sk;
1485
1486 out_free_sec:
1487         security_sk_free(sk);
1488 out_free:
1489         if (slab != NULL)
1490                 kmem_cache_free(slab, sk);
1491         else
1492                 kfree(sk);
1493         return NULL;
1494 }
1495
1496 static void sk_prot_free(struct proto *prot, struct sock *sk)
1497 {
1498         struct kmem_cache *slab;
1499         struct module *owner;
1500
1501         owner = prot->owner;
1502         slab = prot->slab;
1503
1504         cgroup_sk_free(&sk->sk_cgrp_data);
1505         mem_cgroup_sk_free(sk);
1506         security_sk_free(sk);
1507         if (slab != NULL)
1508                 kmem_cache_free(slab, sk);
1509         else
1510                 kfree(sk);
1511         module_put(owner);
1512 }
1513
1514 /**
1515  *      sk_alloc - All socket objects are allocated here
1516  *      @net: the applicable net namespace
1517  *      @family: protocol family
1518  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1519  *      @prot: struct proto associated with this new sock instance
1520  *      @kern: is this to be a kernel socket?
1521  */
1522 struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
1523                       struct proto *prot, int kern)
1524 {
1525         struct sock *sk;
1526
1527         sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
1528         if (sk) {
1529                 sk->sk_family = family;
1530                 /*
1531                  * See comment in struct sock definition to understand
1532                  * why we need sk_prot_creator -acme
1533                  */
1534                 sk->sk_prot = sk->sk_prot_creator = prot;
1535                 sk->sk_kern_sock = kern;
1536                 sock_lock_init(sk);
1537                 sk->sk_net_refcnt = kern ? 0 : 1;
1538                 if (likely(sk->sk_net_refcnt)) {
1539                         get_net(net);
1540                         sock_inuse_add(net, 1);
1541                 }
1542
1543                 sock_net_set(sk, net);
1544                 refcount_set(&sk->sk_wmem_alloc, 1);
1545
1546                 mem_cgroup_sk_alloc(sk);
1547                 cgroup_sk_alloc(&sk->sk_cgrp_data);
1548                 sock_update_classid(&sk->sk_cgrp_data);
1549                 sock_update_netprioidx(&sk->sk_cgrp_data);
1550         }
1551
1552         return sk;
1553 }
1554 EXPORT_SYMBOL(sk_alloc);
1555
1556 /* Sockets having SOCK_RCU_FREE will call this function after one RCU
1557  * grace period. This is the case for UDP sockets and TCP listeners.
1558  */
1559 static void __sk_destruct(struct rcu_head *head)
1560 {
1561         struct sock *sk = container_of(head, struct sock, sk_rcu);
1562         struct sk_filter *filter;
1563
1564         if (sk->sk_destruct)
1565                 sk->sk_destruct(sk);
1566
1567         filter = rcu_dereference_check(sk->sk_filter,
1568                                        refcount_read(&sk->sk_wmem_alloc) == 0);
1569         if (filter) {
1570                 sk_filter_uncharge(sk, filter);
1571                 RCU_INIT_POINTER(sk->sk_filter, NULL);
1572         }
1573         if (rcu_access_pointer(sk->sk_reuseport_cb))
1574                 reuseport_detach_sock(sk);
1575
1576         sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
1577
1578         if (atomic_read(&sk->sk_omem_alloc))
1579                 pr_debug("%s: optmem leakage (%d bytes) detected\n",
1580                          __func__, atomic_read(&sk->sk_omem_alloc));
1581
1582         if (sk->sk_frag.page) {
1583                 put_page(sk->sk_frag.page);
1584                 sk->sk_frag.page = NULL;
1585         }
1586
1587         if (sk->sk_peer_cred)
1588                 put_cred(sk->sk_peer_cred);
1589         put_pid(sk->sk_peer_pid);
1590         if (likely(sk->sk_net_refcnt))
1591                 put_net(sock_net(sk));
1592         sk_prot_free(sk->sk_prot_creator, sk);
1593 }
1594
1595 void sk_destruct(struct sock *sk)
1596 {
1597         if (sock_flag(sk, SOCK_RCU_FREE))
1598                 call_rcu(&sk->sk_rcu, __sk_destruct);
1599         else
1600                 __sk_destruct(&sk->sk_rcu);
1601 }
1602
1603 static void __sk_free(struct sock *sk)
1604 {
1605         if (likely(sk->sk_net_refcnt))
1606                 sock_inuse_add(sock_net(sk), -1);
1607
1608         if (unlikely(sk->sk_net_refcnt && sock_diag_has_destroy_listeners(sk)))
1609                 sock_diag_broadcast_destroy(sk);
1610         else
1611                 sk_destruct(sk);
1612 }
1613
1614 void sk_free(struct sock *sk)
1615 {
1616         /*
1617          * We subtract one from sk_wmem_alloc and can know if
1618          * some packets are still in some tx queue.
1619          * If not null, sock_wfree() will call __sk_free(sk) later
1620          */
1621         if (refcount_dec_and_test(&sk->sk_wmem_alloc))
1622                 __sk_free(sk);
1623 }
1624 EXPORT_SYMBOL(sk_free);
1625
1626 static void sk_init_common(struct sock *sk)
1627 {
1628         skb_queue_head_init(&sk->sk_receive_queue);
1629         skb_queue_head_init(&sk->sk_write_queue);
1630         skb_queue_head_init(&sk->sk_error_queue);
1631
1632         rwlock_init(&sk->sk_callback_lock);
1633         lockdep_set_class_and_name(&sk->sk_receive_queue.lock,
1634                         af_rlock_keys + sk->sk_family,
1635                         af_family_rlock_key_strings[sk->sk_family]);
1636         lockdep_set_class_and_name(&sk->sk_write_queue.lock,
1637                         af_wlock_keys + sk->sk_family,
1638                         af_family_wlock_key_strings[sk->sk_family]);
1639         lockdep_set_class_and_name(&sk->sk_error_queue.lock,
1640                         af_elock_keys + sk->sk_family,
1641                         af_family_elock_key_strings[sk->sk_family]);
1642         lockdep_set_class_and_name(&sk->sk_callback_lock,
1643                         af_callback_keys + sk->sk_family,
1644                         af_family_clock_key_strings[sk->sk_family]);
1645 }
1646
1647 /**
1648  *      sk_clone_lock - clone a socket, and lock its clone
1649  *      @sk: the socket to clone
1650  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1651  *
1652  *      Caller must unlock socket even in error path (bh_unlock_sock(newsk))
1653  */
1654 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
1655 {
1656         struct sock *newsk;
1657         bool is_charged = true;
1658
1659         newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
1660         if (newsk != NULL) {
1661                 struct sk_filter *filter;
1662
1663                 sock_copy(newsk, sk);
1664
1665                 newsk->sk_prot_creator = sk->sk_prot;
1666
1667                 /* SANITY */
1668                 if (likely(newsk->sk_net_refcnt))
1669                         get_net(sock_net(newsk));
1670                 sk_node_init(&newsk->sk_node);
1671                 sock_lock_init(newsk);
1672                 bh_lock_sock(newsk);
1673                 newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
1674                 newsk->sk_backlog.len = 0;
1675
1676                 atomic_set(&newsk->sk_rmem_alloc, 0);
1677                 /*
1678                  * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1679                  */
1680                 refcount_set(&newsk->sk_wmem_alloc, 1);
1681                 atomic_set(&newsk->sk_omem_alloc, 0);
1682                 sk_init_common(newsk);
1683
1684                 newsk->sk_dst_cache     = NULL;
1685                 newsk->sk_dst_pending_confirm = 0;
1686                 newsk->sk_wmem_queued   = 0;
1687                 newsk->sk_forward_alloc = 0;
1688                 atomic_set(&newsk->sk_drops, 0);
1689                 newsk->sk_send_head     = NULL;
1690                 newsk->sk_userlocks     = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1691                 atomic_set(&newsk->sk_zckey, 0);
1692
1693                 sock_reset_flag(newsk, SOCK_DONE);
1694                 mem_cgroup_sk_alloc(newsk);
1695                 cgroup_sk_alloc(&newsk->sk_cgrp_data);
1696
1697                 rcu_read_lock();
1698                 filter = rcu_dereference(sk->sk_filter);
1699                 if (filter != NULL)
1700                         /* though it's an empty new sock, the charging may fail
1701                          * if sysctl_optmem_max was changed between creation of
1702                          * original socket and cloning
1703                          */
1704                         is_charged = sk_filter_charge(newsk, filter);
1705                 RCU_INIT_POINTER(newsk->sk_filter, filter);
1706                 rcu_read_unlock();
1707
1708                 if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk, sk))) {
1709                         /* We need to make sure that we don't uncharge the new
1710                          * socket if we couldn't charge it in the first place
1711                          * as otherwise we uncharge the parent's filter.
1712                          */
1713                         if (!is_charged)
1714                                 RCU_INIT_POINTER(newsk->sk_filter, NULL);
1715                         sk_free_unlock_clone(newsk);
1716                         newsk = NULL;
1717                         goto out;
1718                 }
1719                 RCU_INIT_POINTER(newsk->sk_reuseport_cb, NULL);
1720
1721                 newsk->sk_err      = 0;
1722                 newsk->sk_err_soft = 0;
1723                 newsk->sk_priority = 0;
1724                 newsk->sk_incoming_cpu = raw_smp_processor_id();
1725                 atomic64_set(&newsk->sk_cookie, 0);
1726                 if (likely(newsk->sk_net_refcnt))
1727                         sock_inuse_add(sock_net(newsk), 1);
1728
1729                 /*
1730                  * Before updating sk_refcnt, we must commit prior changes to memory
1731                  * (Documentation/RCU/rculist_nulls.txt for details)
1732                  */
1733                 smp_wmb();
1734                 refcount_set(&newsk->sk_refcnt, 2);
1735
1736                 /*
1737                  * Increment the counter in the same struct proto as the master
1738                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1739                  * is the same as sk->sk_prot->socks, as this field was copied
1740                  * with memcpy).
1741                  *
1742                  * This _changes_ the previous behaviour, where
1743                  * tcp_create_openreq_child always was incrementing the
1744                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1745                  * to be taken into account in all callers. -acme
1746                  */
1747                 sk_refcnt_debug_inc(newsk);
1748                 sk_set_socket(newsk, NULL);
1749                 newsk->sk_wq = NULL;
1750
1751                 if (newsk->sk_prot->sockets_allocated)
1752                         sk_sockets_allocated_inc(newsk);
1753
1754                 if (sock_needs_netstamp(sk) &&
1755                     newsk->sk_flags & SK_FLAGS_TIMESTAMP)
1756                         net_enable_timestamp();
1757         }
1758 out:
1759         return newsk;
1760 }
1761 EXPORT_SYMBOL_GPL(sk_clone_lock);
1762
1763 void sk_free_unlock_clone(struct sock *sk)
1764 {
1765         /* It is still raw copy of parent, so invalidate
1766          * destructor and make plain sk_free() */
1767         sk->sk_destruct = NULL;
1768         bh_unlock_sock(sk);
1769         sk_free(sk);
1770 }
1771 EXPORT_SYMBOL_GPL(sk_free_unlock_clone);
1772
1773 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1774 {
1775         u32 max_segs = 1;
1776
1777         sk_dst_set(sk, dst);
1778         sk->sk_route_caps = dst->dev->features | sk->sk_route_forced_caps;
1779         if (sk->sk_route_caps & NETIF_F_GSO)
1780                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1781         sk->sk_route_caps &= ~sk->sk_route_nocaps;
1782         if (sk_can_gso(sk)) {
1783                 if (dst->header_len && !xfrm_dst_offload_ok(dst)) {
1784                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1785                 } else {
1786                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1787                         sk->sk_gso_max_size = dst->dev->gso_max_size;
1788                         max_segs = max_t(u32, dst->dev->gso_max_segs, 1);
1789                 }
1790         }
1791         sk->sk_gso_max_segs = max_segs;
1792 }
1793 EXPORT_SYMBOL_GPL(sk_setup_caps);
1794
1795 /*
1796  *      Simple resource managers for sockets.
1797  */
1798
1799
1800 /*
1801  * Write buffer destructor automatically called from kfree_skb.
1802  */
1803 void sock_wfree(struct sk_buff *skb)
1804 {
1805         struct sock *sk = skb->sk;
1806         unsigned int len = skb->truesize;
1807
1808         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1809                 /*
1810                  * Keep a reference on sk_wmem_alloc, this will be released
1811                  * after sk_write_space() call
1812                  */
1813                 WARN_ON(refcount_sub_and_test(len - 1, &sk->sk_wmem_alloc));
1814                 sk->sk_write_space(sk);
1815                 len = 1;
1816         }
1817         /*
1818          * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1819          * could not do because of in-flight packets
1820          */
1821         if (refcount_sub_and_test(len, &sk->sk_wmem_alloc))
1822                 __sk_free(sk);
1823 }
1824 EXPORT_SYMBOL(sock_wfree);
1825
1826 /* This variant of sock_wfree() is used by TCP,
1827  * since it sets SOCK_USE_WRITE_QUEUE.
1828  */
1829 void __sock_wfree(struct sk_buff *skb)
1830 {
1831         struct sock *sk = skb->sk;
1832
1833         if (refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc))
1834                 __sk_free(sk);
1835 }
1836
1837 void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1838 {
1839         skb_orphan(skb);
1840         skb->sk = sk;
1841 #ifdef CONFIG_INET
1842         if (unlikely(!sk_fullsock(sk))) {
1843                 skb->destructor = sock_edemux;
1844                 sock_hold(sk);
1845                 return;
1846         }
1847 #endif
1848         skb->destructor = sock_wfree;
1849         skb_set_hash_from_sk(skb, sk);
1850         /*
1851          * We used to take a refcount on sk, but following operation
1852          * is enough to guarantee sk_free() wont free this sock until
1853          * all in-flight packets are completed
1854          */
1855         refcount_add(skb->truesize, &sk->sk_wmem_alloc);
1856 }
1857 EXPORT_SYMBOL(skb_set_owner_w);
1858
1859 /* This helper is used by netem, as it can hold packets in its
1860  * delay queue. We want to allow the owner socket to send more
1861  * packets, as if they were already TX completed by a typical driver.
1862  * But we also want to keep skb->sk set because some packet schedulers
1863  * rely on it (sch_fq for example).
1864  */
1865 void skb_orphan_partial(struct sk_buff *skb)
1866 {
1867         if (skb_is_tcp_pure_ack(skb))
1868                 return;
1869
1870         if (skb->destructor == sock_wfree
1871 #ifdef CONFIG_INET
1872             || skb->destructor == tcp_wfree
1873 #endif
1874                 ) {
1875                 struct sock *sk = skb->sk;
1876
1877                 if (refcount_inc_not_zero(&sk->sk_refcnt)) {
1878                         WARN_ON(refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc));
1879                         skb->destructor = sock_efree;
1880                 }
1881         } else {
1882                 skb_orphan(skb);
1883         }
1884 }
1885 EXPORT_SYMBOL(skb_orphan_partial);
1886
1887 /*
1888  * Read buffer destructor automatically called from kfree_skb.
1889  */
1890 void sock_rfree(struct sk_buff *skb)
1891 {
1892         struct sock *sk = skb->sk;
1893         unsigned int len = skb->truesize;
1894
1895         atomic_sub(len, &sk->sk_rmem_alloc);
1896         sk_mem_uncharge(sk, len);
1897 }
1898 EXPORT_SYMBOL(sock_rfree);
1899
1900 /*
1901  * Buffer destructor for skbs that are not used directly in read or write
1902  * path, e.g. for error handler skbs. Automatically called from kfree_skb.
1903  */
1904 void sock_efree(struct sk_buff *skb)
1905 {
1906         sock_put(skb->sk);
1907 }
1908 EXPORT_SYMBOL(sock_efree);
1909
1910 kuid_t sock_i_uid(struct sock *sk)
1911 {
1912         kuid_t uid;
1913
1914         read_lock_bh(&sk->sk_callback_lock);
1915         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
1916         read_unlock_bh(&sk->sk_callback_lock);
1917         return uid;
1918 }
1919 EXPORT_SYMBOL(sock_i_uid);
1920
1921 unsigned long sock_i_ino(struct sock *sk)
1922 {
1923         unsigned long ino;
1924
1925         read_lock_bh(&sk->sk_callback_lock);
1926         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1927         read_unlock_bh(&sk->sk_callback_lock);
1928         return ino;
1929 }
1930 EXPORT_SYMBOL(sock_i_ino);
1931
1932 /*
1933  * Allocate a skb from the socket's send buffer.
1934  */
1935 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1936                              gfp_t priority)
1937 {
1938         if (force || refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1939                 struct sk_buff *skb = alloc_skb(size, priority);
1940                 if (skb) {
1941                         skb_set_owner_w(skb, sk);
1942                         return skb;
1943                 }
1944         }
1945         return NULL;
1946 }
1947 EXPORT_SYMBOL(sock_wmalloc);
1948
1949 static void sock_ofree(struct sk_buff *skb)
1950 {
1951         struct sock *sk = skb->sk;
1952
1953         atomic_sub(skb->truesize, &sk->sk_omem_alloc);
1954 }
1955
1956 struct sk_buff *sock_omalloc(struct sock *sk, unsigned long size,
1957                              gfp_t priority)
1958 {
1959         struct sk_buff *skb;
1960
1961         /* small safe race: SKB_TRUESIZE may differ from final skb->truesize */
1962         if (atomic_read(&sk->sk_omem_alloc) + SKB_TRUESIZE(size) >
1963             sysctl_optmem_max)
1964                 return NULL;
1965
1966         skb = alloc_skb(size, priority);
1967         if (!skb)
1968                 return NULL;
1969
1970         atomic_add(skb->truesize, &sk->sk_omem_alloc);
1971         skb->sk = sk;
1972         skb->destructor = sock_ofree;
1973         return skb;
1974 }
1975
1976 /*
1977  * Allocate a memory block from the socket's option memory buffer.
1978  */
1979 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1980 {
1981         if ((unsigned int)size <= sysctl_optmem_max &&
1982             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1983                 void *mem;
1984                 /* First do the add, to avoid the race if kmalloc
1985                  * might sleep.
1986                  */
1987                 atomic_add(size, &sk->sk_omem_alloc);
1988                 mem = kmalloc(size, priority);
1989                 if (mem)
1990                         return mem;
1991                 atomic_sub(size, &sk->sk_omem_alloc);
1992         }
1993         return NULL;
1994 }
1995 EXPORT_SYMBOL(sock_kmalloc);
1996
1997 /* Free an option memory block. Note, we actually want the inline
1998  * here as this allows gcc to detect the nullify and fold away the
1999  * condition entirely.
2000  */
2001 static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
2002                                   const bool nullify)
2003 {
2004         if (WARN_ON_ONCE(!mem))
2005                 return;
2006         if (nullify)
2007                 kzfree(mem);
2008         else
2009                 kfree(mem);
2010         atomic_sub(size, &sk->sk_omem_alloc);
2011 }
2012
2013 void sock_kfree_s(struct sock *sk, void *mem, int size)
2014 {
2015         __sock_kfree_s(sk, mem, size, false);
2016 }
2017 EXPORT_SYMBOL(sock_kfree_s);
2018
2019 void sock_kzfree_s(struct sock *sk, void *mem, int size)
2020 {
2021         __sock_kfree_s(sk, mem, size, true);
2022 }
2023 EXPORT_SYMBOL(sock_kzfree_s);
2024
2025 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
2026    I think, these locks should be removed for datagram sockets.
2027  */
2028 static long sock_wait_for_wmem(struct sock *sk, long timeo)
2029 {
2030         DEFINE_WAIT(wait);
2031
2032         sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2033         for (;;) {
2034                 if (!timeo)
2035                         break;
2036                 if (signal_pending(current))
2037                         break;
2038                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
2039                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2040                 if (refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
2041                         break;
2042                 if (sk->sk_shutdown & SEND_SHUTDOWN)
2043                         break;
2044                 if (sk->sk_err)
2045                         break;
2046                 timeo = schedule_timeout(timeo);
2047         }
2048         finish_wait(sk_sleep(sk), &wait);
2049         return timeo;
2050 }
2051
2052
2053 /*
2054  *      Generic send/receive buffer handlers
2055  */
2056
2057 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
2058                                      unsigned long data_len, int noblock,
2059                                      int *errcode, int max_page_order)
2060 {
2061         struct sk_buff *skb;
2062         long timeo;
2063         int err;
2064
2065         timeo = sock_sndtimeo(sk, noblock);
2066         for (;;) {
2067                 err = sock_error(sk);
2068                 if (err != 0)
2069                         goto failure;
2070
2071                 err = -EPIPE;
2072                 if (sk->sk_shutdown & SEND_SHUTDOWN)
2073                         goto failure;
2074
2075                 if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
2076                         break;
2077
2078                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2079                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
2080                 err = -EAGAIN;
2081                 if (!timeo)
2082                         goto failure;
2083                 if (signal_pending(current))
2084                         goto interrupted;
2085                 timeo = sock_wait_for_wmem(sk, timeo);
2086         }
2087         skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
2088                                    errcode, sk->sk_allocation);
2089         if (skb)
2090                 skb_set_owner_w(skb, sk);
2091         return skb;
2092
2093 interrupted:
2094         err = sock_intr_errno(timeo);
2095 failure:
2096         *errcode = err;
2097         return NULL;
2098 }
2099 EXPORT_SYMBOL(sock_alloc_send_pskb);
2100
2101 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
2102                                     int noblock, int *errcode)
2103 {
2104         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode, 0);
2105 }
2106 EXPORT_SYMBOL(sock_alloc_send_skb);
2107
2108 int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
2109                      struct sockcm_cookie *sockc)
2110 {
2111         u32 tsflags;
2112
2113         switch (cmsg->cmsg_type) {
2114         case SO_MARK:
2115                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
2116                         return -EPERM;
2117                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
2118                         return -EINVAL;
2119                 sockc->mark = *(u32 *)CMSG_DATA(cmsg);
2120                 break;
2121         case SO_TIMESTAMPING:
2122                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
2123                         return -EINVAL;
2124
2125                 tsflags = *(u32 *)CMSG_DATA(cmsg);
2126                 if (tsflags & ~SOF_TIMESTAMPING_TX_RECORD_MASK)
2127                         return -EINVAL;
2128
2129                 sockc->tsflags &= ~SOF_TIMESTAMPING_TX_RECORD_MASK;
2130                 sockc->tsflags |= tsflags;
2131                 break;
2132         case SCM_TXTIME:
2133                 if (!sock_flag(sk, SOCK_TXTIME))
2134                         return -EINVAL;
2135                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u64)))
2136                         return -EINVAL;
2137                 sockc->transmit_time = get_unaligned((u64 *)CMSG_DATA(cmsg));
2138                 break;
2139         /* SCM_RIGHTS and SCM_CREDENTIALS are semantically in SOL_UNIX. */
2140         case SCM_RIGHTS:
2141         case SCM_CREDENTIALS:
2142                 break;
2143         default:
2144                 return -EINVAL;
2145         }
2146         return 0;
2147 }
2148 EXPORT_SYMBOL(__sock_cmsg_send);
2149
2150 int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
2151                    struct sockcm_cookie *sockc)
2152 {
2153         struct cmsghdr *cmsg;
2154         int ret;
2155
2156         for_each_cmsghdr(cmsg, msg) {
2157                 if (!CMSG_OK(msg, cmsg))
2158                         return -EINVAL;
2159                 if (cmsg->cmsg_level != SOL_SOCKET)
2160                         continue;
2161                 ret = __sock_cmsg_send(sk, msg, cmsg, sockc);
2162                 if (ret)
2163                         return ret;
2164         }
2165         return 0;
2166 }
2167 EXPORT_SYMBOL(sock_cmsg_send);
2168
2169 static void sk_enter_memory_pressure(struct sock *sk)
2170 {
2171         if (!sk->sk_prot->enter_memory_pressure)
2172                 return;
2173
2174         sk->sk_prot->enter_memory_pressure(sk);
2175 }
2176
2177 static void sk_leave_memory_pressure(struct sock *sk)
2178 {
2179         if (sk->sk_prot->leave_memory_pressure) {
2180                 sk->sk_prot->leave_memory_pressure(sk);
2181         } else {
2182                 unsigned long *memory_pressure = sk->sk_prot->memory_pressure;
2183
2184                 if (memory_pressure && *memory_pressure)
2185                         *memory_pressure = 0;
2186         }
2187 }
2188
2189 /* On 32bit arches, an skb frag is limited to 2^15 */
2190 #define SKB_FRAG_PAGE_ORDER     get_order(32768)
2191
2192 /**
2193  * skb_page_frag_refill - check that a page_frag contains enough room
2194  * @sz: minimum size of the fragment we want to get
2195  * @pfrag: pointer to page_frag
2196  * @gfp: priority for memory allocation
2197  *
2198  * Note: While this allocator tries to use high order pages, there is
2199  * no guarantee that allocations succeed. Therefore, @sz MUST be
2200  * less or equal than PAGE_SIZE.
2201  */
2202 bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
2203 {
2204         if (pfrag->page) {
2205                 if (page_ref_count(pfrag->page) == 1) {
2206                         pfrag->offset = 0;
2207                         return true;
2208                 }
2209                 if (pfrag->offset + sz <= pfrag->size)
2210                         return true;
2211                 put_page(pfrag->page);
2212         }
2213
2214         pfrag->offset = 0;
2215         if (SKB_FRAG_PAGE_ORDER) {
2216                 /* Avoid direct reclaim but allow kswapd to wake */
2217                 pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) |
2218                                           __GFP_COMP | __GFP_NOWARN |
2219                                           __GFP_NORETRY,
2220                                           SKB_FRAG_PAGE_ORDER);
2221                 if (likely(pfrag->page)) {
2222                         pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
2223                         return true;
2224                 }
2225         }
2226         pfrag->page = alloc_page(gfp);
2227         if (likely(pfrag->page)) {
2228                 pfrag->size = PAGE_SIZE;
2229                 return true;
2230         }
2231         return false;
2232 }
2233 EXPORT_SYMBOL(skb_page_frag_refill);
2234
2235 bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
2236 {
2237         if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
2238                 return true;
2239
2240         sk_enter_memory_pressure(sk);
2241         sk_stream_moderate_sndbuf(sk);
2242         return false;
2243 }
2244 EXPORT_SYMBOL(sk_page_frag_refill);
2245
2246 static void __lock_sock(struct sock *sk)
2247         __releases(&sk->sk_lock.slock)
2248         __acquires(&sk->sk_lock.slock)
2249 {
2250         DEFINE_WAIT(wait);
2251
2252         for (;;) {
2253                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
2254                                         TASK_UNINTERRUPTIBLE);
2255                 spin_unlock_bh(&sk->sk_lock.slock);
2256                 schedule();
2257                 spin_lock_bh(&sk->sk_lock.slock);
2258                 if (!sock_owned_by_user(sk))
2259                         break;
2260         }
2261         finish_wait(&sk->sk_lock.wq, &wait);
2262 }
2263
2264 void __release_sock(struct sock *sk)
2265         __releases(&sk->sk_lock.slock)
2266         __acquires(&sk->sk_lock.slock)
2267 {
2268         struct sk_buff *skb, *next;
2269
2270         while ((skb = sk->sk_backlog.head) != NULL) {
2271                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
2272
2273                 spin_unlock_bh(&sk->sk_lock.slock);
2274
2275                 do {
2276                         next = skb->next;
2277                         prefetch(next);
2278                         WARN_ON_ONCE(skb_dst_is_noref(skb));
2279                         skb_mark_not_on_list(skb);
2280                         sk_backlog_rcv(sk, skb);
2281
2282                         cond_resched();
2283
2284                         skb = next;
2285                 } while (skb != NULL);
2286
2287                 spin_lock_bh(&sk->sk_lock.slock);
2288         }
2289
2290         /*
2291          * Doing the zeroing here guarantee we can not loop forever
2292          * while a wild producer attempts to flood us.
2293          */
2294         sk->sk_backlog.len = 0;
2295 }
2296
2297 void __sk_flush_backlog(struct sock *sk)
2298 {
2299         spin_lock_bh(&sk->sk_lock.slock);
2300         __release_sock(sk);
2301         spin_unlock_bh(&sk->sk_lock.slock);
2302 }
2303
2304 /**
2305  * sk_wait_data - wait for data to arrive at sk_receive_queue
2306  * @sk:    sock to wait on
2307  * @timeo: for how long
2308  * @skb:   last skb seen on sk_receive_queue
2309  *
2310  * Now socket state including sk->sk_err is changed only under lock,
2311  * hence we may omit checks after joining wait queue.
2312  * We check receive queue before schedule() only as optimization;
2313  * it is very likely that release_sock() added new data.
2314  */
2315 int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
2316 {
2317         DEFINE_WAIT_FUNC(wait, woken_wake_function);
2318         int rc;
2319
2320         add_wait_queue(sk_sleep(sk), &wait);
2321         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2322         rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
2323         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2324         remove_wait_queue(sk_sleep(sk), &wait);
2325         return rc;
2326 }
2327 EXPORT_SYMBOL(sk_wait_data);
2328
2329 /**
2330  *      __sk_mem_raise_allocated - increase memory_allocated
2331  *      @sk: socket
2332  *      @size: memory size to allocate
2333  *      @amt: pages to allocate
2334  *      @kind: allocation type
2335  *
2336  *      Similar to __sk_mem_schedule(), but does not update sk_forward_alloc
2337  */
2338 int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
2339 {
2340         struct proto *prot = sk->sk_prot;
2341         long allocated = sk_memory_allocated_add(sk, amt);
2342         bool charged = true;
2343
2344         if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
2345             !(charged = mem_cgroup_charge_skmem(sk->sk_memcg, amt)))
2346                 goto suppress_allocation;
2347
2348         /* Under limit. */
2349         if (allocated <= sk_prot_mem_limits(sk, 0)) {
2350                 sk_leave_memory_pressure(sk);
2351                 return 1;
2352         }
2353
2354         /* Under pressure. */
2355         if (allocated > sk_prot_mem_limits(sk, 1))
2356                 sk_enter_memory_pressure(sk);
2357
2358         /* Over hard limit. */
2359         if (allocated > sk_prot_mem_limits(sk, 2))
2360                 goto suppress_allocation;
2361
2362         /* guarantee minimum buffer size under pressure */
2363         if (kind == SK_MEM_RECV) {
2364                 if (atomic_read(&sk->sk_rmem_alloc) < sk_get_rmem0(sk, prot))
2365                         return 1;
2366
2367         } else { /* SK_MEM_SEND */
2368                 int wmem0 = sk_get_wmem0(sk, prot);
2369
2370                 if (sk->sk_type == SOCK_STREAM) {
2371                         if (sk->sk_wmem_queued < wmem0)
2372                                 return 1;
2373                 } else if (refcount_read(&sk->sk_wmem_alloc) < wmem0) {
2374                                 return 1;
2375                 }
2376         }
2377
2378         if (sk_has_memory_pressure(sk)) {
2379                 int alloc;
2380
2381                 if (!sk_under_memory_pressure(sk))
2382                         return 1;
2383                 alloc = sk_sockets_allocated_read_positive(sk);
2384                 if (sk_prot_mem_limits(sk, 2) > alloc *
2385                     sk_mem_pages(sk->sk_wmem_queued +
2386                                  atomic_read(&sk->sk_rmem_alloc) +
2387                                  sk->sk_forward_alloc))
2388                         return 1;
2389         }
2390
2391 suppress_allocation:
2392
2393         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
2394                 sk_stream_moderate_sndbuf(sk);
2395
2396                 /* Fail only if socket is _under_ its sndbuf.
2397                  * In this case we cannot block, so that we have to fail.
2398                  */
2399                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
2400                         return 1;
2401         }
2402
2403         if (kind == SK_MEM_SEND || (kind == SK_MEM_RECV && charged))
2404                 trace_sock_exceed_buf_limit(sk, prot, allocated, kind);
2405
2406         sk_memory_allocated_sub(sk, amt);
2407
2408         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
2409                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amt);
2410
2411         return 0;
2412 }
2413 EXPORT_SYMBOL(__sk_mem_raise_allocated);
2414
2415 /**
2416  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
2417  *      @sk: socket
2418  *      @size: memory size to allocate
2419  *      @kind: allocation type
2420  *
2421  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
2422  *      rmem allocation. This function assumes that protocols which have
2423  *      memory_pressure use sk_wmem_queued as write buffer accounting.
2424  */
2425 int __sk_mem_schedule(struct sock *sk, int size, int kind)
2426 {
2427         int ret, amt = sk_mem_pages(size);
2428
2429         sk->sk_forward_alloc += amt << SK_MEM_QUANTUM_SHIFT;
2430         ret = __sk_mem_raise_allocated(sk, size, amt, kind);
2431         if (!ret)
2432                 sk->sk_forward_alloc -= amt << SK_MEM_QUANTUM_SHIFT;
2433         return ret;
2434 }
2435 EXPORT_SYMBOL(__sk_mem_schedule);
2436
2437 /**
2438  *      __sk_mem_reduce_allocated - reclaim memory_allocated
2439  *      @sk: socket
2440  *      @amount: number of quanta
2441  *
2442  *      Similar to __sk_mem_reclaim(), but does not update sk_forward_alloc
2443  */
2444 void __sk_mem_reduce_allocated(struct sock *sk, int amount)
2445 {
2446         sk_memory_allocated_sub(sk, amount);
2447
2448         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
2449                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amount);
2450
2451         if (sk_under_memory_pressure(sk) &&
2452             (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
2453                 sk_leave_memory_pressure(sk);
2454 }
2455 EXPORT_SYMBOL(__sk_mem_reduce_allocated);
2456
2457 /**
2458  *      __sk_mem_reclaim - reclaim sk_forward_alloc and memory_allocated
2459  *      @sk: socket
2460  *      @amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)
2461  */
2462 void __sk_mem_reclaim(struct sock *sk, int amount)
2463 {
2464         amount >>= SK_MEM_QUANTUM_SHIFT;
2465         sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
2466         __sk_mem_reduce_allocated(sk, amount);
2467 }
2468 EXPORT_SYMBOL(__sk_mem_reclaim);
2469
2470 int sk_set_peek_off(struct sock *sk, int val)
2471 {
2472         sk->sk_peek_off = val;
2473         return 0;
2474 }
2475 EXPORT_SYMBOL_GPL(sk_set_peek_off);
2476
2477 /*
2478  * Set of default routines for initialising struct proto_ops when
2479  * the protocol does not support a particular function. In certain
2480  * cases where it makes no sense for a protocol to have a "do nothing"
2481  * function, some default processing is provided.
2482  */
2483
2484 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
2485 {
2486         return -EOPNOTSUPP;
2487 }
2488 EXPORT_SYMBOL(sock_no_bind);
2489
2490 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
2491                     int len, int flags)
2492 {
2493         return -EOPNOTSUPP;
2494 }
2495 EXPORT_SYMBOL(sock_no_connect);
2496
2497 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
2498 {
2499         return -EOPNOTSUPP;
2500 }
2501 EXPORT_SYMBOL(sock_no_socketpair);
2502
2503 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags,
2504                    bool kern)
2505 {
2506         return -EOPNOTSUPP;
2507 }
2508 EXPORT_SYMBOL(sock_no_accept);
2509
2510 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
2511                     int peer)
2512 {
2513         return -EOPNOTSUPP;
2514 }
2515 EXPORT_SYMBOL(sock_no_getname);
2516
2517 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2518 {
2519         return -EOPNOTSUPP;
2520 }
2521 EXPORT_SYMBOL(sock_no_ioctl);
2522
2523 int sock_no_listen(struct socket *sock, int backlog)
2524 {
2525         return -EOPNOTSUPP;
2526 }
2527 EXPORT_SYMBOL(sock_no_listen);
2528
2529 int sock_no_shutdown(struct socket *sock, int how)
2530 {
2531         return -EOPNOTSUPP;
2532 }
2533 EXPORT_SYMBOL(sock_no_shutdown);
2534
2535 int sock_no_setsockopt(struct socket *sock, int level, int optname,
2536                     char __user *optval, unsigned int optlen)
2537 {
2538         return -EOPNOTSUPP;
2539 }
2540 EXPORT_SYMBOL(sock_no_setsockopt);
2541
2542 int sock_no_getsockopt(struct socket *sock, int level, int optname,
2543                     char __user *optval, int __user *optlen)
2544 {
2545         return -EOPNOTSUPP;
2546 }
2547 EXPORT_SYMBOL(sock_no_getsockopt);
2548
2549 int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
2550 {
2551         return -EOPNOTSUPP;
2552 }
2553 EXPORT_SYMBOL(sock_no_sendmsg);
2554
2555 int sock_no_sendmsg_locked(struct sock *sk, struct msghdr *m, size_t len)
2556 {
2557         return -EOPNOTSUPP;
2558 }
2559 EXPORT_SYMBOL(sock_no_sendmsg_locked);
2560
2561 int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
2562                     int flags)
2563 {
2564         return -EOPNOTSUPP;
2565 }
2566 EXPORT_SYMBOL(sock_no_recvmsg);
2567
2568 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
2569 {
2570         /* Mirror missing mmap method error code */
2571         return -ENODEV;
2572 }
2573 EXPORT_SYMBOL(sock_no_mmap);
2574
2575 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
2576 {
2577         ssize_t res;
2578         struct msghdr msg = {.msg_flags = flags};
2579         struct kvec iov;
2580         char *kaddr = kmap(page);
2581         iov.iov_base = kaddr + offset;
2582         iov.iov_len = size;
2583         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
2584         kunmap(page);
2585         return res;
2586 }
2587 EXPORT_SYMBOL(sock_no_sendpage);
2588
2589 ssize_t sock_no_sendpage_locked(struct sock *sk, struct page *page,
2590                                 int offset, size_t size, int flags)
2591 {
2592         ssize_t res;
2593         struct msghdr msg = {.msg_flags = flags};
2594         struct kvec iov;
2595         char *kaddr = kmap(page);
2596
2597         iov.iov_base = kaddr + offset;
2598         iov.iov_len = size;
2599         res = kernel_sendmsg_locked(sk, &msg, &iov, 1, size);
2600         kunmap(page);
2601         return res;
2602 }
2603 EXPORT_SYMBOL(sock_no_sendpage_locked);
2604
2605 /*
2606  *      Default Socket Callbacks
2607  */
2608
2609 static void sock_def_wakeup(struct sock *sk)
2610 {
2611         struct socket_wq *wq;
2612
2613         rcu_read_lock();
2614         wq = rcu_dereference(sk->sk_wq);
2615         if (skwq_has_sleeper(wq))
2616                 wake_up_interruptible_all(&wq->wait);
2617         rcu_read_unlock();
2618 }
2619
2620 static void sock_def_error_report(struct sock *sk)
2621 {
2622         struct socket_wq *wq;
2623
2624         rcu_read_lock();
2625         wq = rcu_dereference(sk->sk_wq);
2626         if (skwq_has_sleeper(wq))
2627                 wake_up_interruptible_poll(&wq->wait, EPOLLERR);
2628         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
2629         rcu_read_unlock();
2630 }
2631
2632 static void sock_def_readable(struct sock *sk)
2633 {
2634         struct socket_wq *wq;
2635
2636         rcu_read_lock();
2637         wq = rcu_dereference(sk->sk_wq);
2638         if (skwq_has_sleeper(wq))
2639                 wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
2640                                                 EPOLLRDNORM | EPOLLRDBAND);
2641         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
2642         rcu_read_unlock();
2643 }
2644
2645 static void sock_def_write_space(struct sock *sk)
2646 {
2647         struct socket_wq *wq;
2648
2649         rcu_read_lock();
2650
2651         /* Do not wake up a writer until he can make "significant"
2652          * progress.  --DaveM
2653          */
2654         if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
2655                 wq = rcu_dereference(sk->sk_wq);
2656                 if (skwq_has_sleeper(wq))
2657                         wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
2658                                                 EPOLLWRNORM | EPOLLWRBAND);
2659
2660                 /* Should agree with poll, otherwise some programs break */
2661                 if (sock_writeable(sk))
2662                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
2663         }
2664
2665         rcu_read_unlock();
2666 }
2667
2668 static void sock_def_destruct(struct sock *sk)
2669 {
2670 }
2671
2672 void sk_send_sigurg(struct sock *sk)
2673 {
2674         if (sk->sk_socket && sk->sk_socket->file)
2675                 if (send_sigurg(&sk->sk_socket->file->f_owner))
2676                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
2677 }
2678 EXPORT_SYMBOL(sk_send_sigurg);
2679
2680 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
2681                     unsigned long expires)
2682 {
2683         if (!mod_timer(timer, expires))
2684                 sock_hold(sk);
2685 }
2686 EXPORT_SYMBOL(sk_reset_timer);
2687
2688 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
2689 {
2690         if (del_timer(timer))
2691                 __sock_put(sk);
2692 }
2693 EXPORT_SYMBOL(sk_stop_timer);
2694
2695 void sock_init_data(struct socket *sock, struct sock *sk)
2696 {
2697         sk_init_common(sk);
2698         sk->sk_send_head        =       NULL;
2699
2700         timer_setup(&sk->sk_timer, NULL, 0);
2701
2702         sk->sk_allocation       =       GFP_KERNEL;
2703         sk->sk_rcvbuf           =       sysctl_rmem_default;
2704         sk->sk_sndbuf           =       sysctl_wmem_default;
2705         sk->sk_state            =       TCP_CLOSE;
2706         sk_set_socket(sk, sock);
2707
2708         sock_set_flag(sk, SOCK_ZAPPED);
2709
2710         if (sock) {
2711                 sk->sk_type     =       sock->type;
2712                 sk->sk_wq       =       sock->wq;
2713                 sock->sk        =       sk;
2714                 sk->sk_uid      =       SOCK_INODE(sock)->i_uid;
2715         } else {
2716                 sk->sk_wq       =       NULL;
2717                 sk->sk_uid      =       make_kuid(sock_net(sk)->user_ns, 0);
2718         }
2719
2720         rwlock_init(&sk->sk_callback_lock);
2721         if (sk->sk_kern_sock)
2722                 lockdep_set_class_and_name(
2723                         &sk->sk_callback_lock,
2724                         af_kern_callback_keys + sk->sk_family,
2725                         af_family_kern_clock_key_strings[sk->sk_family]);
2726         else
2727                 lockdep_set_class_and_name(
2728                         &sk->sk_callback_lock,
2729                         af_callback_keys + sk->sk_family,
2730                         af_family_clock_key_strings[sk->sk_family]);
2731
2732         sk->sk_state_change     =       sock_def_wakeup;
2733         sk->sk_data_ready       =       sock_def_readable;
2734         sk->sk_write_space      =       sock_def_write_space;
2735         sk->sk_error_report     =       sock_def_error_report;
2736         sk->sk_destruct         =       sock_def_destruct;
2737
2738         sk->sk_frag.page        =       NULL;
2739         sk->sk_frag.offset      =       0;
2740         sk->sk_peek_off         =       -1;
2741
2742         sk->sk_peer_pid         =       NULL;
2743         sk->sk_peer_cred        =       NULL;
2744         sk->sk_write_pending    =       0;
2745         sk->sk_rcvlowat         =       1;
2746         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
2747         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
2748
2749         sk->sk_stamp = SK_DEFAULT_STAMP;
2750         atomic_set(&sk->sk_zckey, 0);
2751
2752 #ifdef CONFIG_NET_RX_BUSY_POLL
2753         sk->sk_napi_id          =       0;
2754         sk->sk_ll_usec          =       sysctl_net_busy_read;
2755 #endif
2756
2757         sk->sk_max_pacing_rate = ~0UL;
2758         sk->sk_pacing_rate = ~0UL;
2759         sk->sk_pacing_shift = 10;
2760         sk->sk_incoming_cpu = -1;
2761
2762         sk_rx_queue_clear(sk);
2763         /*
2764          * Before updating sk_refcnt, we must commit prior changes to memory
2765          * (Documentation/RCU/rculist_nulls.txt for details)
2766          */
2767         smp_wmb();
2768         refcount_set(&sk->sk_refcnt, 1);
2769         atomic_set(&sk->sk_drops, 0);
2770 }
2771 EXPORT_SYMBOL(sock_init_data);
2772
2773 void lock_sock_nested(struct sock *sk, int subclass)
2774 {
2775         might_sleep();
2776         spin_lock_bh(&sk->sk_lock.slock);
2777         if (sk->sk_lock.owned)
2778                 __lock_sock(sk);
2779         sk->sk_lock.owned = 1;
2780         spin_unlock(&sk->sk_lock.slock);
2781         /*
2782          * The sk_lock has mutex_lock() semantics here:
2783          */
2784         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
2785         local_bh_enable();
2786 }
2787 EXPORT_SYMBOL(lock_sock_nested);
2788
2789 void release_sock(struct sock *sk)
2790 {
2791         spin_lock_bh(&sk->sk_lock.slock);
2792         if (sk->sk_backlog.tail)
2793                 __release_sock(sk);
2794
2795         /* Warning : release_cb() might need to release sk ownership,
2796          * ie call sock_release_ownership(sk) before us.
2797          */
2798         if (sk->sk_prot->release_cb)
2799                 sk->sk_prot->release_cb(sk);
2800
2801         sock_release_ownership(sk);
2802         if (waitqueue_active(&sk->sk_lock.wq))
2803                 wake_up(&sk->sk_lock.wq);
2804         spin_unlock_bh(&sk->sk_lock.slock);
2805 }
2806 EXPORT_SYMBOL(release_sock);
2807
2808 /**
2809  * lock_sock_fast - fast version of lock_sock
2810  * @sk: socket
2811  *
2812  * This version should be used for very small section, where process wont block
2813  * return false if fast path is taken:
2814  *
2815  *   sk_lock.slock locked, owned = 0, BH disabled
2816  *
2817  * return true if slow path is taken:
2818  *
2819  *   sk_lock.slock unlocked, owned = 1, BH enabled
2820  */
2821 bool lock_sock_fast(struct sock *sk)
2822 {
2823         might_sleep();
2824         spin_lock_bh(&sk->sk_lock.slock);
2825
2826         if (!sk->sk_lock.owned)
2827                 /*
2828                  * Note : We must disable BH
2829                  */
2830                 return false;
2831
2832         __lock_sock(sk);
2833         sk->sk_lock.owned = 1;
2834         spin_unlock(&sk->sk_lock.slock);
2835         /*
2836          * The sk_lock has mutex_lock() semantics here:
2837          */
2838         mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
2839         local_bh_enable();
2840         return true;
2841 }
2842 EXPORT_SYMBOL(lock_sock_fast);
2843
2844 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
2845 {
2846         struct timeval tv;
2847
2848         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2849         tv = ktime_to_timeval(sk->sk_stamp);
2850         if (tv.tv_sec == -1)
2851                 return -ENOENT;
2852         if (tv.tv_sec == 0) {
2853                 sk->sk_stamp = ktime_get_real();
2854                 tv = ktime_to_timeval(sk->sk_stamp);
2855         }
2856         return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
2857 }
2858 EXPORT_SYMBOL(sock_get_timestamp);
2859
2860 int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2861 {
2862         struct timespec ts;
2863
2864         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2865         ts = ktime_to_timespec(sk->sk_stamp);
2866         if (ts.tv_sec == -1)
2867                 return -ENOENT;
2868         if (ts.tv_sec == 0) {
2869                 sk->sk_stamp = ktime_get_real();
2870                 ts = ktime_to_timespec(sk->sk_stamp);
2871         }
2872         return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2873 }
2874 EXPORT_SYMBOL(sock_get_timestampns);
2875
2876 void sock_enable_timestamp(struct sock *sk, int flag)
2877 {
2878         if (!sock_flag(sk, flag)) {
2879                 unsigned long previous_flags = sk->sk_flags;
2880
2881                 sock_set_flag(sk, flag);
2882                 /*
2883                  * we just set one of the two flags which require net
2884                  * time stamping, but time stamping might have been on
2885                  * already because of the other one
2886                  */
2887                 if (sock_needs_netstamp(sk) &&
2888                     !(previous_flags & SK_FLAGS_TIMESTAMP))
2889                         net_enable_timestamp();
2890         }
2891 }
2892
2893 int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
2894                        int level, int type)
2895 {
2896         struct sock_exterr_skb *serr;
2897         struct sk_buff *skb;
2898         int copied, err;
2899
2900         err = -EAGAIN;
2901         skb = sock_dequeue_err_skb(sk);
2902         if (skb == NULL)
2903                 goto out;
2904
2905         copied = skb->len;
2906         if (copied > len) {
2907                 msg->msg_flags |= MSG_TRUNC;
2908                 copied = len;
2909         }
2910         err = skb_copy_datagram_msg(skb, 0, msg, copied);
2911         if (err)
2912                 goto out_free_skb;
2913
2914         sock_recv_timestamp(msg, sk, skb);
2915
2916         serr = SKB_EXT_ERR(skb);
2917         put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
2918
2919         msg->msg_flags |= MSG_ERRQUEUE;
2920         err = copied;
2921
2922 out_free_skb:
2923         kfree_skb(skb);
2924 out:
2925         return err;
2926 }
2927 EXPORT_SYMBOL(sock_recv_errqueue);
2928
2929 /*
2930  *      Get a socket option on an socket.
2931  *
2932  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
2933  *      asynchronous errors should be reported by getsockopt. We assume
2934  *      this means if you specify SO_ERROR (otherwise whats the point of it).
2935  */
2936 int sock_common_getsockopt(struct socket *sock, int level, int optname,
2937                            char __user *optval, int __user *optlen)
2938 {
2939         struct sock *sk = sock->sk;
2940
2941         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2942 }
2943 EXPORT_SYMBOL(sock_common_getsockopt);
2944
2945 #ifdef CONFIG_COMPAT
2946 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
2947                                   char __user *optval, int __user *optlen)
2948 {
2949         struct sock *sk = sock->sk;
2950
2951         if (sk->sk_prot->compat_getsockopt != NULL)
2952                 return sk->sk_prot->compat_getsockopt(sk, level, optname,
2953                                                       optval, optlen);
2954         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2955 }
2956 EXPORT_SYMBOL(compat_sock_common_getsockopt);
2957 #endif
2958
2959 int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
2960                         int flags)
2961 {
2962         struct sock *sk = sock->sk;
2963         int addr_len = 0;
2964         int err;
2965
2966         err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
2967                                    flags & ~MSG_DONTWAIT, &addr_len);
2968         if (err >= 0)
2969                 msg->msg_namelen = addr_len;
2970         return err;
2971 }
2972 EXPORT_SYMBOL(sock_common_recvmsg);
2973
2974 /*
2975  *      Set socket options on an inet socket.
2976  */
2977 int sock_common_setsockopt(struct socket *sock, int level, int optname,
2978                            char __user *optval, unsigned int optlen)
2979 {
2980         struct sock *sk = sock->sk;
2981
2982         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2983 }
2984 EXPORT_SYMBOL(sock_common_setsockopt);
2985
2986 #ifdef CONFIG_COMPAT
2987 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
2988                                   char __user *optval, unsigned int optlen)
2989 {
2990         struct sock *sk = sock->sk;
2991
2992         if (sk->sk_prot->compat_setsockopt != NULL)
2993                 return sk->sk_prot->compat_setsockopt(sk, level, optname,
2994                                                       optval, optlen);
2995         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2996 }
2997 EXPORT_SYMBOL(compat_sock_common_setsockopt);
2998 #endif
2999
3000 void sk_common_release(struct sock *sk)
3001 {
3002         if (sk->sk_prot->destroy)
3003                 sk->sk_prot->destroy(sk);
3004
3005         /*
3006          * Observation: when sock_common_release is called, processes have
3007          * no access to socket. But net still has.
3008          * Step one, detach it from networking:
3009          *
3010          * A. Remove from hash tables.
3011          */
3012
3013         sk->sk_prot->unhash(sk);
3014
3015         /*
3016          * In this point socket cannot receive new packets, but it is possible
3017          * that some packets are in flight because some CPU runs receiver and
3018          * did hash table lookup before we unhashed socket. They will achieve
3019          * receive queue and will be purged by socket destructor.
3020          *
3021          * Also we still have packets pending on receive queue and probably,
3022          * our own packets waiting in device queues. sock_destroy will drain
3023          * receive queue, but transmitted packets will delay socket destruction
3024          * until the last reference will be released.
3025          */
3026
3027         sock_orphan(sk);
3028
3029         xfrm_sk_free_policy(sk);
3030
3031         sk_refcnt_debug_release(sk);
3032
3033         sock_put(sk);
3034 }
3035 EXPORT_SYMBOL(sk_common_release);
3036
3037 void sk_get_meminfo(const struct sock *sk, u32 *mem)
3038 {
3039         memset(mem, 0, sizeof(*mem) * SK_MEMINFO_VARS);
3040
3041         mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk);
3042         mem[SK_MEMINFO_RCVBUF] = sk->sk_rcvbuf;
3043         mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk);
3044         mem[SK_MEMINFO_SNDBUF] = sk->sk_sndbuf;
3045         mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc;
3046         mem[SK_MEMINFO_WMEM_QUEUED] = sk->sk_wmem_queued;
3047         mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc);
3048         mem[SK_MEMINFO_BACKLOG] = sk->sk_backlog.len;
3049         mem[SK_MEMINFO_DROPS] = atomic_read(&sk->sk_drops);
3050 }
3051
3052 #ifdef CONFIG_PROC_FS
3053 #define PROTO_INUSE_NR  64      /* should be enough for the first time */
3054 struct prot_inuse {
3055         int val[PROTO_INUSE_NR];
3056 };
3057
3058 static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
3059
3060 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
3061 {
3062         __this_cpu_add(net->core.prot_inuse->val[prot->inuse_idx], val);
3063 }
3064 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
3065
3066 int sock_prot_inuse_get(struct net *net, struct proto *prot)
3067 {
3068         int cpu, idx = prot->inuse_idx;
3069         int res = 0;
3070
3071         for_each_possible_cpu(cpu)
3072                 res += per_cpu_ptr(net->core.prot_inuse, cpu)->val[idx];
3073
3074         return res >= 0 ? res : 0;
3075 }
3076 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
3077
3078 static void sock_inuse_add(struct net *net, int val)
3079 {
3080         this_cpu_add(*net->core.sock_inuse, val);
3081 }
3082
3083 int sock_inuse_get(struct net *net)
3084 {
3085         int cpu, res = 0;
3086
3087         for_each_possible_cpu(cpu)
3088                 res += *per_cpu_ptr(net->core.sock_inuse, cpu);
3089
3090         return res;
3091 }
3092
3093 EXPORT_SYMBOL_GPL(sock_inuse_get);
3094
3095 static int __net_init sock_inuse_init_net(struct net *net)
3096 {
3097         net->core.prot_inuse = alloc_percpu(struct prot_inuse);
3098         if (net->core.prot_inuse == NULL)
3099                 return -ENOMEM;
3100
3101         net->core.sock_inuse = alloc_percpu(int);
3102         if (net->core.sock_inuse == NULL)
3103                 goto out;
3104
3105         return 0;
3106
3107 out:
3108         free_percpu(net->core.prot_inuse);
3109         return -ENOMEM;
3110 }
3111
3112 static void __net_exit sock_inuse_exit_net(struct net *net)
3113 {
3114         free_percpu(net->core.prot_inuse);
3115         free_percpu(net->core.sock_inuse);
3116 }
3117
3118 static struct pernet_operations net_inuse_ops = {
3119         .init = sock_inuse_init_net,
3120         .exit = sock_inuse_exit_net,
3121 };
3122
3123 static __init int net_inuse_init(void)
3124 {
3125         if (register_pernet_subsys(&net_inuse_ops))
3126                 panic("Cannot initialize net inuse counters");
3127
3128         return 0;
3129 }
3130
3131 core_initcall(net_inuse_init);
3132
3133 static void assign_proto_idx(struct proto *prot)
3134 {
3135         prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
3136
3137         if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
3138                 pr_err("PROTO_INUSE_NR exhausted\n");
3139                 return;
3140         }
3141
3142         set_bit(prot->inuse_idx, proto_inuse_idx);
3143 }
3144
3145 static void release_proto_idx(struct proto *prot)
3146 {
3147         if (prot->inuse_idx != PROTO_INUSE_NR - 1)
3148                 clear_bit(prot->inuse_idx, proto_inuse_idx);
3149 }
3150 #else
3151 static inline void assign_proto_idx(struct proto *prot)
3152 {
3153 }
3154
3155 static inline void release_proto_idx(struct proto *prot)
3156 {
3157 }
3158
3159 static void sock_inuse_add(struct net *net, int val)
3160 {
3161 }
3162 #endif
3163
3164 static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
3165 {
3166         if (!rsk_prot)
3167                 return;
3168         kfree(rsk_prot->slab_name);
3169         rsk_prot->slab_name = NULL;
3170         kmem_cache_destroy(rsk_prot->slab);
3171         rsk_prot->slab = NULL;
3172 }
3173
3174 static int req_prot_init(const struct proto *prot)
3175 {
3176         struct request_sock_ops *rsk_prot = prot->rsk_prot;
3177
3178         if (!rsk_prot)
3179                 return 0;
3180
3181         rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
3182                                         prot->name);
3183         if (!rsk_prot->slab_name)
3184                 return -ENOMEM;
3185
3186         rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
3187                                            rsk_prot->obj_size, 0,
3188                                            SLAB_ACCOUNT | prot->slab_flags,
3189                                            NULL);
3190
3191         if (!rsk_prot->slab) {
3192                 pr_crit("%s: Can't create request sock SLAB cache!\n",
3193                         prot->name);
3194                 return -ENOMEM;
3195         }
3196         return 0;
3197 }
3198
3199 int proto_register(struct proto *prot, int alloc_slab)
3200 {
3201         if (alloc_slab) {
3202                 prot->slab = kmem_cache_create_usercopy(prot->name,
3203                                         prot->obj_size, 0,
3204                                         SLAB_HWCACHE_ALIGN | SLAB_ACCOUNT |
3205                                         prot->slab_flags,
3206                                         prot->useroffset, prot->usersize,
3207                                         NULL);
3208
3209                 if (prot->slab == NULL) {
3210                         pr_crit("%s: Can't create sock SLAB cache!\n",
3211                                 prot->name);
3212                         goto out;
3213                 }
3214
3215                 if (req_prot_init(prot))
3216                         goto out_free_request_sock_slab;
3217
3218                 if (prot->twsk_prot != NULL) {
3219                         prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
3220
3221                         if (prot->twsk_prot->twsk_slab_name == NULL)
3222                                 goto out_free_request_sock_slab;
3223
3224                         prot->twsk_prot->twsk_slab =
3225                                 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
3226                                                   prot->twsk_prot->twsk_obj_size,
3227                                                   0,
3228                                                   SLAB_ACCOUNT |
3229                                                   prot->slab_flags,
3230                                                   NULL);
3231                         if (prot->twsk_prot->twsk_slab == NULL)
3232                                 goto out_free_timewait_sock_slab_name;
3233                 }
3234         }
3235
3236         mutex_lock(&proto_list_mutex);
3237         list_add(&prot->node, &proto_list);
3238         assign_proto_idx(prot);
3239         mutex_unlock(&proto_list_mutex);
3240         return 0;
3241
3242 out_free_timewait_sock_slab_name:
3243         kfree(prot->twsk_prot->twsk_slab_name);
3244 out_free_request_sock_slab:
3245         req_prot_cleanup(prot->rsk_prot);
3246
3247         kmem_cache_destroy(prot->slab);
3248         prot->slab = NULL;
3249 out:
3250         return -ENOBUFS;
3251 }
3252 EXPORT_SYMBOL(proto_register);
3253
3254 void proto_unregister(struct proto *prot)
3255 {
3256         mutex_lock(&proto_list_mutex);
3257         release_proto_idx(prot);
3258         list_del(&prot->node);
3259         mutex_unlock(&proto_list_mutex);
3260
3261         kmem_cache_destroy(prot->slab);
3262         prot->slab = NULL;
3263
3264         req_prot_cleanup(prot->rsk_prot);
3265
3266         if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
3267                 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
3268                 kfree(prot->twsk_prot->twsk_slab_name);
3269                 prot->twsk_prot->twsk_slab = NULL;
3270         }
3271 }
3272 EXPORT_SYMBOL(proto_unregister);
3273
3274 int sock_load_diag_module(int family, int protocol)
3275 {
3276         if (!protocol) {
3277                 if (!sock_is_registered(family))
3278                         return -ENOENT;
3279
3280                 return request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
3281                                       NETLINK_SOCK_DIAG, family);
3282         }
3283
3284 #ifdef CONFIG_INET
3285         if (family == AF_INET &&
3286             protocol != IPPROTO_RAW &&
3287             !rcu_access_pointer(inet_protos[protocol]))
3288                 return -ENOENT;
3289 #endif
3290
3291         return request_module("net-pf-%d-proto-%d-type-%d-%d", PF_NETLINK,
3292                               NETLINK_SOCK_DIAG, family, protocol);
3293 }
3294 EXPORT_SYMBOL(sock_load_diag_module);
3295
3296 #ifdef CONFIG_PROC_FS
3297 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
3298         __acquires(proto_list_mutex)
3299 {
3300         mutex_lock(&proto_list_mutex);
3301         return seq_list_start_head(&proto_list, *pos);
3302 }
3303
3304 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3305 {
3306         return seq_list_next(v, &proto_list, pos);
3307 }
3308
3309 static void proto_seq_stop(struct seq_file *seq, void *v)
3310         __releases(proto_list_mutex)
3311 {
3312         mutex_unlock(&proto_list_mutex);
3313 }
3314
3315 static char proto_method_implemented(const void *method)
3316 {
3317         return method == NULL ? 'n' : 'y';
3318 }
3319 static long sock_prot_memory_allocated(struct proto *proto)
3320 {
3321         return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
3322 }
3323
3324 static char *sock_prot_memory_pressure(struct proto *proto)
3325 {
3326         return proto->memory_pressure != NULL ?
3327         proto_memory_pressure(proto) ? "yes" : "no" : "NI";
3328 }
3329
3330 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
3331 {
3332
3333         seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
3334                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
3335                    proto->name,
3336                    proto->obj_size,
3337                    sock_prot_inuse_get(seq_file_net(seq), proto),
3338                    sock_prot_memory_allocated(proto),
3339                    sock_prot_memory_pressure(proto),
3340                    proto->max_header,
3341                    proto->slab == NULL ? "no" : "yes",
3342                    module_name(proto->owner),
3343                    proto_method_implemented(proto->close),
3344                    proto_method_implemented(proto->connect),
3345                    proto_method_implemented(proto->disconnect),
3346                    proto_method_implemented(proto->accept),
3347                    proto_method_implemented(proto->ioctl),
3348                    proto_method_implemented(proto->init),
3349                    proto_method_implemented(proto->destroy),
3350                    proto_method_implemented(proto->shutdown),
3351                    proto_method_implemented(proto->setsockopt),
3352                    proto_method_implemented(proto->getsockopt),
3353                    proto_method_implemented(proto->sendmsg),
3354                    proto_method_implemented(proto->recvmsg),
3355                    proto_method_implemented(proto->sendpage),
3356                    proto_method_implemented(proto->bind),
3357                    proto_method_implemented(proto->backlog_rcv),
3358                    proto_method_implemented(proto->hash),
3359                    proto_method_implemented(proto->unhash),
3360                    proto_method_implemented(proto->get_port),
3361                    proto_method_implemented(proto->enter_memory_pressure));
3362 }
3363
3364 static int proto_seq_show(struct seq_file *seq, void *v)
3365 {
3366         if (v == &proto_list)
3367                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
3368                            "protocol",
3369                            "size",
3370                            "sockets",
3371                            "memory",
3372                            "press",
3373                            "maxhdr",
3374                            "slab",
3375                            "module",
3376                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
3377         else
3378                 proto_seq_printf(seq, list_entry(v, struct proto, node));
3379         return 0;
3380 }
3381
3382 static const struct seq_operations proto_seq_ops = {
3383         .start  = proto_seq_start,
3384         .next   = proto_seq_next,
3385         .stop   = proto_seq_stop,
3386         .show   = proto_seq_show,
3387 };
3388
3389 static __net_init int proto_init_net(struct net *net)
3390 {
3391         if (!proc_create_net("protocols", 0444, net->proc_net, &proto_seq_ops,
3392                         sizeof(struct seq_net_private)))
3393                 return -ENOMEM;
3394
3395         return 0;
3396 }
3397
3398 static __net_exit void proto_exit_net(struct net *net)
3399 {
3400         remove_proc_entry("protocols", net->proc_net);
3401 }
3402
3403
3404 static __net_initdata struct pernet_operations proto_net_ops = {
3405         .init = proto_init_net,
3406         .exit = proto_exit_net,
3407 };
3408
3409 static int __init proto_init(void)
3410 {
3411         return register_pernet_subsys(&proto_net_ops);
3412 }
3413
3414 subsys_initcall(proto_init);
3415
3416 #endif /* PROC_FS */
3417
3418 #ifdef CONFIG_NET_RX_BUSY_POLL
3419 bool sk_busy_loop_end(void *p, unsigned long start_time)
3420 {
3421         struct sock *sk = p;
3422
3423         return !skb_queue_empty(&sk->sk_receive_queue) ||
3424                sk_busy_loop_timeout(sk, start_time);
3425 }
3426 EXPORT_SYMBOL(sk_busy_loop_end);
3427 #endif /* CONFIG_NET_RX_BUSY_POLL */