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