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                 break;
 736         case SO_BROADCAST:
 737                 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
 738                 break;
 739         case SO_SNDBUF:
 740                 /* Don't error on this BSD doesn't and if you think
 741                  * about it this is right. Otherwise apps have to
 742                  * play 'guess the biggest size' games. RCVBUF/SNDBUF
 743                  * are treated in BSD as hints
 744                  */
 745                 val = min_t(u32, val, sysctl_wmem_max);
 746 set_sndbuf:
 747                 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 748                 sk->sk_sndbuf = max_t(u32, val * 2, SOCK_MIN_SNDBUF);
 749                 /* Wake up sending tasks if we upped the value. */
 750                 sk->sk_write_space(sk);
 751                 break;
 752
 753         case SO_SNDBUFFORCE:
 754                 if (!capable(CAP_NET_ADMIN)) {
 755                         ret = -EPERM;
 756                         break;
 757                 }
 758                 goto set_sndbuf;
 759
 760         case SO_RCVBUF:
 761                 /* Don't error on this BSD doesn't and if you think
 762                  * about it this is right. Otherwise apps have to
 763                  * play 'guess the biggest size' games. RCVBUF/SNDBUF
 764                  * are treated in BSD as hints
 765                  */
 766                 val = min_t(u32, val, sysctl_rmem_max);
 767 set_rcvbuf:
 768                 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 769                 /*
 770                  * We double it on the way in to account for
 771                  * "struct sk_buff" etc. overhead.   Applications
 772                  * assume that the SO_RCVBUF setting they make will
 773                  * allow that much actual data to be received on that
 774                  * socket.
 775                  *
 776                  * Applications are unaware that "struct sk_buff" and
 777                  * other overheads allocate from the receive buffer
 778                  * during socket buffer allocation.
 779                  *
 780                  * And after considering the possible alternatives,
 781                  * returning the value we actually used in getsockopt
 782                  * is the most desirable behavior.
 783                  */
 784                 sk->sk_rcvbuf = max_t(u32, val * 2, SOCK_MIN_RCVBUF);
 785                 break;
 786
 787         case SO_RCVBUFFORCE:
 788                 if (!capable(CAP_NET_ADMIN)) {
 789                         ret = -EPERM;
 790                         break;
 791                 }
 792                 goto set_rcvbuf;
 793
 794         case SO_KEEPALIVE:
 795 #ifdef CONFIG_INET
 796                 if (sk->sk_protocol == IPPROTO_TCP &&
 797                     sk->sk_type == SOCK_STREAM)
 798                         tcp_set_keepalive(sk, valbool);
 799 #endif
 800                 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
 801                 break;
 802
 803         case SO_OOBINLINE:
 804                 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
 805                 break;
 806
 807         case SO_NO_CHECK:
 808                 sk->sk_no_check_tx = valbool;
 809                 break;
 810
 811         case SO_PRIORITY:
 812                 if ((val >= 0 && val <= 6) ||
 813                     ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
 814                         sk->sk_priority = val;
 815                 else
 816                         ret = -EPERM;
 817                 break;
 818
 819         case SO_LINGER:
 820                 if (optlen < sizeof(ling)) {
 821                         ret = -EINVAL;  /* 1003.1g */
 822                         break;
 823                 }
 824                 if (copy_from_user(&ling, optval, sizeof(ling))) {
 825                         ret = -EFAULT;
 826                         break;
 827                 }
 828                 if (!ling.l_onoff)
 829                         sock_reset_flag(sk, SOCK_LINGER);
 830                 else {
 831 #if (BITS_PER_LONG == 32)
 832                         if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
 833                                 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
 834                         else
 835 #endif
 836                                 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
 837                         sock_set_flag(sk, SOCK_LINGER);
 838                 }
 839                 break;
 840
 841         case SO_BSDCOMPAT:
 842                 sock_warn_obsolete_bsdism("setsockopt");
 843                 break;
 844
 845         case SO_PASSCRED:
 846                 if (valbool)
 847                         set_bit(SOCK_PASSCRED, &sock->flags);
 848                 else
 849                         clear_bit(SOCK_PASSCRED, &sock->flags);
 850                 break;
 851
 852         case SO_TIMESTAMP:
 853         case SO_TIMESTAMPNS:
 854                 if (valbool)  {
 855                         if (optname == SO_TIMESTAMP)
 856                                 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 857                         else
 858                                 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
 859                         sock_set_flag(sk, SOCK_RCVTSTAMP);
 860                         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
 861                 } else {
 862                         sock_reset_flag(sk, SOCK_RCVTSTAMP);
 863                         sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 864                 }
 865                 break;
 866
 867         case SO_TIMESTAMPING:
 868                 if (val & ~SOF_TIMESTAMPING_MASK) {
 869                         ret = -EINVAL;
 870                         break;
 871                 }
 872
 873                 if (val & SOF_TIMESTAMPING_OPT_ID &&
 874                     !(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)) {
 875                         if (sk->sk_protocol == IPPROTO_TCP) {
 876                                 if (sk->sk_state != TCP_ESTABLISHED) {
 877                                         ret = -EINVAL;
 878                                         break;
 879                                 }
 880                                 sk->sk_tskey = tcp_sk(sk)->snd_una;
 881                         } else {
 882                                 sk->sk_tskey = 0;
 883                         }
 884                 }
 885                 sk->sk_tsflags = val;
 886                 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
 887                         sock_enable_timestamp(sk,
 888                                               SOCK_TIMESTAMPING_RX_SOFTWARE);
 889                 else
 890                         sock_disable_timestamp(sk,
 891                                                (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE));
 892                 break;
 893
 894         case SO_RCVLOWAT:
 895                 if (val < 0)
 896                         val = INT_MAX;
 897                 sk->sk_rcvlowat = val ? : 1;
 898                 break;
 899
 900         case SO_RCVTIMEO:
 901                 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
 902                 break;
 903
 904         case SO_SNDTIMEO:
 905                 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
 906                 break;
 907
 908         case SO_ATTACH_FILTER:
 909                 ret = -EINVAL;
 910                 if (optlen == sizeof(struct sock_fprog)) {
 911                         struct sock_fprog fprog;
 912
 913                         ret = -EFAULT;
 914                         if (copy_from_user(&fprog, optval, sizeof(fprog)))
 915                                 break;
 916
 917                         ret = sk_attach_filter(&fprog, sk);
 918                 }
 919                 break;
 920
 921         case SO_ATTACH_BPF:
 922                 ret = -EINVAL;
 923                 if (optlen == sizeof(u32)) {
 924                         u32 ufd;
 925
 926                         ret = -EFAULT;
 927                         if (copy_from_user(&ufd, optval, sizeof(ufd)))
 928                                 break;
 929
 930                         ret = sk_attach_bpf(ufd, sk);
 931                 }
 932                 break;
 933
 934         case SO_DETACH_FILTER:
 935                 ret = sk_detach_filter(sk);
 936                 break;
 937
 938         case SO_LOCK_FILTER:
 939                 if (sock_flag(sk, SOCK_FILTER_LOCKED) && !valbool)
 940                         ret = -EPERM;
 941                 else
 942                         sock_valbool_flag(sk, SOCK_FILTER_LOCKED, valbool);
 943                 break;
 944
 945         case SO_PASSSEC:
 946                 if (valbool)
 947                         set_bit(SOCK_PASSSEC, &sock->flags);
 948                 else
 949                         clear_bit(SOCK_PASSSEC, &sock->flags);
 950                 break;
 951         case SO_MARK:
 952                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
 953                         ret = -EPERM;
 954                 else
 955                         sk->sk_mark = val;
 956                 break;
 957
 958         case SO_RXQ_OVFL:
 959                 sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
 960                 break;
 961
 962         case SO_WIFI_STATUS:
 963                 sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
 964                 break;
 965
 966         case SO_PEEK_OFF:
 967                 if (sock->ops->set_peek_off)
 968                         ret = sock->ops->set_peek_off(sk, val);
 969                 else
 970                         ret = -EOPNOTSUPP;
 971                 break;
 972
 973         case SO_NOFCS:
 974                 sock_valbool_flag(sk, SOCK_NOFCS, valbool);
 975                 break;
 976
 977         case SO_SELECT_ERR_QUEUE:
 978                 sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
 979                 break;
 980
 981 #ifdef CONFIG_NET_RX_BUSY_POLL
 982         case SO_BUSY_POLL:
 983                 /* allow unprivileged users to decrease the value */
 984                 if ((val > sk->sk_ll_usec) && !capable(CAP_NET_ADMIN))
 985                         ret = -EPERM;
 986                 else {
 987                         if (val < 0)
 988                                 ret = -EINVAL;
 989                         else
 990                                 sk->sk_ll_usec = val;
 991                 }
 992                 break;
 993 #endif
 994
 995         case SO_MAX_PACING_RATE:
 996                 sk->sk_max_pacing_rate = val;
 997                 sk->sk_pacing_rate = min(sk->sk_pacing_rate,
 998                                          sk->sk_max_pacing_rate);
 999                 break;
1000
1001         case SO_INCOMING_CPU:
1002                 sk->sk_incoming_cpu = val;
1003                 break;
1004
1005         default:
1006                 ret = -ENOPROTOOPT;
1007                 break;
1008         }
1009         release_sock(sk);
1010         return ret;
1011 }
1012 EXPORT_SYMBOL(sock_setsockopt);
1013
1014
1015 static void cred_to_ucred(struct pid *pid, const struct cred *cred,
1016                           struct ucred *ucred)
1017 {
1018         ucred->pid = pid_vnr(pid);
1019         ucred->uid = ucred->gid = -1;
1020         if (cred) {
1021                 struct user_namespace *current_ns = current_user_ns();
1022
1023                 ucred->uid = from_kuid_munged(current_ns, cred->euid);
1024                 ucred->gid = from_kgid_munged(current_ns, cred->egid);
1025         }
1026 }
1027
1028 int sock_getsockopt(struct socket *sock, int level, int optname,
1029                     char __user *optval, int __user *optlen)
1030 {
1031         struct sock *sk = sock->sk;
1032
1033         union {
1034                 int val;
1035                 struct linger ling;
1036                 struct timeval tm;
1037         } v;
1038
1039         int lv = sizeof(int);
1040         int len;
1041
1042         if (get_user(len, optlen))
1043                 return -EFAULT;
1044         if (len < 0)
1045                 return -EINVAL;
1046
1047         memset(&v, 0, sizeof(v));
1048
1049         switch (optname) {
1050         case SO_DEBUG:
1051                 v.val = sock_flag(sk, SOCK_DBG);
1052                 break;
1053
1054         case SO_DONTROUTE:
1055                 v.val = sock_flag(sk, SOCK_LOCALROUTE);
1056                 break;
1057
1058         case SO_BROADCAST:
1059                 v.val = sock_flag(sk, SOCK_BROADCAST);
1060                 break;
1061
1062         case SO_SNDBUF:
1063                 v.val = sk->sk_sndbuf;
1064                 break;
1065
1066         case SO_RCVBUF:
1067                 v.val = sk->sk_rcvbuf;
1068                 break;
1069
1070         case SO_REUSEADDR:
1071                 v.val = sk->sk_reuse;
1072                 break;
1073
1074         case SO_REUSEPORT:
1075                 v.val = sk->sk_reuseport;
1076                 break;
1077
1078         case SO_KEEPALIVE:
1079                 v.val = sock_flag(sk, SOCK_KEEPOPEN);
1080                 break;
1081
1082         case SO_TYPE:
1083                 v.val = sk->sk_type;
1084                 break;
1085
1086         case SO_PROTOCOL:
1087                 v.val = sk->sk_protocol;
1088                 break;
1089
1090         case SO_DOMAIN:
1091                 v.val = sk->sk_family;
1092                 break;
1093
1094         case SO_ERROR:
1095                 v.val = -sock_error(sk);
1096                 if (v.val == 0)
1097                         v.val = xchg(&sk->sk_err_soft, 0);
1098                 break;
1099
1100         case SO_OOBINLINE:
1101                 v.val = sock_flag(sk, SOCK_URGINLINE);
1102                 break;
1103
1104         case SO_NO_CHECK:
1105                 v.val = sk->sk_no_check_tx;
1106                 break;
1107
1108         case SO_PRIORITY:
1109                 v.val = sk->sk_priority;
1110                 break;
1111
1112         case SO_LINGER:
1113                 lv              = sizeof(v.ling);
1114                 v.ling.l_onoff  = sock_flag(sk, SOCK_LINGER);
1115                 v.ling.l_linger = sk->sk_lingertime / HZ;
1116                 break;
1117
1118         case SO_BSDCOMPAT:
1119                 sock_warn_obsolete_bsdism("getsockopt");
1120                 break;
1121
1122         case SO_TIMESTAMP:
1123                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
1124                                 !sock_flag(sk, SOCK_RCVTSTAMPNS);
1125                 break;
1126
1127         case SO_TIMESTAMPNS:
1128                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
1129                 break;
1130
1131         case SO_TIMESTAMPING:
1132                 v.val = sk->sk_tsflags;
1133                 break;
1134
1135         case SO_RCVTIMEO:
1136                 lv = sizeof(struct timeval);
1137                 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
1138                         v.tm.tv_sec = 0;
1139                         v.tm.tv_usec = 0;
1140                 } else {
1141                         v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
1142                         v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
1143                 }
1144                 break;
1145
1146         case SO_SNDTIMEO:
1147                 lv = sizeof(struct timeval);
1148                 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
1149                         v.tm.tv_sec = 0;
1150                         v.tm.tv_usec = 0;
1151                 } else {
1152                         v.tm.tv_sec = sk->sk_sndtimeo / HZ;
1153                         v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
1154                 }
1155                 break;
1156
1157         case SO_RCVLOWAT:
1158                 v.val = sk->sk_rcvlowat;
1159                 break;
1160
1161         case SO_SNDLOWAT:
1162                 v.val = 1;
1163                 break;
1164
1165         case SO_PASSCRED:
1166                 v.val = !!test_bit(SOCK_PASSCRED, &sock->flags);
1167                 break;
1168
1169         case SO_PEERCRED:
1170         {
1171                 struct ucred peercred;
1172                 if (len > sizeof(peercred))
1173                         len = sizeof(peercred);
1174                 cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
1175                 if (copy_to_user(optval, &peercred, len))
1176                         return -EFAULT;
1177                 goto lenout;
1178         }
1179
1180         case SO_PEERNAME:
1181         {
1182                 char address[128];
1183
1184                 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
1185                         return -ENOTCONN;
1186                 if (lv < len)
1187                         return -EINVAL;
1188                 if (copy_to_user(optval, address, len))
1189                         return -EFAULT;
1190                 goto lenout;
1191         }
1192
1193         /* Dubious BSD thing... Probably nobody even uses it, but
1194          * the UNIX standard wants it for whatever reason... -DaveM
1195          */
1196         case SO_ACCEPTCONN:
1197                 v.val = sk->sk_state == TCP_LISTEN;
1198                 break;
1199
1200         case SO_PASSSEC:
1201                 v.val = !!test_bit(SOCK_PASSSEC, &sock->flags);
1202                 break;
1203
1204         case SO_PEERSEC:
1205                 return security_socket_getpeersec_stream(sock, optval, optlen, len);
1206
1207         case SO_MARK:
1208                 v.val = sk->sk_mark;
1209                 break;
1210
1211         case SO_RXQ_OVFL:
1212                 v.val = sock_flag(sk, SOCK_RXQ_OVFL);
1213                 break;
1214
1215         case SO_WIFI_STATUS:
1216                 v.val = sock_flag(sk, SOCK_WIFI_STATUS);
1217                 break;
1218
1219         case SO_PEEK_OFF:
1220                 if (!sock->ops->set_peek_off)
1221                         return -EOPNOTSUPP;
1222
1223                 v.val = sk->sk_peek_off;
1224                 break;
1225         case SO_NOFCS:
1226                 v.val = sock_flag(sk, SOCK_NOFCS);
1227                 break;
1228
1229         case SO_BINDTODEVICE:
1230                 return sock_getbindtodevice(sk, optval, optlen, len);
1231
1232         case SO_GET_FILTER:
1233                 len = sk_get_filter(sk, (struct sock_filter __user *)optval, len);
1234                 if (len < 0)
1235                         return len;
1236
1237                 goto lenout;
1238
1239         case SO_LOCK_FILTER:
1240                 v.val = sock_flag(sk, SOCK_FILTER_LOCKED);
1241                 break;
1242
1243         case SO_BPF_EXTENSIONS:
1244                 v.val = bpf_tell_extensions();
1245                 break;
1246
1247         case SO_SELECT_ERR_QUEUE:
1248                 v.val = sock_flag(sk, SOCK_SELECT_ERR_QUEUE);
1249                 break;
1250
1251 #ifdef CONFIG_NET_RX_BUSY_POLL
1252         case SO_BUSY_POLL:
1253                 v.val = sk->sk_ll_usec;
1254                 break;
1255 #endif
1256
1257         case SO_MAX_PACING_RATE:
1258                 v.val = sk->sk_max_pacing_rate;
1259                 break;
1260
1261         case SO_INCOMING_CPU:
1262                 v.val = sk->sk_incoming_cpu;
1263                 break;
1264
1265         default:
1266                 /* We implement the SO_SNDLOWAT etc to not be settable
1267                  * (1003.1g 7).
1268                  */
1269                 return -ENOPROTOOPT;
1270         }
1271
1272         if (len > lv)
1273                 len = lv;
1274         if (copy_to_user(optval, &v, len))
1275                 return -EFAULT;
1276 lenout:
1277         if (put_user(len, optlen))
1278                 return -EFAULT;
1279         return 0;
1280 }
1281
1282 /*
1283  * Initialize an sk_lock.
1284  *
1285  * (We also register the sk_lock with the lock validator.)
1286  */
1287 static inline void sock_lock_init(struct sock *sk)
1288 {
1289         sock_lock_init_class_and_name(sk,
1290                         af_family_slock_key_strings[sk->sk_family],
1291                         af_family_slock_keys + sk->sk_family,
1292                         af_family_key_strings[sk->sk_family],
1293                         af_family_keys + sk->sk_family);
1294 }
1295
1296 /*
1297  * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
1298  * even temporarly, because of RCU lookups. sk_node should also be left as is.
1299  * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
1300  */
1301 static void sock_copy(struct sock *nsk, const struct sock *osk)
1302 {
1303 #ifdef CONFIG_SECURITY_NETWORK
1304         void *sptr = nsk->sk_security;
1305 #endif
1306         memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
1307
1308         memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
1309                osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
1310
1311 #ifdef CONFIG_SECURITY_NETWORK
1312         nsk->sk_security = sptr;
1313         security_sk_clone(osk, nsk);
1314 #endif
1315 }
1316
1317 void sk_prot_clear_portaddr_nulls(struct sock *sk, int size)
1318 {
1319         unsigned long nulls1, nulls2;
1320
1321         nulls1 = offsetof(struct sock, __sk_common.skc_node.next);
1322         nulls2 = offsetof(struct sock, __sk_common.skc_portaddr_node.next);
1323         if (nulls1 > nulls2)
1324                 swap(nulls1, nulls2);
1325
1326         if (nulls1 != 0)
1327                 memset((char *)sk, 0, nulls1);
1328         memset((char *)sk + nulls1 + sizeof(void *), 0,
1329                nulls2 - nulls1 - sizeof(void *));
1330         memset((char *)sk + nulls2 + sizeof(void *), 0,
1331                size - nulls2 - sizeof(void *));
1332 }
1333 EXPORT_SYMBOL(sk_prot_clear_portaddr_nulls);
1334
1335 static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
1336                 int family)
1337 {
1338         struct sock *sk;
1339         struct kmem_cache *slab;
1340
1341         slab = prot->slab;
1342         if (slab != NULL) {
1343                 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
1344                 if (!sk)
1345                         return sk;
1346                 if (priority & __GFP_ZERO) {
1347                         if (prot->clear_sk)
1348                                 prot->clear_sk(sk, prot->obj_size);
1349                         else
1350                                 sk_prot_clear_nulls(sk, prot->obj_size);
1351                 }
1352         } else
1353                 sk = kmalloc(prot->obj_size, priority);
1354
1355         if (sk != NULL) {
1356                 kmemcheck_annotate_bitfield(sk, flags);
1357
1358                 if (security_sk_alloc(sk, family, priority))
1359                         goto out_free;
1360
1361                 if (!try_module_get(prot->owner))
1362                         goto out_free_sec;
1363                 sk_tx_queue_clear(sk);
1364         }
1365
1366         return sk;
1367
1368 out_free_sec:
1369         security_sk_free(sk);
1370 out_free:
1371         if (slab != NULL)
1372                 kmem_cache_free(slab, sk);
1373         else
1374                 kfree(sk);
1375         return NULL;
1376 }
1377
1378 static void sk_prot_free(struct proto *prot, struct sock *sk)
1379 {
1380         struct kmem_cache *slab;
1381         struct module *owner;
1382
1383         owner = prot->owner;
1384         slab = prot->slab;
1385
1386         security_sk_free(sk);
1387         if (slab != NULL)
1388                 kmem_cache_free(slab, sk);
1389         else
1390                 kfree(sk);
1391         module_put(owner);
1392 }
1393
1394 #if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
1395 void sock_update_netprioidx(struct sock *sk)
1396 {
1397         if (in_interrupt())
1398                 return;
1399
1400         sk->sk_cgrp_prioidx = task_netprioidx(current);
1401 }
1402 EXPORT_SYMBOL_GPL(sock_update_netprioidx);
1403 #endif
1404
1405 /**
1406  *      sk_alloc - All socket objects are allocated here
1407  *      @net: the applicable net namespace
1408  *      @family: protocol family
1409  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1410  *      @prot: struct proto associated with this new sock instance
1411  *      @kern: is this to be a kernel socket?
1412  */
1413 struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
1414                       struct proto *prot, int kern)
1415 {
1416         struct sock *sk;
1417
1418         sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
1419         if (sk) {
1420                 sk->sk_family = family;
1421                 /*
1422                  * See comment in struct sock definition to understand
1423                  * why we need sk_prot_creator -acme
1424                  */
1425                 sk->sk_prot = sk->sk_prot_creator = prot;
1426                 sock_lock_init(sk);
1427                 sk->sk_net_refcnt = kern ? 0 : 1;
1428                 if (likely(sk->sk_net_refcnt))
1429                         get_net(net);
1430                 sock_net_set(sk, net);
1431                 atomic_set(&sk->sk_wmem_alloc, 1);
1432
1433                 sock_update_classid(sk);
1434                 sock_update_netprioidx(sk);
1435         }
1436
1437         return sk;
1438 }
1439 EXPORT_SYMBOL(sk_alloc);
1440
1441 void sk_destruct(struct sock *sk)
1442 {
1443         struct sk_filter *filter;
1444
1445         if (sk->sk_destruct)
1446                 sk->sk_destruct(sk);
1447
1448         filter = rcu_dereference_check(sk->sk_filter,
1449                                        atomic_read(&sk->sk_wmem_alloc) == 0);
1450         if (filter) {
1451                 sk_filter_uncharge(sk, filter);
1452                 RCU_INIT_POINTER(sk->sk_filter, NULL);
1453         }
1454
1455         sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
1456
1457         if (atomic_read(&sk->sk_omem_alloc))
1458                 pr_debug("%s: optmem leakage (%d bytes) detected\n",
1459                          __func__, atomic_read(&sk->sk_omem_alloc));
1460
1461         if (sk->sk_peer_cred)
1462                 put_cred(sk->sk_peer_cred);
1463         put_pid(sk->sk_peer_pid);
1464         if (likely(sk->sk_net_refcnt))
1465                 put_net(sock_net(sk));
1466         sk_prot_free(sk->sk_prot_creator, sk);
1467 }
1468
1469 static void __sk_free(struct sock *sk)
1470 {
1471         if (unlikely(sock_diag_has_destroy_listeners(sk) && sk->sk_net_refcnt))
1472                 sock_diag_broadcast_destroy(sk);
1473         else
1474                 sk_destruct(sk);
1475 }
1476
1477 void sk_free(struct sock *sk)
1478 {
1479         /*
1480          * We subtract one from sk_wmem_alloc and can know if
1481          * some packets are still in some tx queue.
1482          * If not null, sock_wfree() will call __sk_free(sk) later
1483          */
1484         if (atomic_dec_and_test(&sk->sk_wmem_alloc))
1485                 __sk_free(sk);
1486 }
1487 EXPORT_SYMBOL(sk_free);
1488
1489 static void sk_update_clone(const struct sock *sk, struct sock *newsk)
1490 {
1491         if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
1492                 sock_update_memcg(newsk);
1493 }
1494
1495 /**
1496  *      sk_clone_lock - clone a socket, and lock its clone
1497  *      @sk: the socket to clone
1498  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1499  *
1500  *      Caller must unlock socket even in error path (bh_unlock_sock(newsk))
1501  */
1502 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
1503 {
1504         struct sock *newsk;
1505         bool is_charged = true;
1506
1507         newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
1508         if (newsk != NULL) {
1509                 struct sk_filter *filter;
1510
1511                 sock_copy(newsk, sk);
1512
1513                 /* SANITY */
1514                 if (likely(newsk->sk_net_refcnt))
1515                         get_net(sock_net(newsk));
1516                 sk_node_init(&newsk->sk_node);
1517                 sock_lock_init(newsk);
1518                 bh_lock_sock(newsk);
1519                 newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
1520                 newsk->sk_backlog.len = 0;
1521
1522                 atomic_set(&newsk->sk_rmem_alloc, 0);
1523                 /*
1524                  * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1525                  */
1526                 atomic_set(&newsk->sk_wmem_alloc, 1);
1527                 atomic_set(&newsk->sk_omem_alloc, 0);
1528                 skb_queue_head_init(&newsk->sk_receive_queue);
1529                 skb_queue_head_init(&newsk->sk_write_queue);
1530
1531                 rwlock_init(&newsk->sk_callback_lock);
1532                 lockdep_set_class_and_name(&newsk->sk_callback_lock,
1533                                 af_callback_keys + newsk->sk_family,
1534                                 af_family_clock_key_strings[newsk->sk_family]);
1535
1536                 newsk->sk_dst_cache     = NULL;
1537                 newsk->sk_wmem_queued   = 0;
1538                 newsk->sk_forward_alloc = 0;
1539                 newsk->sk_send_head     = NULL;
1540                 newsk->sk_userlocks     = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1541
1542                 sock_reset_flag(newsk, SOCK_DONE);
1543                 skb_queue_head_init(&newsk->sk_error_queue);
1544
1545                 filter = rcu_dereference_protected(newsk->sk_filter, 1);
1546                 if (filter != NULL)
1547                         /* though it's an empty new sock, the charging may fail
1548                          * if sysctl_optmem_max was changed between creation of
1549                          * original socket and cloning
1550                          */
1551                         is_charged = sk_filter_charge(newsk, filter);
1552
1553                 if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk))) {
1554                         /* It is still raw copy of parent, so invalidate
1555                          * destructor and make plain sk_free() */
1556                         newsk->sk_destruct = NULL;
1557                         bh_unlock_sock(newsk);
1558                         sk_free(newsk);
1559                         newsk = NULL;
1560                         goto out;
1561                 }
1562
1563                 newsk->sk_err      = 0;
1564                 newsk->sk_priority = 0;
1565                 newsk->sk_incoming_cpu = raw_smp_processor_id();
1566                 atomic64_set(&newsk->sk_cookie, 0);
1567                 /*
1568                  * Before updating sk_refcnt, we must commit prior changes to memory
1569                  * (Documentation/RCU/rculist_nulls.txt for details)
1570                  */
1571                 smp_wmb();
1572                 atomic_set(&newsk->sk_refcnt, 2);
1573
1574                 /*
1575                  * Increment the counter in the same struct proto as the master
1576                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1577                  * is the same as sk->sk_prot->socks, as this field was copied
1578                  * with memcpy).
1579                  *
1580                  * This _changes_ the previous behaviour, where
1581                  * tcp_create_openreq_child always was incrementing the
1582                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1583                  * to be taken into account in all callers. -acme
1584                  */
1585                 sk_refcnt_debug_inc(newsk);
1586                 sk_set_socket(newsk, NULL);
1587                 newsk->sk_wq = NULL;
1588
1589                 sk_update_clone(sk, newsk);
1590
1591                 if (newsk->sk_prot->sockets_allocated)
1592                         sk_sockets_allocated_inc(newsk);
1593
1594                 if (sock_needs_netstamp(sk) &&
1595                     newsk->sk_flags & SK_FLAGS_TIMESTAMP)
1596                         net_enable_timestamp();
1597         }
1598 out:
1599         return newsk;
1600 }
1601 EXPORT_SYMBOL_GPL(sk_clone_lock);
1602
1603 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1604 {
1605         u32 max_segs = 1;
1606
1607         sk_dst_set(sk, dst);
1608         sk->sk_route_caps = dst->dev->features;
1609         if (sk->sk_route_caps & NETIF_F_GSO)
1610                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1611         sk->sk_route_caps &= ~sk->sk_route_nocaps;
1612         if (sk_can_gso(sk)) {
1613                 if (dst->header_len) {
1614                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1615                 } else {
1616                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1617                         sk->sk_gso_max_size = dst->dev->gso_max_size;
1618                         max_segs = max_t(u32, dst->dev->gso_max_segs, 1);
1619                 }
1620         }
1621         sk->sk_gso_max_segs = max_segs;
1622 }
1623 EXPORT_SYMBOL_GPL(sk_setup_caps);
1624
1625 /*
1626  *      Simple resource managers for sockets.
1627  */
1628
1629
1630 /*
1631  * Write buffer destructor automatically called from kfree_skb.
1632  */
1633 void sock_wfree(struct sk_buff *skb)
1634 {
1635         struct sock *sk = skb->sk;
1636         unsigned int len = skb->truesize;
1637
1638         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1639                 /*
1640                  * Keep a reference on sk_wmem_alloc, this will be released
1641                  * after sk_write_space() call
1642                  */
1643                 atomic_sub(len - 1, &sk->sk_wmem_alloc);
1644                 sk->sk_write_space(sk);
1645                 len = 1;
1646         }
1647         /*
1648          * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1649          * could not do because of in-flight packets
1650          */
1651         if (atomic_sub_and_test(len, &sk->sk_wmem_alloc))
1652                 __sk_free(sk);
1653 }
1654 EXPORT_SYMBOL(sock_wfree);
1655
1656 void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1657 {
1658         skb_orphan(skb);
1659         skb->sk = sk;
1660 #ifdef CONFIG_INET
1661         if (unlikely(!sk_fullsock(sk))) {
1662                 skb->destructor = sock_edemux;
1663                 sock_hold(sk);
1664                 return;
1665         }
1666 #endif
1667         skb->destructor = sock_wfree;
1668         skb_set_hash_from_sk(skb, sk);
1669         /*
1670          * We used to take a refcount on sk, but following operation
1671          * is enough to guarantee sk_free() wont free this sock until
1672          * all in-flight packets are completed
1673          */
1674         atomic_add(skb->truesize, &sk->sk_wmem_alloc);
1675 }
1676 EXPORT_SYMBOL(skb_set_owner_w);
1677
1678 void skb_orphan_partial(struct sk_buff *skb)
1679 {
1680         /* TCP stack sets skb->ooo_okay based on sk_wmem_alloc,
1681          * so we do not completely orphan skb, but transfert all
1682          * accounted bytes but one, to avoid unexpected reorders.
1683          */
1684         if (skb->destructor == sock_wfree
1685 #ifdef CONFIG_INET
1686             || skb->destructor == tcp_wfree
1687 #endif
1688                 ) {
1689                 atomic_sub(skb->truesize - 1, &skb->sk->sk_wmem_alloc);
1690                 skb->truesize = 1;
1691         } else {
1692                 skb_orphan(skb);
1693         }
1694 }
1695 EXPORT_SYMBOL(skb_orphan_partial);
1696
1697 /*
1698  * Read buffer destructor automatically called from kfree_skb.
1699  */
1700 void sock_rfree(struct sk_buff *skb)
1701 {
1702         struct sock *sk = skb->sk;
1703         unsigned int len = skb->truesize;
1704
1705         atomic_sub(len, &sk->sk_rmem_alloc);
1706         sk_mem_uncharge(sk, len);
1707 }
1708 EXPORT_SYMBOL(sock_rfree);
1709
1710 /*
1711  * Buffer destructor for skbs that are not used directly in read or write
1712  * path, e.g. for error handler skbs. Automatically called from kfree_skb.
1713  */
1714 void sock_efree(struct sk_buff *skb)
1715 {
1716         sock_put(skb->sk);
1717 }
1718 EXPORT_SYMBOL(sock_efree);
1719
1720 kuid_t sock_i_uid(struct sock *sk)
1721 {
1722         kuid_t uid;
1723
1724         read_lock_bh(&sk->sk_callback_lock);
1725         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
1726         read_unlock_bh(&sk->sk_callback_lock);
1727         return uid;
1728 }
1729 EXPORT_SYMBOL(sock_i_uid);
1730
1731 unsigned long sock_i_ino(struct sock *sk)
1732 {
1733         unsigned long ino;
1734
1735         read_lock_bh(&sk->sk_callback_lock);
1736         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1737         read_unlock_bh(&sk->sk_callback_lock);
1738         return ino;
1739 }
1740 EXPORT_SYMBOL(sock_i_ino);
1741
1742 /*
1743  * Allocate a skb from the socket's send buffer.
1744  */
1745 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1746                              gfp_t priority)
1747 {
1748         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1749                 struct sk_buff *skb = alloc_skb(size, priority);
1750                 if (skb) {
1751                         skb_set_owner_w(skb, sk);
1752                         return skb;
1753                 }
1754         }
1755         return NULL;
1756 }
1757 EXPORT_SYMBOL(sock_wmalloc);
1758
1759 /*
1760  * Allocate a memory block from the socket's option memory buffer.
1761  */
1762 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1763 {
1764         if ((unsigned int)size <= sysctl_optmem_max &&
1765             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1766                 void *mem;
1767                 /* First do the add, to avoid the race if kmalloc
1768                  * might sleep.
1769                  */
1770                 atomic_add(size, &sk->sk_omem_alloc);
1771                 mem = kmalloc(size, priority);
1772                 if (mem)
1773                         return mem;
1774                 atomic_sub(size, &sk->sk_omem_alloc);
1775         }
1776         return NULL;
1777 }
1778 EXPORT_SYMBOL(sock_kmalloc);
1779
1780 /* Free an option memory block. Note, we actually want the inline
1781  * here as this allows gcc to detect the nullify and fold away the
1782  * condition entirely.
1783  */
1784 static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
1785                                   const bool nullify)
1786 {
1787         if (WARN_ON_ONCE(!mem))
1788                 return;
1789         if (nullify)
1790                 kzfree(mem);
1791         else
1792                 kfree(mem);
1793         atomic_sub(size, &sk->sk_omem_alloc);
1794 }
1795
1796 void sock_kfree_s(struct sock *sk, void *mem, int size)
1797 {
1798         __sock_kfree_s(sk, mem, size, false);
1799 }
1800 EXPORT_SYMBOL(sock_kfree_s);
1801
1802 void sock_kzfree_s(struct sock *sk, void *mem, int size)
1803 {
1804         __sock_kfree_s(sk, mem, size, true);
1805 }
1806 EXPORT_SYMBOL(sock_kzfree_s);
1807
1808 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1809    I think, these locks should be removed for datagram sockets.
1810  */
1811 static long sock_wait_for_wmem(struct sock *sk, long timeo)
1812 {
1813         DEFINE_WAIT(wait);
1814
1815         sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
1816         for (;;) {
1817                 if (!timeo)
1818                         break;
1819                 if (signal_pending(current))
1820                         break;
1821                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1822                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1823                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1824                         break;
1825                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1826                         break;
1827                 if (sk->sk_err)
1828                         break;
1829                 timeo = schedule_timeout(timeo);
1830         }
1831         finish_wait(sk_sleep(sk), &wait);
1832         return timeo;
1833 }
1834
1835
1836 /*
1837  *      Generic send/receive buffer handlers
1838  */
1839
1840 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1841                                      unsigned long data_len, int noblock,
1842                                      int *errcode, int max_page_order)
1843 {
1844         struct sk_buff *skb;
1845         long timeo;
1846         int err;
1847
1848         timeo = sock_sndtimeo(sk, noblock);
1849         for (;;) {
1850                 err = sock_error(sk);
1851                 if (err != 0)
1852                         goto failure;
1853
1854                 err = -EPIPE;
1855                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1856                         goto failure;
1857
1858                 if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
1859                         break;
1860
1861                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
1862                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1863                 err = -EAGAIN;
1864                 if (!timeo)
1865                         goto failure;
1866                 if (signal_pending(current))
1867                         goto interrupted;
1868                 timeo = sock_wait_for_wmem(sk, timeo);
1869         }
1870         skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
1871                                    errcode, sk->sk_allocation);
1872         if (skb)
1873                 skb_set_owner_w(skb, sk);
1874         return skb;
1875
1876 interrupted:
1877         err = sock_intr_errno(timeo);
1878 failure:
1879         *errcode = err;
1880         return NULL;
1881 }
1882 EXPORT_SYMBOL(sock_alloc_send_pskb);
1883
1884 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1885                                     int noblock, int *errcode)
1886 {
1887         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode, 0);
1888 }
1889 EXPORT_SYMBOL(sock_alloc_send_skb);
1890
1891 int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
1892                    struct sockcm_cookie *sockc)
1893 {
1894         struct cmsghdr *cmsg;
1895
1896         for_each_cmsghdr(cmsg, msg) {
1897                 if (!CMSG_OK(msg, cmsg))
1898                         return -EINVAL;
1899                 if (cmsg->cmsg_level != SOL_SOCKET)
1900                         continue;
1901                 switch (cmsg->cmsg_type) {
1902                 case SO_MARK:
1903                         if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
1904                                 return -EPERM;
1905                         if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
1906                                 return -EINVAL;
1907                         sockc->mark = *(u32 *)CMSG_DATA(cmsg);
1908                         break;
1909                 default:
1910                         return -EINVAL;
1911                 }
1912         }
1913         return 0;
1914 }
1915 EXPORT_SYMBOL(sock_cmsg_send);
1916
1917 /* On 32bit arches, an skb frag is limited to 2^15 */
1918 #define SKB_FRAG_PAGE_ORDER     get_order(32768)
1919
1920 /**
1921  * skb_page_frag_refill - check that a page_frag contains enough room
1922  * @sz: minimum size of the fragment we want to get
1923  * @pfrag: pointer to page_frag
1924  * @gfp: priority for memory allocation
1925  *
1926  * Note: While this allocator tries to use high order pages, there is
1927  * no guarantee that allocations succeed. Therefore, @sz MUST be
1928  * less or equal than PAGE_SIZE.
1929  */
1930 bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
1931 {
1932         if (pfrag->page) {
1933                 if (atomic_read(&pfrag->page->_count) == 1) {
1934                         pfrag->offset = 0;
1935                         return true;
1936                 }
1937                 if (pfrag->offset + sz <= pfrag->size)
1938                         return true;
1939                 put_page(pfrag->page);
1940         }
1941
1942         pfrag->offset = 0;
1943         if (SKB_FRAG_PAGE_ORDER) {
1944                 /* Avoid direct reclaim but allow kswapd to wake */
1945                 pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) |
1946                                           __GFP_COMP | __GFP_NOWARN |
1947                                           __GFP_NORETRY,
1948                                           SKB_FRAG_PAGE_ORDER);
1949                 if (likely(pfrag->page)) {
1950                         pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
1951                         return true;
1952                 }
1953         }
1954         pfrag->page = alloc_page(gfp);
1955         if (likely(pfrag->page)) {
1956                 pfrag->size = PAGE_SIZE;
1957                 return true;
1958         }
1959         return false;
1960 }
1961 EXPORT_SYMBOL(skb_page_frag_refill);
1962
1963 bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
1964 {
1965         if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
1966                 return true;
1967
1968         sk_enter_memory_pressure(sk);
1969         sk_stream_moderate_sndbuf(sk);
1970         return false;
1971 }
1972 EXPORT_SYMBOL(sk_page_frag_refill);
1973
1974 static void __lock_sock(struct sock *sk)
1975         __releases(&sk->sk_lock.slock)
1976         __acquires(&sk->sk_lock.slock)
1977 {
1978         DEFINE_WAIT(wait);
1979
1980         for (;;) {
1981                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1982                                         TASK_UNINTERRUPTIBLE);
1983                 spin_unlock_bh(&sk->sk_lock.slock);
1984                 schedule();
1985                 spin_lock_bh(&sk->sk_lock.slock);
1986                 if (!sock_owned_by_user(sk))
1987                         break;
1988         }
1989         finish_wait(&sk->sk_lock.wq, &wait);
1990 }
1991
1992 static void __release_sock(struct sock *sk)
1993         __releases(&sk->sk_lock.slock)
1994         __acquires(&sk->sk_lock.slock)
1995 {
1996         struct sk_buff *skb = sk->sk_backlog.head;
1997
1998         do {
1999                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
2000                 bh_unlock_sock(sk);
2001
2002                 do {
2003                         struct sk_buff *next = skb->next;
2004
2005                         prefetch(next);
2006                         WARN_ON_ONCE(skb_dst_is_noref(skb));
2007                         skb->next = NULL;
2008                         sk_backlog_rcv(sk, skb);
2009
2010                         /*
2011                          * We are in process context here with softirqs
2012                          * disabled, use cond_resched_softirq() to preempt.
2013                          * This is safe to do because we've taken the backlog
2014                          * queue private:
2015                          */
2016                         cond_resched_softirq();
2017
2018                         skb = next;
2019                 } while (skb != NULL);
2020
2021                 bh_lock_sock(sk);
2022         } while ((skb = sk->sk_backlog.head) != NULL);
2023
2024         /*
2025          * Doing the zeroing here guarantee we can not loop forever
2026          * while a wild producer attempts to flood us.
2027          */
2028         sk->sk_backlog.len = 0;
2029 }
2030
2031 /**
2032  * sk_wait_data - wait for data to arrive at sk_receive_queue
2033  * @sk:    sock to wait on
2034  * @timeo: for how long
2035  * @skb:   last skb seen on sk_receive_queue
2036  *
2037  * Now socket state including sk->sk_err is changed only under lock,
2038  * hence we may omit checks after joining wait queue.
2039  * We check receive queue before schedule() only as optimization;
2040  * it is very likely that release_sock() added new data.
2041  */
2042 int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
2043 {
2044         int rc;
2045         DEFINE_WAIT(wait);
2046
2047         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2048         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2049         rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb);
2050         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2051         finish_wait(sk_sleep(sk), &wait);
2052         return rc;
2053 }
2054 EXPORT_SYMBOL(sk_wait_data);
2055
2056 /**
2057  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
2058  *      @sk: socket
2059  *      @size: memory size to allocate
2060  *      @kind: allocation type
2061  *
2062  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
2063  *      rmem allocation. This function assumes that protocols which have
2064  *      memory_pressure use sk_wmem_queued as write buffer accounting.
2065  */
2066 int __sk_mem_schedule(struct sock *sk, int size, int kind)
2067 {
2068         struct proto *prot = sk->sk_prot;
2069         int amt = sk_mem_pages(size);
2070         long allocated;
2071         int parent_status = UNDER_LIMIT;
2072
2073         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
2074
2075         allocated = sk_memory_allocated_add(sk, amt, &parent_status);
2076
2077         /* Under limit. */
2078         if (parent_status == UNDER_LIMIT &&
2079                         allocated <= sk_prot_mem_limits(sk, 0)) {
2080                 sk_leave_memory_pressure(sk);
2081                 return 1;
2082         }
2083
2084         /* Under pressure. (we or our parents) */
2085         if ((parent_status > SOFT_LIMIT) ||
2086                         allocated > sk_prot_mem_limits(sk, 1))
2087                 sk_enter_memory_pressure(sk);
2088
2089         /* Over hard limit (we or our parents) */
2090         if ((parent_status == OVER_LIMIT) ||
2091                         (allocated > sk_prot_mem_limits(sk, 2)))
2092                 goto suppress_allocation;
2093
2094         /* guarantee minimum buffer size under pressure */
2095         if (kind == SK_MEM_RECV) {
2096                 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
2097                         return 1;
2098
2099         } else { /* SK_MEM_SEND */
2100                 if (sk->sk_type == SOCK_STREAM) {
2101                         if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
2102                                 return 1;
2103                 } else if (atomic_read(&sk->sk_wmem_alloc) <
2104                            prot->sysctl_wmem[0])
2105                                 return 1;
2106         }
2107
2108         if (sk_has_memory_pressure(sk)) {
2109                 int alloc;
2110
2111                 if (!sk_under_memory_pressure(sk))
2112                         return 1;
2113                 alloc = sk_sockets_allocated_read_positive(sk);
2114                 if (sk_prot_mem_limits(sk, 2) > alloc *
2115                     sk_mem_pages(sk->sk_wmem_queued +
2116                                  atomic_read(&sk->sk_rmem_alloc) +
2117                                  sk->sk_forward_alloc))
2118                         return 1;
2119         }
2120
2121 suppress_allocation:
2122
2123         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
2124                 sk_stream_moderate_sndbuf(sk);
2125
2126                 /* Fail only if socket is _under_ its sndbuf.
2127                  * In this case we cannot block, so that we have to fail.
2128                  */
2129                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
2130                         return 1;
2131         }
2132
2133         trace_sock_exceed_buf_limit(sk, prot, allocated);
2134
2135         /* Alas. Undo changes. */
2136         sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
2137
2138         sk_memory_allocated_sub(sk, amt);
2139
2140         return 0;
2141 }
2142 EXPORT_SYMBOL(__sk_mem_schedule);
2143
2144 /**
2145  *      __sk_mem_reclaim - reclaim memory_allocated
2146  *      @sk: socket
2147  *      @amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)
2148  */
2149 void __sk_mem_reclaim(struct sock *sk, int amount)
2150 {
2151         amount >>= SK_MEM_QUANTUM_SHIFT;
2152         sk_memory_allocated_sub(sk, amount);
2153         sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
2154
2155         if (sk_under_memory_pressure(sk) &&
2156             (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
2157                 sk_leave_memory_pressure(sk);
2158 }
2159 EXPORT_SYMBOL(__sk_mem_reclaim);
2160
2161
2162 /*
2163  * Set of default routines for initialising struct proto_ops when
2164  * the protocol does not support a particular function. In certain
2165  * cases where it makes no sense for a protocol to have a "do nothing"
2166  * function, some default processing is provided.
2167  */
2168
2169 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
2170 {
2171         return -EOPNOTSUPP;
2172 }
2173 EXPORT_SYMBOL(sock_no_bind);
2174
2175 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
2176                     int len, int flags)
2177 {
2178         return -EOPNOTSUPP;
2179 }
2180 EXPORT_SYMBOL(sock_no_connect);
2181
2182 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
2183 {
2184         return -EOPNOTSUPP;
2185 }
2186 EXPORT_SYMBOL(sock_no_socketpair);
2187
2188 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
2189 {
2190         return -EOPNOTSUPP;
2191 }
2192 EXPORT_SYMBOL(sock_no_accept);
2193
2194 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
2195                     int *len, int peer)
2196 {
2197         return -EOPNOTSUPP;
2198 }
2199 EXPORT_SYMBOL(sock_no_getname);
2200
2201 unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
2202 {
2203         return 0;
2204 }
2205 EXPORT_SYMBOL(sock_no_poll);
2206
2207 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2208 {
2209         return -EOPNOTSUPP;
2210 }
2211 EXPORT_SYMBOL(sock_no_ioctl);
2212
2213 int sock_no_listen(struct socket *sock, int backlog)
2214 {
2215         return -EOPNOTSUPP;
2216 }
2217 EXPORT_SYMBOL(sock_no_listen);
2218
2219 int sock_no_shutdown(struct socket *sock, int how)
2220 {
2221         return -EOPNOTSUPP;
2222 }
2223 EXPORT_SYMBOL(sock_no_shutdown);
2224
2225 int sock_no_setsockopt(struct socket *sock, int level, int optname,
2226                     char __user *optval, unsigned int optlen)
2227 {
2228         return -EOPNOTSUPP;
2229 }
2230 EXPORT_SYMBOL(sock_no_setsockopt);
2231
2232 int sock_no_getsockopt(struct socket *sock, int level, int optname,
2233                     char __user *optval, int __user *optlen)
2234 {
2235         return -EOPNOTSUPP;
2236 }
2237 EXPORT_SYMBOL(sock_no_getsockopt);
2238
2239 int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
2240 {
2241         return -EOPNOTSUPP;
2242 }
2243 EXPORT_SYMBOL(sock_no_sendmsg);
2244
2245 int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
2246                     int flags)
2247 {
2248         return -EOPNOTSUPP;
2249 }
2250 EXPORT_SYMBOL(sock_no_recvmsg);
2251
2252 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
2253 {
2254         /* Mirror missing mmap method error code */
2255         return -ENODEV;
2256 }
2257 EXPORT_SYMBOL(sock_no_mmap);
2258
2259 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
2260 {
2261         ssize_t res;
2262         struct msghdr msg = {.msg_flags = flags};
2263         struct kvec iov;
2264         char *kaddr = kmap(page);
2265         iov.iov_base = kaddr + offset;
2266         iov.iov_len = size;
2267         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
2268         kunmap(page);
2269         return res;
2270 }
2271 EXPORT_SYMBOL(sock_no_sendpage);
2272
2273 /*
2274  *      Default Socket Callbacks
2275  */
2276
2277 static void sock_def_wakeup(struct sock *sk)
2278 {
2279         struct socket_wq *wq;
2280
2281         rcu_read_lock();
2282         wq = rcu_dereference(sk->sk_wq);
2283         if (wq_has_sleeper(wq))
2284                 wake_up_interruptible_all(&wq->wait);
2285         rcu_read_unlock();
2286 }
2287
2288 static void sock_def_error_report(struct sock *sk)
2289 {
2290         struct socket_wq *wq;
2291
2292         rcu_read_lock();
2293         wq = rcu_dereference(sk->sk_wq);
2294         if (wq_has_sleeper(wq))
2295                 wake_up_interruptible_poll(&wq->wait, POLLERR);
2296         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
2297         rcu_read_unlock();
2298 }
2299
2300 static void sock_def_readable(struct sock *sk)
2301 {
2302         struct socket_wq *wq;
2303
2304         rcu_read_lock();
2305         wq = rcu_dereference(sk->sk_wq);
2306         if (wq_has_sleeper(wq))
2307                 wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
2308                                                 POLLRDNORM | POLLRDBAND);
2309         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
2310         rcu_read_unlock();
2311 }
2312
2313 static void sock_def_write_space(struct sock *sk)
2314 {
2315         struct socket_wq *wq;
2316
2317         rcu_read_lock();
2318
2319         /* Do not wake up a writer until he can make "significant"
2320          * progress.  --DaveM
2321          */
2322         if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
2323                 wq = rcu_dereference(sk->sk_wq);
2324                 if (wq_has_sleeper(wq))
2325                         wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
2326                                                 POLLWRNORM | POLLWRBAND);
2327
2328                 /* Should agree with poll, otherwise some programs break */
2329                 if (sock_writeable(sk))
2330                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
2331         }
2332
2333         rcu_read_unlock();
2334 }
2335
2336 static void sock_def_destruct(struct sock *sk)
2337 {
2338 }
2339
2340 void sk_send_sigurg(struct sock *sk)
2341 {
2342         if (sk->sk_socket && sk->sk_socket->file)
2343                 if (send_sigurg(&sk->sk_socket->file->f_owner))
2344                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
2345 }
2346 EXPORT_SYMBOL(sk_send_sigurg);
2347
2348 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
2349                     unsigned long expires)
2350 {
2351         if (!mod_timer(timer, expires))
2352                 sock_hold(sk);
2353 }
2354 EXPORT_SYMBOL(sk_reset_timer);
2355
2356 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
2357 {
2358         if (del_timer(timer))
2359                 __sock_put(sk);
2360 }
2361 EXPORT_SYMBOL(sk_stop_timer);
2362
2363 void sock_init_data(struct socket *sock, struct sock *sk)
2364 {
2365         skb_queue_head_init(&sk->sk_receive_queue);
2366         skb_queue_head_init(&sk->sk_write_queue);
2367         skb_queue_head_init(&sk->sk_error_queue);
2368
2369         sk->sk_send_head        =       NULL;
2370
2371         init_timer(&sk->sk_timer);
2372
2373         sk->sk_allocation       =       GFP_KERNEL;
2374         sk->sk_rcvbuf           =       sysctl_rmem_default;
2375         sk->sk_sndbuf           =       sysctl_wmem_default;
2376         sk->sk_state            =       TCP_CLOSE;
2377         sk_set_socket(sk, sock);
2378
2379         sock_set_flag(sk, SOCK_ZAPPED);
2380
2381         if (sock) {
2382                 sk->sk_type     =       sock->type;
2383                 sk->sk_wq       =       sock->wq;
2384                 sock->sk        =       sk;
2385         } else
2386                 sk->sk_wq       =       NULL;
2387
2388         rwlock_init(&sk->sk_callback_lock);
2389         lockdep_set_class_and_name(&sk->sk_callback_lock,
2390                         af_callback_keys + sk->sk_family,
2391                         af_family_clock_key_strings[sk->sk_family]);
2392
2393         sk->sk_state_change     =       sock_def_wakeup;
2394         sk->sk_data_ready       =       sock_def_readable;
2395         sk->sk_write_space      =       sock_def_write_space;
2396         sk->sk_error_report     =       sock_def_error_report;
2397         sk->sk_destruct         =       sock_def_destruct;
2398
2399         sk->sk_frag.page        =       NULL;
2400         sk->sk_frag.offset      =       0;
2401         sk->sk_peek_off         =       -1;
2402
2403         sk->sk_peer_pid         =       NULL;
2404         sk->sk_peer_cred        =       NULL;
2405         sk->sk_write_pending    =       0;
2406         sk->sk_rcvlowat         =       1;
2407         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
2408         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
2409
2410         sk->sk_stamp = ktime_set(-1L, 0);
2411
2412 #ifdef CONFIG_NET_RX_BUSY_POLL
2413         sk->sk_napi_id          =       0;
2414         sk->sk_ll_usec          =       sysctl_net_busy_read;
2415 #endif
2416
2417         sk->sk_max_pacing_rate = ~0U;
2418         sk->sk_pacing_rate = ~0U;
2419         sk->sk_incoming_cpu = -1;
2420         /*
2421          * Before updating sk_refcnt, we must commit prior changes to memory
2422          * (Documentation/RCU/rculist_nulls.txt for details)
2423          */
2424         smp_wmb();
2425         atomic_set(&sk->sk_refcnt, 1);
2426         atomic_set(&sk->sk_drops, 0);
2427 }
2428 EXPORT_SYMBOL(sock_init_data);
2429
2430 void lock_sock_nested(struct sock *sk, int subclass)
2431 {
2432         might_sleep();
2433         spin_lock_bh(&sk->sk_lock.slock);
2434         if (sk->sk_lock.owned)
2435                 __lock_sock(sk);
2436         sk->sk_lock.owned = 1;
2437         spin_unlock(&sk->sk_lock.slock);
2438         /*
2439          * The sk_lock has mutex_lock() semantics here:
2440          */
2441         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
2442         local_bh_enable();
2443 }
2444 EXPORT_SYMBOL(lock_sock_nested);
2445
2446 void release_sock(struct sock *sk)
2447 {
2448         /*
2449          * The sk_lock has mutex_unlock() semantics:
2450          */
2451         mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
2452
2453         spin_lock_bh(&sk->sk_lock.slock);
2454         if (sk->sk_backlog.tail)
2455                 __release_sock(sk);
2456
2457         /* Warning : release_cb() might need to release sk ownership,
2458          * ie call sock_release_ownership(sk) before us.
2459          */
2460         if (sk->sk_prot->release_cb)
2461                 sk->sk_prot->release_cb(sk);
2462
2463         sock_release_ownership(sk);
2464         if (waitqueue_active(&sk->sk_lock.wq))
2465                 wake_up(&sk->sk_lock.wq);
2466         spin_unlock_bh(&sk->sk_lock.slock);
2467 }
2468 EXPORT_SYMBOL(release_sock);
2469
2470 /**
2471  * lock_sock_fast - fast version of lock_sock
2472  * @sk: socket
2473  *
2474  * This version should be used for very small section, where process wont block
2475  * return false if fast path is taken
2476  *   sk_lock.slock locked, owned = 0, BH disabled
2477  * return true if slow path is taken
2478  *   sk_lock.slock unlocked, owned = 1, BH enabled
2479  */
2480 bool lock_sock_fast(struct sock *sk)
2481 {
2482         might_sleep();
2483         spin_lock_bh(&sk->sk_lock.slock);
2484
2485         if (!sk->sk_lock.owned)
2486                 /*
2487                  * Note : We must disable BH
2488                  */
2489                 return false;
2490
2491         __lock_sock(sk);
2492         sk->sk_lock.owned = 1;
2493         spin_unlock(&sk->sk_lock.slock);
2494         /*
2495          * The sk_lock has mutex_lock() semantics here:
2496          */
2497         mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
2498         local_bh_enable();
2499         return true;
2500 }
2501 EXPORT_SYMBOL(lock_sock_fast);
2502
2503 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
2504 {
2505         struct timeval tv;
2506         if (!sock_flag(sk, SOCK_TIMESTAMP))
2507                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2508         tv = ktime_to_timeval(sk->sk_stamp);
2509         if (tv.tv_sec == -1)
2510                 return -ENOENT;
2511         if (tv.tv_sec == 0) {
2512                 sk->sk_stamp = ktime_get_real();
2513                 tv = ktime_to_timeval(sk->sk_stamp);
2514         }
2515         return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
2516 }
2517 EXPORT_SYMBOL(sock_get_timestamp);
2518
2519 int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2520 {
2521         struct timespec ts;
2522         if (!sock_flag(sk, SOCK_TIMESTAMP))
2523                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2524         ts = ktime_to_timespec(sk->sk_stamp);
2525         if (ts.tv_sec == -1)
2526                 return -ENOENT;
2527         if (ts.tv_sec == 0) {
2528                 sk->sk_stamp = ktime_get_real();
2529                 ts = ktime_to_timespec(sk->sk_stamp);
2530         }
2531         return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2532 }
2533 EXPORT_SYMBOL(sock_get_timestampns);
2534
2535 void sock_enable_timestamp(struct sock *sk, int flag)
2536 {
2537         if (!sock_flag(sk, flag)) {
2538                 unsigned long previous_flags = sk->sk_flags;
2539
2540                 sock_set_flag(sk, flag);
2541                 /*
2542                  * we just set one of the two flags which require net
2543                  * time stamping, but time stamping might have been on
2544                  * already because of the other one
2545                  */
2546                 if (sock_needs_netstamp(sk) &&
2547                     !(previous_flags & SK_FLAGS_TIMESTAMP))
2548                         net_enable_timestamp();
2549         }
2550 }
2551
2552 int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
2553                        int level, int type)
2554 {
2555         struct sock_exterr_skb *serr;
2556         struct sk_buff *skb;
2557         int copied, err;
2558
2559         err = -EAGAIN;
2560         skb = sock_dequeue_err_skb(sk);
2561         if (skb == NULL)
2562                 goto out;
2563
2564         copied = skb->len;
2565         if (copied > len) {
2566                 msg->msg_flags |= MSG_TRUNC;
2567                 copied = len;
2568         }
2569         err = skb_copy_datagram_msg(skb, 0, msg, copied);
2570         if (err)
2571                 goto out_free_skb;
2572
2573         sock_recv_timestamp(msg, sk, skb);
2574
2575         serr = SKB_EXT_ERR(skb);
2576         put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
2577
2578         msg->msg_flags |= MSG_ERRQUEUE;
2579         err = copied;
2580
2581 out_free_skb:
2582         kfree_skb(skb);
2583 out:
2584         return err;
2585 }
2586 EXPORT_SYMBOL(sock_recv_errqueue);
2587
2588 /*
2589  *      Get a socket option on an socket.
2590  *
2591  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
2592  *      asynchronous errors should be reported by getsockopt. We assume
2593  *      this means if you specify SO_ERROR (otherwise whats the point of it).
2594  */
2595 int sock_common_getsockopt(struct socket *sock, int level, int optname,
2596                            char __user *optval, int __user *optlen)
2597 {
2598         struct sock *sk = sock->sk;
2599
2600         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2601 }
2602 EXPORT_SYMBOL(sock_common_getsockopt);
2603
2604 #ifdef CONFIG_COMPAT
2605 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
2606                                   char __user *optval, int __user *optlen)
2607 {
2608         struct sock *sk = sock->sk;
2609
2610         if (sk->sk_prot->compat_getsockopt != NULL)
2611                 return sk->sk_prot->compat_getsockopt(sk, level, optname,
2612                                                       optval, optlen);
2613         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2614 }
2615 EXPORT_SYMBOL(compat_sock_common_getsockopt);
2616 #endif
2617
2618 int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
2619                         int flags)
2620 {
2621         struct sock *sk = sock->sk;
2622         int addr_len = 0;
2623         int err;
2624
2625         err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
2626                                    flags & ~MSG_DONTWAIT, &addr_len);
2627         if (err >= 0)
2628                 msg->msg_namelen = addr_len;
2629         return err;
2630 }
2631 EXPORT_SYMBOL(sock_common_recvmsg);
2632
2633 /*
2634  *      Set socket options on an inet socket.
2635  */
2636 int sock_common_setsockopt(struct socket *sock, int level, int optname,
2637                            char __user *optval, unsigned int optlen)
2638 {
2639         struct sock *sk = sock->sk;
2640
2641         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2642 }
2643 EXPORT_SYMBOL(sock_common_setsockopt);
2644
2645 #ifdef CONFIG_COMPAT
2646 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
2647                                   char __user *optval, unsigned int optlen)
2648 {
2649         struct sock *sk = sock->sk;
2650
2651         if (sk->sk_prot->compat_setsockopt != NULL)
2652                 return sk->sk_prot->compat_setsockopt(sk, level, optname,
2653                                                       optval, optlen);
2654         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2655 }
2656 EXPORT_SYMBOL(compat_sock_common_setsockopt);
2657 #endif
2658
2659 void sk_common_release(struct sock *sk)
2660 {
2661         if (sk->sk_prot->destroy)
2662                 sk->sk_prot->destroy(sk);
2663
2664         /*
2665          * Observation: when sock_common_release is called, processes have
2666          * no access to socket. But net still has.
2667          * Step one, detach it from networking:
2668          *
2669          * A. Remove from hash tables.
2670          */
2671
2672         sk->sk_prot->unhash(sk);
2673
2674         /*
2675          * In this point socket cannot receive new packets, but it is possible
2676          * that some packets are in flight because some CPU runs receiver and
2677          * did hash table lookup before we unhashed socket. They will achieve
2678          * receive queue and will be purged by socket destructor.
2679          *
2680          * Also we still have packets pending on receive queue and probably,
2681          * our own packets waiting in device queues. sock_destroy will drain
2682          * receive queue, but transmitted packets will delay socket destruction
2683          * until the last reference will be released.
2684          */
2685
2686         sock_orphan(sk);
2687
2688         xfrm_sk_free_policy(sk);
2689
2690         sk_refcnt_debug_release(sk);
2691
2692         if (sk->sk_frag.page) {
2693                 put_page(sk->sk_frag.page);
2694                 sk->sk_frag.page = NULL;
2695         }
2696
2697         sock_put(sk);
2698 }
2699 EXPORT_SYMBOL(sk_common_release);
2700
2701 #ifdef CONFIG_PROC_FS
2702 #define PROTO_INUSE_NR  64      /* should be enough for the first time */
2703 struct prot_inuse {
2704         int val[PROTO_INUSE_NR];
2705 };
2706
2707 static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
2708
2709 #ifdef CONFIG_NET_NS
2710 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2711 {
2712         __this_cpu_add(net->core.inuse->val[prot->inuse_idx], val);
2713 }
2714 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2715
2716 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2717 {
2718         int cpu, idx = prot->inuse_idx;
2719         int res = 0;
2720
2721         for_each_possible_cpu(cpu)
2722                 res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2723
2724         return res >= 0 ? res : 0;
2725 }
2726 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2727
2728 static int __net_init sock_inuse_init_net(struct net *net)
2729 {
2730         net->core.inuse = alloc_percpu(struct prot_inuse);
2731         return net->core.inuse ? 0 : -ENOMEM;
2732 }
2733
2734 static void __net_exit sock_inuse_exit_net(struct net *net)
2735 {
2736         free_percpu(net->core.inuse);
2737 }
2738
2739 static struct pernet_operations net_inuse_ops = {
2740         .init = sock_inuse_init_net,
2741         .exit = sock_inuse_exit_net,
2742 };
2743
2744 static __init int net_inuse_init(void)
2745 {
2746         if (register_pernet_subsys(&net_inuse_ops))
2747                 panic("Cannot initialize net inuse counters");
2748
2749         return 0;
2750 }
2751
2752 core_initcall(net_inuse_init);
2753 #else
2754 static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2755
2756 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2757 {
2758         __this_cpu_add(prot_inuse.val[prot->inuse_idx], val);
2759 }
2760 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2761
2762 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2763 {
2764         int cpu, idx = prot->inuse_idx;
2765         int res = 0;
2766
2767         for_each_possible_cpu(cpu)
2768                 res += per_cpu(prot_inuse, cpu).val[idx];
2769
2770         return res >= 0 ? res : 0;
2771 }
2772 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2773 #endif
2774
2775 static void assign_proto_idx(struct proto *prot)
2776 {
2777         prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2778
2779         if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
2780                 pr_err("PROTO_INUSE_NR exhausted\n");
2781                 return;
2782         }
2783
2784         set_bit(prot->inuse_idx, proto_inuse_idx);
2785 }
2786
2787 static void release_proto_idx(struct proto *prot)
2788 {
2789         if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2790                 clear_bit(prot->inuse_idx, proto_inuse_idx);
2791 }
2792 #else
2793 static inline void assign_proto_idx(struct proto *prot)
2794 {
2795 }
2796
2797 static inline void release_proto_idx(struct proto *prot)
2798 {
2799 }
2800 #endif
2801
2802 static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
2803 {
2804         if (!rsk_prot)
2805                 return;
2806         kfree(rsk_prot->slab_name);
2807         rsk_prot->slab_name = NULL;
2808         kmem_cache_destroy(rsk_prot->slab);
2809         rsk_prot->slab = NULL;
2810 }
2811
2812 static int req_prot_init(const struct proto *prot)
2813 {
2814         struct request_sock_ops *rsk_prot = prot->rsk_prot;
2815
2816         if (!rsk_prot)
2817                 return 0;
2818
2819         rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
2820                                         prot->name);
2821         if (!rsk_prot->slab_name)
2822                 return -ENOMEM;
2823
2824         rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
2825                                            rsk_prot->obj_size, 0,
2826                                            prot->slab_flags, NULL);
2827
2828         if (!rsk_prot->slab) {
2829                 pr_crit("%s: Can't create request sock SLAB cache!\n",
2830                         prot->name);
2831                 return -ENOMEM;
2832         }
2833         return 0;
2834 }
2835
2836 int proto_register(struct proto *prot, int alloc_slab)
2837 {
2838         if (alloc_slab) {
2839                 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
2840                                         SLAB_HWCACHE_ALIGN | prot->slab_flags,
2841                                         NULL);
2842
2843                 if (prot->slab == NULL) {
2844                         pr_crit("%s: Can't create sock SLAB cache!\n",
2845                                 prot->name);
2846                         goto out;
2847                 }
2848
2849                 if (req_prot_init(prot))
2850                         goto out_free_request_sock_slab;
2851
2852                 if (prot->twsk_prot != NULL) {
2853                         prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
2854
2855                         if (prot->twsk_prot->twsk_slab_name == NULL)
2856                                 goto out_free_request_sock_slab;
2857
2858                         prot->twsk_prot->twsk_slab =
2859                                 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
2860                                                   prot->twsk_prot->twsk_obj_size,
2861                                                   0,
2862                                                   prot->slab_flags,
2863                                                   NULL);
2864                         if (prot->twsk_prot->twsk_slab == NULL)
2865                                 goto out_free_timewait_sock_slab_name;
2866                 }
2867         }
2868
2869         mutex_lock(&proto_list_mutex);
2870         list_add(&prot->node, &proto_list);
2871         assign_proto_idx(prot);
2872         mutex_unlock(&proto_list_mutex);
2873         return 0;
2874
2875 out_free_timewait_sock_slab_name:
2876         kfree(prot->twsk_prot->twsk_slab_name);
2877 out_free_request_sock_slab:
2878         req_prot_cleanup(prot->rsk_prot);
2879
2880         kmem_cache_destroy(prot->slab);
2881         prot->slab = NULL;
2882 out:
2883         return -ENOBUFS;
2884 }
2885 EXPORT_SYMBOL(proto_register);
2886
2887 void proto_unregister(struct proto *prot)
2888 {
2889         mutex_lock(&proto_list_mutex);
2890         release_proto_idx(prot);
2891         list_del(&prot->node);
2892         mutex_unlock(&proto_list_mutex);
2893
2894         kmem_cache_destroy(prot->slab);
2895         prot->slab = NULL;
2896
2897         req_prot_cleanup(prot->rsk_prot);
2898
2899         if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
2900                 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
2901                 kfree(prot->twsk_prot->twsk_slab_name);
2902                 prot->twsk_prot->twsk_slab = NULL;
2903         }
2904 }
2905 EXPORT_SYMBOL(proto_unregister);
2906
2907 #ifdef CONFIG_PROC_FS
2908 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
2909         __acquires(proto_list_mutex)
2910 {
2911         mutex_lock(&proto_list_mutex);
2912         return seq_list_start_head(&proto_list, *pos);
2913 }
2914
2915 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2916 {
2917         return seq_list_next(v, &proto_list, pos);
2918 }
2919
2920 static void proto_seq_stop(struct seq_file *seq, void *v)
2921         __releases(proto_list_mutex)
2922 {
2923         mutex_unlock(&proto_list_mutex);
2924 }
2925
2926 static char proto_method_implemented(const void *method)
2927 {
2928         return method == NULL ? 'n' : 'y';
2929 }
2930 static long sock_prot_memory_allocated(struct proto *proto)
2931 {
2932         return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
2933 }
2934
2935 static char *sock_prot_memory_pressure(struct proto *proto)
2936 {
2937         return proto->memory_pressure != NULL ?
2938         proto_memory_pressure(proto) ? "yes" : "no" : "NI";
2939 }
2940
2941 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
2942 {
2943
2944         seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
2945                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
2946                    proto->name,
2947                    proto->obj_size,
2948                    sock_prot_inuse_get(seq_file_net(seq), proto),
2949                    sock_prot_memory_allocated(proto),
2950                    sock_prot_memory_pressure(proto),
2951                    proto->max_header,
2952                    proto->slab == NULL ? "no" : "yes",
2953                    module_name(proto->owner),
2954                    proto_method_implemented(proto->close),
2955                    proto_method_implemented(proto->connect),
2956                    proto_method_implemented(proto->disconnect),
2957                    proto_method_implemented(proto->accept),
2958                    proto_method_implemented(proto->ioctl),
2959                    proto_method_implemented(proto->init),
2960                    proto_method_implemented(proto->destroy),
2961                    proto_method_implemented(proto->shutdown),
2962                    proto_method_implemented(proto->setsockopt),
2963                    proto_method_implemented(proto->getsockopt),
2964                    proto_method_implemented(proto->sendmsg),
2965                    proto_method_implemented(proto->recvmsg),
2966                    proto_method_implemented(proto->sendpage),
2967                    proto_method_implemented(proto->bind),
2968                    proto_method_implemented(proto->backlog_rcv),
2969                    proto_method_implemented(proto->hash),
2970                    proto_method_implemented(proto->unhash),
2971                    proto_method_implemented(proto->get_port),
2972                    proto_method_implemented(proto->enter_memory_pressure));
2973 }
2974
2975 static int proto_seq_show(struct seq_file *seq, void *v)
2976 {
2977         if (v == &proto_list)
2978                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
2979                            "protocol",
2980                            "size",
2981                            "sockets",
2982                            "memory",
2983                            "press",
2984                            "maxhdr",
2985                            "slab",
2986                            "module",
2987                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
2988         else
2989                 proto_seq_printf(seq, list_entry(v, struct proto, node));
2990         return 0;
2991 }
2992
2993 static const struct seq_operations proto_seq_ops = {
2994         .start  = proto_seq_start,
2995         .next   = proto_seq_next,
2996         .stop   = proto_seq_stop,
2997         .show   = proto_seq_show,
2998 };
2999
3000 static int proto_seq_open(struct inode *inode, struct file *file)
3001 {
3002         return seq_open_net(inode, file, &proto_seq_ops,
3003                             sizeof(struct seq_net_private));
3004 }
3005
3006 static const struct file_operations proto_seq_fops = {
3007         .owner          = THIS_MODULE,
3008         .open           = proto_seq_open,
3009         .read           = seq_read,
3010         .llseek         = seq_lseek,
3011         .release        = seq_release_net,
3012 };
3013
3014 static __net_init int proto_init_net(struct net *net)
3015 {
3016         if (!proc_create("protocols", S_IRUGO, net->proc_net, &proto_seq_fops))
3017                 return -ENOMEM;
3018
3019         return 0;
3020 }
3021
3022 static __net_exit void proto_exit_net(struct net *net)
3023 {
3024         remove_proc_entry("protocols", net->proc_net);
3025 }
3026
3027
3028 static __net_initdata struct pernet_operations proto_net_ops = {
3029         .init = proto_init_net,
3030         .exit = proto_exit_net,
3031 };
3032
3033 static int __init proto_init(void)
3034 {
3035         return register_pernet_subsys(&proto_net_ops);
3036 }
3037
3038 subsys_initcall(proto_init);
3039
3040 #endif /* PROC_FS */