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