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