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