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                         sk_free_unlock_clone(newsk);
1543                         newsk = NULL;
1544                         goto out;
1545                 }
1546                 RCU_INIT_POINTER(newsk->sk_reuseport_cb, NULL);
1547
1548                 newsk->sk_err      = 0;
1549                 newsk->sk_err_soft = 0;
1550                 newsk->sk_priority = 0;
1551                 newsk->sk_incoming_cpu = raw_smp_processor_id();
1552                 atomic64_set(&newsk->sk_cookie, 0);
1553
1554                 mem_cgroup_sk_alloc(newsk);
1555                 cgroup_sk_alloc(&newsk->sk_cgrp_data);
1556
1557                 /*
1558                  * Before updating sk_refcnt, we must commit prior changes to memory
1559                  * (Documentation/RCU/rculist_nulls.txt for details)
1560                  */
1561                 smp_wmb();
1562                 atomic_set(&newsk->sk_refcnt, 2);
1563
1564                 /*
1565                  * Increment the counter in the same struct proto as the master
1566                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1567                  * is the same as sk->sk_prot->socks, as this field was copied
1568                  * with memcpy).
1569                  *
1570                  * This _changes_ the previous behaviour, where
1571                  * tcp_create_openreq_child always was incrementing the
1572                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1573                  * to be taken into account in all callers. -acme
1574                  */
1575                 sk_refcnt_debug_inc(newsk);
1576                 sk_set_socket(newsk, NULL);
1577                 newsk->sk_wq = NULL;
1578
1579                 if (newsk->sk_prot->sockets_allocated)
1580                         sk_sockets_allocated_inc(newsk);
1581
1582                 if (sock_needs_netstamp(sk) &&
1583                     newsk->sk_flags & SK_FLAGS_TIMESTAMP)
1584                         net_enable_timestamp();
1585         }
1586 out:
1587         return newsk;
1588 }
1589 EXPORT_SYMBOL_GPL(sk_clone_lock);
1590
1591 void sk_free_unlock_clone(struct sock *sk)
1592 {
1593         /* It is still raw copy of parent, so invalidate
1594          * destructor and make plain sk_free() */
1595         sk->sk_destruct = NULL;
1596         bh_unlock_sock(sk);
1597         sk_free(sk);
1598 }
1599 EXPORT_SYMBOL_GPL(sk_free_unlock_clone);
1600
1601 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1602 {
1603         u32 max_segs = 1;
1604
1605         sk_dst_set(sk, dst);
1606         sk->sk_route_caps = dst->dev->features;
1607         if (sk->sk_route_caps & NETIF_F_GSO)
1608                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1609         sk->sk_route_caps &= ~sk->sk_route_nocaps;
1610         if (sk_can_gso(sk)) {
1611                 if (dst->header_len) {
1612                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1613                 } else {
1614                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1615                         sk->sk_gso_max_size = dst->dev->gso_max_size;
1616                         max_segs = max_t(u32, dst->dev->gso_max_segs, 1);
1617                 }
1618         }
1619         sk->sk_gso_max_segs = max_segs;
1620 }
1621 EXPORT_SYMBOL_GPL(sk_setup_caps);
1622
1623 /*
1624  *      Simple resource managers for sockets.
1625  */
1626
1627
1628 /*
1629  * Write buffer destructor automatically called from kfree_skb.
1630  */
1631 void sock_wfree(struct sk_buff *skb)
1632 {
1633         struct sock *sk = skb->sk;
1634         unsigned int len = skb->truesize;
1635
1636         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1637                 /*
1638                  * Keep a reference on sk_wmem_alloc, this will be released
1639                  * after sk_write_space() call
1640                  */
1641                 atomic_sub(len - 1, &sk->sk_wmem_alloc);
1642                 sk->sk_write_space(sk);
1643                 len = 1;
1644         }
1645         /*
1646          * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1647          * could not do because of in-flight packets
1648          */
1649         if (atomic_sub_and_test(len, &sk->sk_wmem_alloc))
1650                 __sk_free(sk);
1651 }
1652 EXPORT_SYMBOL(sock_wfree);
1653
1654 /* This variant of sock_wfree() is used by TCP,
1655  * since it sets SOCK_USE_WRITE_QUEUE.
1656  */
1657 void __sock_wfree(struct sk_buff *skb)
1658 {
1659         struct sock *sk = skb->sk;
1660
1661         if (atomic_sub_and_test(skb->truesize, &sk->sk_wmem_alloc))
1662                 __sk_free(sk);
1663 }
1664
1665 void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1666 {
1667         skb_orphan(skb);
1668         skb->sk = sk;
1669 #ifdef CONFIG_INET
1670         if (unlikely(!sk_fullsock(sk))) {
1671                 skb->destructor = sock_edemux;
1672                 sock_hold(sk);
1673                 return;
1674         }
1675 #endif
1676         skb->destructor = sock_wfree;
1677         skb_set_hash_from_sk(skb, sk);
1678         /*
1679          * We used to take a refcount on sk, but following operation
1680          * is enough to guarantee sk_free() wont free this sock until
1681          * all in-flight packets are completed
1682          */
1683         atomic_add(skb->truesize, &sk->sk_wmem_alloc);
1684 }
1685 EXPORT_SYMBOL(skb_set_owner_w);
1686
1687 /* This helper is used by netem, as it can hold packets in its
1688  * delay queue. We want to allow the owner socket to send more
1689  * packets, as if they were already TX completed by a typical driver.
1690  * But we also want to keep skb->sk set because some packet schedulers
1691  * rely on it (sch_fq for example). So we set skb->truesize to a small
1692  * amount (1) and decrease sk_wmem_alloc accordingly.
1693  */
1694 void skb_orphan_partial(struct sk_buff *skb)
1695 {
1696         /* If this skb is a TCP pure ACK or already went here,
1697          * we have nothing to do. 2 is already a very small truesize.
1698          */
1699         if (skb->truesize <= 2)
1700                 return;
1701
1702         /* TCP stack sets skb->ooo_okay based on sk_wmem_alloc,
1703          * so we do not completely orphan skb, but transfert all
1704          * accounted bytes but one, to avoid unexpected reorders.
1705          */
1706         if (skb->destructor == sock_wfree
1707 #ifdef CONFIG_INET
1708             || skb->destructor == tcp_wfree
1709 #endif
1710                 ) {
1711                 atomic_sub(skb->truesize - 1, &skb->sk->sk_wmem_alloc);
1712                 skb->truesize = 1;
1713         } else {
1714                 skb_orphan(skb);
1715         }
1716 }
1717 EXPORT_SYMBOL(skb_orphan_partial);
1718
1719 /*
1720  * Read buffer destructor automatically called from kfree_skb.
1721  */
1722 void sock_rfree(struct sk_buff *skb)
1723 {
1724         struct sock *sk = skb->sk;
1725         unsigned int len = skb->truesize;
1726
1727         atomic_sub(len, &sk->sk_rmem_alloc);
1728         sk_mem_uncharge(sk, len);
1729 }
1730 EXPORT_SYMBOL(sock_rfree);
1731
1732 /*
1733  * Buffer destructor for skbs that are not used directly in read or write
1734  * path, e.g. for error handler skbs. Automatically called from kfree_skb.
1735  */
1736 void sock_efree(struct sk_buff *skb)
1737 {
1738         sock_put(skb->sk);
1739 }
1740 EXPORT_SYMBOL(sock_efree);
1741
1742 kuid_t sock_i_uid(struct sock *sk)
1743 {
1744         kuid_t uid;
1745
1746         read_lock_bh(&sk->sk_callback_lock);
1747         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
1748         read_unlock_bh(&sk->sk_callback_lock);
1749         return uid;
1750 }
1751 EXPORT_SYMBOL(sock_i_uid);
1752
1753 unsigned long sock_i_ino(struct sock *sk)
1754 {
1755         unsigned long ino;
1756
1757         read_lock_bh(&sk->sk_callback_lock);
1758         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1759         read_unlock_bh(&sk->sk_callback_lock);
1760         return ino;
1761 }
1762 EXPORT_SYMBOL(sock_i_ino);
1763
1764 /*
1765  * Allocate a skb from the socket's send buffer.
1766  */
1767 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1768                              gfp_t priority)
1769 {
1770         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1771                 struct sk_buff *skb = alloc_skb(size, priority);
1772                 if (skb) {
1773                         skb_set_owner_w(skb, sk);
1774                         return skb;
1775                 }
1776         }
1777         return NULL;
1778 }
1779 EXPORT_SYMBOL(sock_wmalloc);
1780
1781 /*
1782  * Allocate a memory block from the socket's option memory buffer.
1783  */
1784 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1785 {
1786         if ((unsigned int)size <= sysctl_optmem_max &&
1787             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1788                 void *mem;
1789                 /* First do the add, to avoid the race if kmalloc
1790                  * might sleep.
1791                  */
1792                 atomic_add(size, &sk->sk_omem_alloc);
1793                 mem = kmalloc(size, priority);
1794                 if (mem)
1795                         return mem;
1796                 atomic_sub(size, &sk->sk_omem_alloc);
1797         }
1798         return NULL;
1799 }
1800 EXPORT_SYMBOL(sock_kmalloc);
1801
1802 /* Free an option memory block. Note, we actually want the inline
1803  * here as this allows gcc to detect the nullify and fold away the
1804  * condition entirely.
1805  */
1806 static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
1807                                   const bool nullify)
1808 {
1809         if (WARN_ON_ONCE(!mem))
1810                 return;
1811         if (nullify)
1812                 kzfree(mem);
1813         else
1814                 kfree(mem);
1815         atomic_sub(size, &sk->sk_omem_alloc);
1816 }
1817
1818 void sock_kfree_s(struct sock *sk, void *mem, int size)
1819 {
1820         __sock_kfree_s(sk, mem, size, false);
1821 }
1822 EXPORT_SYMBOL(sock_kfree_s);
1823
1824 void sock_kzfree_s(struct sock *sk, void *mem, int size)
1825 {
1826         __sock_kfree_s(sk, mem, size, true);
1827 }
1828 EXPORT_SYMBOL(sock_kzfree_s);
1829
1830 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1831    I think, these locks should be removed for datagram sockets.
1832  */
1833 static long sock_wait_for_wmem(struct sock *sk, long timeo)
1834 {
1835         DEFINE_WAIT(wait);
1836
1837         sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
1838         for (;;) {
1839                 if (!timeo)
1840                         break;
1841                 if (signal_pending(current))
1842                         break;
1843                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1844                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1845                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1846                         break;
1847                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1848                         break;
1849                 if (sk->sk_err)
1850                         break;
1851                 timeo = schedule_timeout(timeo);
1852         }
1853         finish_wait(sk_sleep(sk), &wait);
1854         return timeo;
1855 }
1856
1857
1858 /*
1859  *      Generic send/receive buffer handlers
1860  */
1861
1862 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1863                                      unsigned long data_len, int noblock,
1864                                      int *errcode, int max_page_order)
1865 {
1866         struct sk_buff *skb;
1867         long timeo;
1868         int err;
1869
1870         timeo = sock_sndtimeo(sk, noblock);
1871         for (;;) {
1872                 err = sock_error(sk);
1873                 if (err != 0)
1874                         goto failure;
1875
1876                 err = -EPIPE;
1877                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1878                         goto failure;
1879
1880                 if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
1881                         break;
1882
1883                 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
1884                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1885                 err = -EAGAIN;
1886                 if (!timeo)
1887                         goto failure;
1888                 if (signal_pending(current))
1889                         goto interrupted;
1890                 timeo = sock_wait_for_wmem(sk, timeo);
1891         }
1892         skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
1893                                    errcode, sk->sk_allocation);
1894         if (skb)
1895                 skb_set_owner_w(skb, sk);
1896         return skb;
1897
1898 interrupted:
1899         err = sock_intr_errno(timeo);
1900 failure:
1901         *errcode = err;
1902         return NULL;
1903 }
1904 EXPORT_SYMBOL(sock_alloc_send_pskb);
1905
1906 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1907                                     int noblock, int *errcode)
1908 {
1909         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode, 0);
1910 }
1911 EXPORT_SYMBOL(sock_alloc_send_skb);
1912
1913 int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
1914                      struct sockcm_cookie *sockc)
1915 {
1916         u32 tsflags;
1917
1918         switch (cmsg->cmsg_type) {
1919         case SO_MARK:
1920                 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
1921                         return -EPERM;
1922                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
1923                         return -EINVAL;
1924                 sockc->mark = *(u32 *)CMSG_DATA(cmsg);
1925                 break;
1926         case SO_TIMESTAMPING:
1927                 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
1928                         return -EINVAL;
1929
1930                 tsflags = *(u32 *)CMSG_DATA(cmsg);
1931                 if (tsflags & ~SOF_TIMESTAMPING_TX_RECORD_MASK)
1932                         return -EINVAL;
1933
1934                 sockc->tsflags &= ~SOF_TIMESTAMPING_TX_RECORD_MASK;
1935                 sockc->tsflags |= tsflags;
1936                 break;
1937         /* SCM_RIGHTS and SCM_CREDENTIALS are semantically in SOL_UNIX. */
1938         case SCM_RIGHTS:
1939         case SCM_CREDENTIALS:
1940                 break;
1941         default:
1942                 return -EINVAL;
1943         }
1944         return 0;
1945 }
1946 EXPORT_SYMBOL(__sock_cmsg_send);
1947
1948 int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
1949                    struct sockcm_cookie *sockc)
1950 {
1951         struct cmsghdr *cmsg;
1952         int ret;
1953
1954         for_each_cmsghdr(cmsg, msg) {
1955                 if (!CMSG_OK(msg, cmsg))
1956                         return -EINVAL;
1957                 if (cmsg->cmsg_level != SOL_SOCKET)
1958                         continue;
1959                 ret = __sock_cmsg_send(sk, msg, cmsg, sockc);
1960                 if (ret)
1961                         return ret;
1962         }
1963         return 0;
1964 }
1965 EXPORT_SYMBOL(sock_cmsg_send);
1966
1967 /* On 32bit arches, an skb frag is limited to 2^15 */
1968 #define SKB_FRAG_PAGE_ORDER     get_order(32768)
1969
1970 /**
1971  * skb_page_frag_refill - check that a page_frag contains enough room
1972  * @sz: minimum size of the fragment we want to get
1973  * @pfrag: pointer to page_frag
1974  * @gfp: priority for memory allocation
1975  *
1976  * Note: While this allocator tries to use high order pages, there is
1977  * no guarantee that allocations succeed. Therefore, @sz MUST be
1978  * less or equal than PAGE_SIZE.
1979  */
1980 bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
1981 {
1982         if (pfrag->page) {
1983                 if (page_ref_count(pfrag->page) == 1) {
1984                         pfrag->offset = 0;
1985                         return true;
1986                 }
1987                 if (pfrag->offset + sz <= pfrag->size)
1988                         return true;
1989                 put_page(pfrag->page);
1990         }
1991
1992         pfrag->offset = 0;
1993         if (SKB_FRAG_PAGE_ORDER) {
1994                 /* Avoid direct reclaim but allow kswapd to wake */
1995                 pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) |
1996                                           __GFP_COMP | __GFP_NOWARN |
1997                                           __GFP_NORETRY,
1998                                           SKB_FRAG_PAGE_ORDER);
1999                 if (likely(pfrag->page)) {
2000                         pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
2001                         return true;
2002                 }
2003         }
2004         pfrag->page = alloc_page(gfp);
2005         if (likely(pfrag->page)) {
2006                 pfrag->size = PAGE_SIZE;
2007                 return true;
2008         }
2009         return false;
2010 }
2011 EXPORT_SYMBOL(skb_page_frag_refill);
2012
2013 bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
2014 {
2015         if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
2016                 return true;
2017
2018         sk_enter_memory_pressure(sk);
2019         sk_stream_moderate_sndbuf(sk);
2020         return false;
2021 }
2022 EXPORT_SYMBOL(sk_page_frag_refill);
2023
2024 static void __lock_sock(struct sock *sk)
2025         __releases(&sk->sk_lock.slock)
2026         __acquires(&sk->sk_lock.slock)
2027 {
2028         DEFINE_WAIT(wait);
2029
2030         for (;;) {
2031                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
2032                                         TASK_UNINTERRUPTIBLE);
2033                 spin_unlock_bh(&sk->sk_lock.slock);
2034                 schedule();
2035                 spin_lock_bh(&sk->sk_lock.slock);
2036                 if (!sock_owned_by_user(sk))
2037                         break;
2038         }
2039         finish_wait(&sk->sk_lock.wq, &wait);
2040 }
2041
2042 static void __release_sock(struct sock *sk)
2043         __releases(&sk->sk_lock.slock)
2044         __acquires(&sk->sk_lock.slock)
2045 {
2046         struct sk_buff *skb, *next;
2047
2048         while ((skb = sk->sk_backlog.head) != NULL) {
2049                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
2050
2051                 spin_unlock_bh(&sk->sk_lock.slock);
2052
2053                 do {
2054                         next = skb->next;
2055                         prefetch(next);
2056                         WARN_ON_ONCE(skb_dst_is_noref(skb));
2057                         skb->next = NULL;
2058                         sk_backlog_rcv(sk, skb);
2059
2060                         cond_resched();
2061
2062                         skb = next;
2063                 } while (skb != NULL);
2064
2065                 spin_lock_bh(&sk->sk_lock.slock);
2066         }
2067
2068         /*
2069          * Doing the zeroing here guarantee we can not loop forever
2070          * while a wild producer attempts to flood us.
2071          */
2072         sk->sk_backlog.len = 0;
2073 }
2074
2075 void __sk_flush_backlog(struct sock *sk)
2076 {
2077         spin_lock_bh(&sk->sk_lock.slock);
2078         __release_sock(sk);
2079         spin_unlock_bh(&sk->sk_lock.slock);
2080 }
2081
2082 /**
2083  * sk_wait_data - wait for data to arrive at sk_receive_queue
2084  * @sk:    sock to wait on
2085  * @timeo: for how long
2086  * @skb:   last skb seen on sk_receive_queue
2087  *
2088  * Now socket state including sk->sk_err is changed only under lock,
2089  * hence we may omit checks after joining wait queue.
2090  * We check receive queue before schedule() only as optimization;
2091  * it is very likely that release_sock() added new data.
2092  */
2093 int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
2094 {
2095         DEFINE_WAIT_FUNC(wait, woken_wake_function);
2096         int rc;
2097
2098         add_wait_queue(sk_sleep(sk), &wait);
2099         sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2100         rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
2101         sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2102         remove_wait_queue(sk_sleep(sk), &wait);
2103         return rc;
2104 }
2105 EXPORT_SYMBOL(sk_wait_data);
2106
2107 /**
2108  *      __sk_mem_raise_allocated - increase memory_allocated
2109  *      @sk: socket
2110  *      @size: memory size to allocate
2111  *      @amt: pages to allocate
2112  *      @kind: allocation type
2113  *
2114  *      Similar to __sk_mem_schedule(), but does not update sk_forward_alloc
2115  */
2116 int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
2117 {
2118         struct proto *prot = sk->sk_prot;
2119         long allocated = sk_memory_allocated_add(sk, amt);
2120
2121         if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
2122             !mem_cgroup_charge_skmem(sk->sk_memcg, amt))
2123                 goto suppress_allocation;
2124
2125         /* Under limit. */
2126         if (allocated <= sk_prot_mem_limits(sk, 0)) {
2127                 sk_leave_memory_pressure(sk);
2128                 return 1;
2129         }
2130
2131         /* Under pressure. */
2132         if (allocated > sk_prot_mem_limits(sk, 1))
2133                 sk_enter_memory_pressure(sk);
2134
2135         /* Over hard limit. */
2136         if (allocated > sk_prot_mem_limits(sk, 2))
2137                 goto suppress_allocation;
2138
2139         /* guarantee minimum buffer size under pressure */
2140         if (kind == SK_MEM_RECV) {
2141                 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
2142                         return 1;
2143
2144         } else { /* SK_MEM_SEND */
2145                 if (sk->sk_type == SOCK_STREAM) {
2146                         if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
2147                                 return 1;
2148                 } else if (atomic_read(&sk->sk_wmem_alloc) <
2149                            prot->sysctl_wmem[0])
2150                                 return 1;
2151         }
2152
2153         if (sk_has_memory_pressure(sk)) {
2154                 int alloc;
2155
2156                 if (!sk_under_memory_pressure(sk))
2157                         return 1;
2158                 alloc = sk_sockets_allocated_read_positive(sk);
2159                 if (sk_prot_mem_limits(sk, 2) > alloc *
2160                     sk_mem_pages(sk->sk_wmem_queued +
2161                                  atomic_read(&sk->sk_rmem_alloc) +
2162                                  sk->sk_forward_alloc))
2163                         return 1;
2164         }
2165
2166 suppress_allocation:
2167
2168         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
2169                 sk_stream_moderate_sndbuf(sk);
2170
2171                 /* Fail only if socket is _under_ its sndbuf.
2172                  * In this case we cannot block, so that we have to fail.
2173                  */
2174                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
2175                         return 1;
2176         }
2177
2178         trace_sock_exceed_buf_limit(sk, prot, allocated);
2179
2180         sk_memory_allocated_sub(sk, amt);
2181
2182         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
2183                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amt);
2184
2185         return 0;
2186 }
2187 EXPORT_SYMBOL(__sk_mem_raise_allocated);
2188
2189 /**
2190  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
2191  *      @sk: socket
2192  *      @size: memory size to allocate
2193  *      @kind: allocation type
2194  *
2195  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
2196  *      rmem allocation. This function assumes that protocols which have
2197  *      memory_pressure use sk_wmem_queued as write buffer accounting.
2198  */
2199 int __sk_mem_schedule(struct sock *sk, int size, int kind)
2200 {
2201         int ret, amt = sk_mem_pages(size);
2202
2203         sk->sk_forward_alloc += amt << SK_MEM_QUANTUM_SHIFT;
2204         ret = __sk_mem_raise_allocated(sk, size, amt, kind);
2205         if (!ret)
2206                 sk->sk_forward_alloc -= amt << SK_MEM_QUANTUM_SHIFT;
2207         return ret;
2208 }
2209 EXPORT_SYMBOL(__sk_mem_schedule);
2210
2211 /**
2212  *      __sk_mem_reduce_allocated - reclaim memory_allocated
2213  *      @sk: socket
2214  *      @amount: number of quanta
2215  *
2216  *      Similar to __sk_mem_reclaim(), but does not update sk_forward_alloc
2217  */
2218 void __sk_mem_reduce_allocated(struct sock *sk, int amount)
2219 {
2220         sk_memory_allocated_sub(sk, amount);
2221
2222         if (mem_cgroup_sockets_enabled && sk->sk_memcg)
2223                 mem_cgroup_uncharge_skmem(sk->sk_memcg, amount);
2224
2225         if (sk_under_memory_pressure(sk) &&
2226             (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
2227                 sk_leave_memory_pressure(sk);
2228 }
2229 EXPORT_SYMBOL(__sk_mem_reduce_allocated);
2230
2231 /**
2232  *      __sk_mem_reclaim - reclaim sk_forward_alloc and memory_allocated
2233  *      @sk: socket
2234  *      @amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)
2235  */
2236 void __sk_mem_reclaim(struct sock *sk, int amount)
2237 {
2238         amount >>= SK_MEM_QUANTUM_SHIFT;
2239         sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
2240         __sk_mem_reduce_allocated(sk, amount);
2241 }
2242 EXPORT_SYMBOL(__sk_mem_reclaim);
2243
2244 int sk_set_peek_off(struct sock *sk, int val)
2245 {
2246         if (val < 0)
2247                 return -EINVAL;
2248
2249         sk->sk_peek_off = val;
2250         return 0;
2251 }
2252 EXPORT_SYMBOL_GPL(sk_set_peek_off);
2253
2254 /*
2255  * Set of default routines for initialising struct proto_ops when
2256  * the protocol does not support a particular function. In certain
2257  * cases where it makes no sense for a protocol to have a "do nothing"
2258  * function, some default processing is provided.
2259  */
2260
2261 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
2262 {
2263         return -EOPNOTSUPP;
2264 }
2265 EXPORT_SYMBOL(sock_no_bind);
2266
2267 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
2268                     int len, int flags)
2269 {
2270         return -EOPNOTSUPP;
2271 }
2272 EXPORT_SYMBOL(sock_no_connect);
2273
2274 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
2275 {
2276         return -EOPNOTSUPP;
2277 }
2278 EXPORT_SYMBOL(sock_no_socketpair);
2279
2280 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
2281 {
2282         return -EOPNOTSUPP;
2283 }
2284 EXPORT_SYMBOL(sock_no_accept);
2285
2286 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
2287                     int *len, int peer)
2288 {
2289         return -EOPNOTSUPP;
2290 }
2291 EXPORT_SYMBOL(sock_no_getname);
2292
2293 unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
2294 {
2295         return 0;
2296 }
2297 EXPORT_SYMBOL(sock_no_poll);
2298
2299 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2300 {
2301         return -EOPNOTSUPP;
2302 }
2303 EXPORT_SYMBOL(sock_no_ioctl);
2304
2305 int sock_no_listen(struct socket *sock, int backlog)
2306 {
2307         return -EOPNOTSUPP;
2308 }
2309 EXPORT_SYMBOL(sock_no_listen);
2310
2311 int sock_no_shutdown(struct socket *sock, int how)
2312 {
2313         return -EOPNOTSUPP;
2314 }
2315 EXPORT_SYMBOL(sock_no_shutdown);
2316
2317 int sock_no_setsockopt(struct socket *sock, int level, int optname,
2318                     char __user *optval, unsigned int optlen)
2319 {
2320         return -EOPNOTSUPP;
2321 }
2322 EXPORT_SYMBOL(sock_no_setsockopt);
2323
2324 int sock_no_getsockopt(struct socket *sock, int level, int optname,
2325                     char __user *optval, int __user *optlen)
2326 {
2327         return -EOPNOTSUPP;
2328 }
2329 EXPORT_SYMBOL(sock_no_getsockopt);
2330
2331 int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
2332 {
2333         return -EOPNOTSUPP;
2334 }
2335 EXPORT_SYMBOL(sock_no_sendmsg);
2336
2337 int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
2338                     int flags)
2339 {
2340         return -EOPNOTSUPP;
2341 }
2342 EXPORT_SYMBOL(sock_no_recvmsg);
2343
2344 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
2345 {
2346         /* Mirror missing mmap method error code */
2347         return -ENODEV;
2348 }
2349 EXPORT_SYMBOL(sock_no_mmap);
2350
2351 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
2352 {
2353         ssize_t res;
2354         struct msghdr msg = {.msg_flags = flags};
2355         struct kvec iov;
2356         char *kaddr = kmap(page);
2357         iov.iov_base = kaddr + offset;
2358         iov.iov_len = size;
2359         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
2360         kunmap(page);
2361         return res;
2362 }
2363 EXPORT_SYMBOL(sock_no_sendpage);
2364
2365 /*
2366  *      Default Socket Callbacks
2367  */
2368
2369 static void sock_def_wakeup(struct sock *sk)
2370 {
2371         struct socket_wq *wq;
2372
2373         rcu_read_lock();
2374         wq = rcu_dereference(sk->sk_wq);
2375         if (skwq_has_sleeper(wq))
2376                 wake_up_interruptible_all(&wq->wait);
2377         rcu_read_unlock();
2378 }
2379
2380 static void sock_def_error_report(struct sock *sk)
2381 {
2382         struct socket_wq *wq;
2383
2384         rcu_read_lock();
2385         wq = rcu_dereference(sk->sk_wq);
2386         if (skwq_has_sleeper(wq))
2387                 wake_up_interruptible_poll(&wq->wait, POLLERR);
2388         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
2389         rcu_read_unlock();
2390 }
2391
2392 static void sock_def_readable(struct sock *sk)
2393 {
2394         struct socket_wq *wq;
2395
2396         rcu_read_lock();
2397         wq = rcu_dereference(sk->sk_wq);
2398         if (skwq_has_sleeper(wq))
2399                 wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
2400                                                 POLLRDNORM | POLLRDBAND);
2401         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
2402         rcu_read_unlock();
2403 }
2404
2405 static void sock_def_write_space(struct sock *sk)
2406 {
2407         struct socket_wq *wq;
2408
2409         rcu_read_lock();
2410
2411         /* Do not wake up a writer until he can make "significant"
2412          * progress.  --DaveM
2413          */
2414         if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
2415                 wq = rcu_dereference(sk->sk_wq);
2416                 if (skwq_has_sleeper(wq))
2417                         wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
2418                                                 POLLWRNORM | POLLWRBAND);
2419
2420                 /* Should agree with poll, otherwise some programs break */
2421                 if (sock_writeable(sk))
2422                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
2423         }
2424
2425         rcu_read_unlock();
2426 }
2427
2428 static void sock_def_destruct(struct sock *sk)
2429 {
2430 }
2431
2432 void sk_send_sigurg(struct sock *sk)
2433 {
2434         if (sk->sk_socket && sk->sk_socket->file)
2435                 if (send_sigurg(&sk->sk_socket->file->f_owner))
2436                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
2437 }
2438 EXPORT_SYMBOL(sk_send_sigurg);
2439
2440 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
2441                     unsigned long expires)
2442 {
2443         if (!mod_timer(timer, expires))
2444                 sock_hold(sk);
2445 }
2446 EXPORT_SYMBOL(sk_reset_timer);
2447
2448 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
2449 {
2450         if (del_timer(timer))
2451                 __sock_put(sk);
2452 }
2453 EXPORT_SYMBOL(sk_stop_timer);
2454
2455 void sock_init_data(struct socket *sock, struct sock *sk)
2456 {
2457         skb_queue_head_init(&sk->sk_receive_queue);
2458         skb_queue_head_init(&sk->sk_write_queue);
2459         skb_queue_head_init(&sk->sk_error_queue);
2460
2461         sk->sk_send_head        =       NULL;
2462
2463         init_timer(&sk->sk_timer);
2464
2465         sk->sk_allocation       =       GFP_KERNEL;
2466         sk->sk_rcvbuf           =       sysctl_rmem_default;
2467         sk->sk_sndbuf           =       sysctl_wmem_default;
2468         sk->sk_state            =       TCP_CLOSE;
2469         sk_set_socket(sk, sock);
2470
2471         sock_set_flag(sk, SOCK_ZAPPED);
2472
2473         if (sock) {
2474                 sk->sk_type     =       sock->type;
2475                 sk->sk_wq       =       sock->wq;
2476                 sock->sk        =       sk;
2477                 sk->sk_uid      =       SOCK_INODE(sock)->i_uid;
2478         } else {
2479                 sk->sk_wq       =       NULL;
2480                 sk->sk_uid      =       make_kuid(sock_net(sk)->user_ns, 0);
2481         }
2482
2483         rwlock_init(&sk->sk_callback_lock);
2484         lockdep_set_class_and_name(&sk->sk_callback_lock,
2485                         af_callback_keys + sk->sk_family,
2486                         af_family_clock_key_strings[sk->sk_family]);
2487
2488         sk->sk_state_change     =       sock_def_wakeup;
2489         sk->sk_data_ready       =       sock_def_readable;
2490         sk->sk_write_space      =       sock_def_write_space;
2491         sk->sk_error_report     =       sock_def_error_report;
2492         sk->sk_destruct         =       sock_def_destruct;
2493
2494         sk->sk_frag.page        =       NULL;
2495         sk->sk_frag.offset      =       0;
2496         sk->sk_peek_off         =       -1;
2497
2498         sk->sk_peer_pid         =       NULL;
2499         sk->sk_peer_cred        =       NULL;
2500         sk->sk_write_pending    =       0;
2501         sk->sk_rcvlowat         =       1;
2502         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
2503         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
2504
2505         sk->sk_stamp = ktime_set(-1L, 0);
2506
2507 #ifdef CONFIG_NET_RX_BUSY_POLL
2508         sk->sk_napi_id          =       0;
2509         sk->sk_ll_usec          =       sysctl_net_busy_read;
2510 #endif
2511
2512         sk->sk_max_pacing_rate = ~0U;
2513         sk->sk_pacing_rate = ~0U;
2514         sk->sk_incoming_cpu = -1;
2515         /*
2516          * Before updating sk_refcnt, we must commit prior changes to memory
2517          * (Documentation/RCU/rculist_nulls.txt for details)
2518          */
2519         smp_wmb();
2520         atomic_set(&sk->sk_refcnt, 1);
2521         atomic_set(&sk->sk_drops, 0);
2522 }
2523 EXPORT_SYMBOL(sock_init_data);
2524
2525 void lock_sock_nested(struct sock *sk, int subclass)
2526 {
2527         might_sleep();
2528         spin_lock_bh(&sk->sk_lock.slock);
2529         if (sk->sk_lock.owned)
2530                 __lock_sock(sk);
2531         sk->sk_lock.owned = 1;
2532         spin_unlock(&sk->sk_lock.slock);
2533         /*
2534          * The sk_lock has mutex_lock() semantics here:
2535          */
2536         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
2537         local_bh_enable();
2538 }
2539 EXPORT_SYMBOL(lock_sock_nested);
2540
2541 void release_sock(struct sock *sk)
2542 {
2543         spin_lock_bh(&sk->sk_lock.slock);
2544         if (sk->sk_backlog.tail)
2545                 __release_sock(sk);
2546
2547         /* Warning : release_cb() might need to release sk ownership,
2548          * ie call sock_release_ownership(sk) before us.
2549          */
2550         if (sk->sk_prot->release_cb)
2551                 sk->sk_prot->release_cb(sk);
2552
2553         sock_release_ownership(sk);
2554         if (waitqueue_active(&sk->sk_lock.wq))
2555                 wake_up(&sk->sk_lock.wq);
2556         spin_unlock_bh(&sk->sk_lock.slock);
2557 }
2558 EXPORT_SYMBOL(release_sock);
2559
2560 /**
2561  * lock_sock_fast - fast version of lock_sock
2562  * @sk: socket
2563  *
2564  * This version should be used for very small section, where process wont block
2565  * return false if fast path is taken
2566  *   sk_lock.slock locked, owned = 0, BH disabled
2567  * return true if slow path is taken
2568  *   sk_lock.slock unlocked, owned = 1, BH enabled
2569  */
2570 bool lock_sock_fast(struct sock *sk)
2571 {
2572         might_sleep();
2573         spin_lock_bh(&sk->sk_lock.slock);
2574
2575         if (!sk->sk_lock.owned)
2576                 /*
2577                  * Note : We must disable BH
2578                  */
2579                 return false;
2580
2581         __lock_sock(sk);
2582         sk->sk_lock.owned = 1;
2583         spin_unlock(&sk->sk_lock.slock);
2584         /*
2585          * The sk_lock has mutex_lock() semantics here:
2586          */
2587         mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
2588         local_bh_enable();
2589         return true;
2590 }
2591 EXPORT_SYMBOL(lock_sock_fast);
2592
2593 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
2594 {
2595         struct timeval tv;
2596         if (!sock_flag(sk, SOCK_TIMESTAMP))
2597                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2598         tv = ktime_to_timeval(sk->sk_stamp);
2599         if (tv.tv_sec == -1)
2600                 return -ENOENT;
2601         if (tv.tv_sec == 0) {
2602                 sk->sk_stamp = ktime_get_real();
2603                 tv = ktime_to_timeval(sk->sk_stamp);
2604         }
2605         return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
2606 }
2607 EXPORT_SYMBOL(sock_get_timestamp);
2608
2609 int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2610 {
2611         struct timespec ts;
2612         if (!sock_flag(sk, SOCK_TIMESTAMP))
2613                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2614         ts = ktime_to_timespec(sk->sk_stamp);
2615         if (ts.tv_sec == -1)
2616                 return -ENOENT;
2617         if (ts.tv_sec == 0) {
2618                 sk->sk_stamp = ktime_get_real();
2619                 ts = ktime_to_timespec(sk->sk_stamp);
2620         }
2621         return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2622 }
2623 EXPORT_SYMBOL(sock_get_timestampns);
2624
2625 void sock_enable_timestamp(struct sock *sk, int flag)
2626 {
2627         if (!sock_flag(sk, flag)) {
2628                 unsigned long previous_flags = sk->sk_flags;
2629
2630                 sock_set_flag(sk, flag);
2631                 /*
2632                  * we just set one of the two flags which require net
2633                  * time stamping, but time stamping might have been on
2634                  * already because of the other one
2635                  */
2636                 if (sock_needs_netstamp(sk) &&
2637                     !(previous_flags & SK_FLAGS_TIMESTAMP))
2638                         net_enable_timestamp();
2639         }
2640 }
2641
2642 int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
2643                        int level, int type)
2644 {
2645         struct sock_exterr_skb *serr;
2646         struct sk_buff *skb;
2647         int copied, err;
2648
2649         err = -EAGAIN;
2650         skb = sock_dequeue_err_skb(sk);
2651         if (skb == NULL)
2652                 goto out;
2653
2654         copied = skb->len;
2655         if (copied > len) {
2656                 msg->msg_flags |= MSG_TRUNC;
2657                 copied = len;
2658         }
2659         err = skb_copy_datagram_msg(skb, 0, msg, copied);
2660         if (err)
2661                 goto out_free_skb;
2662
2663         sock_recv_timestamp(msg, sk, skb);
2664
2665         serr = SKB_EXT_ERR(skb);
2666         put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
2667
2668         msg->msg_flags |= MSG_ERRQUEUE;
2669         err = copied;
2670
2671 out_free_skb:
2672         kfree_skb(skb);
2673 out:
2674         return err;
2675 }
2676 EXPORT_SYMBOL(sock_recv_errqueue);
2677
2678 /*
2679  *      Get a socket option on an socket.
2680  *
2681  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
2682  *      asynchronous errors should be reported by getsockopt. We assume
2683  *      this means if you specify SO_ERROR (otherwise whats the point of it).
2684  */
2685 int sock_common_getsockopt(struct socket *sock, int level, int optname,
2686                            char __user *optval, int __user *optlen)
2687 {
2688         struct sock *sk = sock->sk;
2689
2690         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2691 }
2692 EXPORT_SYMBOL(sock_common_getsockopt);
2693
2694 #ifdef CONFIG_COMPAT
2695 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
2696                                   char __user *optval, int __user *optlen)
2697 {
2698         struct sock *sk = sock->sk;
2699
2700         if (sk->sk_prot->compat_getsockopt != NULL)
2701                 return sk->sk_prot->compat_getsockopt(sk, level, optname,
2702                                                       optval, optlen);
2703         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2704 }
2705 EXPORT_SYMBOL(compat_sock_common_getsockopt);
2706 #endif
2707
2708 int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
2709                         int flags)
2710 {
2711         struct sock *sk = sock->sk;
2712         int addr_len = 0;
2713         int err;
2714
2715         err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
2716                                    flags & ~MSG_DONTWAIT, &addr_len);
2717         if (err >= 0)
2718                 msg->msg_namelen = addr_len;
2719         return err;
2720 }
2721 EXPORT_SYMBOL(sock_common_recvmsg);
2722
2723 /*
2724  *      Set socket options on an inet socket.
2725  */
2726 int sock_common_setsockopt(struct socket *sock, int level, int optname,
2727                            char __user *optval, unsigned int optlen)
2728 {
2729         struct sock *sk = sock->sk;
2730
2731         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2732 }
2733 EXPORT_SYMBOL(sock_common_setsockopt);
2734
2735 #ifdef CONFIG_COMPAT
2736 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
2737                                   char __user *optval, unsigned int optlen)
2738 {
2739         struct sock *sk = sock->sk;
2740
2741         if (sk->sk_prot->compat_setsockopt != NULL)
2742                 return sk->sk_prot->compat_setsockopt(sk, level, optname,
2743                                                       optval, optlen);
2744         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2745 }
2746 EXPORT_SYMBOL(compat_sock_common_setsockopt);
2747 #endif
2748
2749 void sk_common_release(struct sock *sk)
2750 {
2751         if (sk->sk_prot->destroy)
2752                 sk->sk_prot->destroy(sk);
2753
2754         /*
2755          * Observation: when sock_common_release is called, processes have
2756          * no access to socket. But net still has.
2757          * Step one, detach it from networking:
2758          *
2759          * A. Remove from hash tables.
2760          */
2761
2762         sk->sk_prot->unhash(sk);
2763
2764         /*
2765          * In this point socket cannot receive new packets, but it is possible
2766          * that some packets are in flight because some CPU runs receiver and
2767          * did hash table lookup before we unhashed socket. They will achieve
2768          * receive queue and will be purged by socket destructor.
2769          *
2770          * Also we still have packets pending on receive queue and probably,
2771          * our own packets waiting in device queues. sock_destroy will drain
2772          * receive queue, but transmitted packets will delay socket destruction
2773          * until the last reference will be released.
2774          */
2775
2776         sock_orphan(sk);
2777
2778         xfrm_sk_free_policy(sk);
2779
2780         sk_refcnt_debug_release(sk);
2781
2782         if (sk->sk_frag.page) {
2783                 put_page(sk->sk_frag.page);
2784                 sk->sk_frag.page = NULL;
2785         }
2786
2787         sock_put(sk);
2788 }
2789 EXPORT_SYMBOL(sk_common_release);
2790
2791 #ifdef CONFIG_PROC_FS
2792 #define PROTO_INUSE_NR  64      /* should be enough for the first time */
2793 struct prot_inuse {
2794         int val[PROTO_INUSE_NR];
2795 };
2796
2797 static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
2798
2799 #ifdef CONFIG_NET_NS
2800 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2801 {
2802         __this_cpu_add(net->core.inuse->val[prot->inuse_idx], val);
2803 }
2804 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2805
2806 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2807 {
2808         int cpu, idx = prot->inuse_idx;
2809         int res = 0;
2810
2811         for_each_possible_cpu(cpu)
2812                 res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2813
2814         return res >= 0 ? res : 0;
2815 }
2816 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2817
2818 static int __net_init sock_inuse_init_net(struct net *net)
2819 {
2820         net->core.inuse = alloc_percpu(struct prot_inuse);
2821         return net->core.inuse ? 0 : -ENOMEM;
2822 }
2823
2824 static void __net_exit sock_inuse_exit_net(struct net *net)
2825 {
2826         free_percpu(net->core.inuse);
2827 }
2828
2829 static struct pernet_operations net_inuse_ops = {
2830         .init = sock_inuse_init_net,
2831         .exit = sock_inuse_exit_net,
2832 };
2833
2834 static __init int net_inuse_init(void)
2835 {
2836         if (register_pernet_subsys(&net_inuse_ops))
2837                 panic("Cannot initialize net inuse counters");
2838
2839         return 0;
2840 }
2841
2842 core_initcall(net_inuse_init);
2843 #else
2844 static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2845
2846 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2847 {
2848         __this_cpu_add(prot_inuse.val[prot->inuse_idx], val);
2849 }
2850 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2851
2852 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2853 {
2854         int cpu, idx = prot->inuse_idx;
2855         int res = 0;
2856
2857         for_each_possible_cpu(cpu)
2858                 res += per_cpu(prot_inuse, cpu).val[idx];
2859
2860         return res >= 0 ? res : 0;
2861 }
2862 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2863 #endif
2864
2865 static void assign_proto_idx(struct proto *prot)
2866 {
2867         prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2868
2869         if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
2870                 pr_err("PROTO_INUSE_NR exhausted\n");
2871                 return;
2872         }
2873
2874         set_bit(prot->inuse_idx, proto_inuse_idx);
2875 }
2876
2877 static void release_proto_idx(struct proto *prot)
2878 {
2879         if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2880                 clear_bit(prot->inuse_idx, proto_inuse_idx);
2881 }
2882 #else
2883 static inline void assign_proto_idx(struct proto *prot)
2884 {
2885 }
2886
2887 static inline void release_proto_idx(struct proto *prot)
2888 {
2889 }
2890 #endif
2891
2892 static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
2893 {
2894         if (!rsk_prot)
2895                 return;
2896         kfree(rsk_prot->slab_name);
2897         rsk_prot->slab_name = NULL;
2898         kmem_cache_destroy(rsk_prot->slab);
2899         rsk_prot->slab = NULL;
2900 }
2901
2902 static int req_prot_init(const struct proto *prot)
2903 {
2904         struct request_sock_ops *rsk_prot = prot->rsk_prot;
2905
2906         if (!rsk_prot)
2907                 return 0;
2908
2909         rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
2910                                         prot->name);
2911         if (!rsk_prot->slab_name)
2912                 return -ENOMEM;
2913
2914         rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
2915                                            rsk_prot->obj_size, 0,
2916                                            prot->slab_flags, NULL);
2917
2918         if (!rsk_prot->slab) {
2919                 pr_crit("%s: Can't create request sock SLAB cache!\n",
2920                         prot->name);
2921                 return -ENOMEM;
2922         }
2923         return 0;
2924 }
2925
2926 int proto_register(struct proto *prot, int alloc_slab)
2927 {
2928         if (alloc_slab) {
2929                 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
2930                                         SLAB_HWCACHE_ALIGN | prot->slab_flags,
2931                                         NULL);
2932
2933                 if (prot->slab == NULL) {
2934                         pr_crit("%s: Can't create sock SLAB cache!\n",
2935                                 prot->name);
2936                         goto out;
2937                 }
2938
2939                 if (req_prot_init(prot))
2940                         goto out_free_request_sock_slab;
2941
2942                 if (prot->twsk_prot != NULL) {
2943                         prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
2944
2945                         if (prot->twsk_prot->twsk_slab_name == NULL)
2946                                 goto out_free_request_sock_slab;
2947
2948                         prot->twsk_prot->twsk_slab =
2949                                 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
2950                                                   prot->twsk_prot->twsk_obj_size,
2951                                                   0,
2952                                                   prot->slab_flags,
2953                                                   NULL);
2954                         if (prot->twsk_prot->twsk_slab == NULL)
2955                                 goto out_free_timewait_sock_slab_name;
2956                 }
2957         }
2958
2959         mutex_lock(&proto_list_mutex);
2960         list_add(&prot->node, &proto_list);
2961         assign_proto_idx(prot);
2962         mutex_unlock(&proto_list_mutex);
2963         return 0;
2964
2965 out_free_timewait_sock_slab_name:
2966         kfree(prot->twsk_prot->twsk_slab_name);
2967 out_free_request_sock_slab:
2968         req_prot_cleanup(prot->rsk_prot);
2969
2970         kmem_cache_destroy(prot->slab);
2971         prot->slab = NULL;
2972 out:
2973         return -ENOBUFS;
2974 }
2975 EXPORT_SYMBOL(proto_register);
2976
2977 void proto_unregister(struct proto *prot)
2978 {
2979         mutex_lock(&proto_list_mutex);
2980         release_proto_idx(prot);
2981         list_del(&prot->node);
2982         mutex_unlock(&proto_list_mutex);
2983
2984         kmem_cache_destroy(prot->slab);
2985         prot->slab = NULL;
2986
2987         req_prot_cleanup(prot->rsk_prot);
2988
2989         if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
2990                 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
2991                 kfree(prot->twsk_prot->twsk_slab_name);
2992                 prot->twsk_prot->twsk_slab = NULL;
2993         }
2994 }
2995 EXPORT_SYMBOL(proto_unregister);
2996
2997 #ifdef CONFIG_PROC_FS
2998 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
2999         __acquires(proto_list_mutex)
3000 {
3001         mutex_lock(&proto_list_mutex);
3002         return seq_list_start_head(&proto_list, *pos);
3003 }
3004
3005 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3006 {
3007         return seq_list_next(v, &proto_list, pos);
3008 }
3009
3010 static void proto_seq_stop(struct seq_file *seq, void *v)
3011         __releases(proto_list_mutex)
3012 {
3013         mutex_unlock(&proto_list_mutex);
3014 }
3015
3016 static char proto_method_implemented(const void *method)
3017 {
3018         return method == NULL ? 'n' : 'y';
3019 }
3020 static long sock_prot_memory_allocated(struct proto *proto)
3021 {
3022         return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
3023 }
3024
3025 static char *sock_prot_memory_pressure(struct proto *proto)
3026 {
3027         return proto->memory_pressure != NULL ?
3028         proto_memory_pressure(proto) ? "yes" : "no" : "NI";
3029 }
3030
3031 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
3032 {
3033
3034         seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
3035                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
3036                    proto->name,
3037                    proto->obj_size,
3038                    sock_prot_inuse_get(seq_file_net(seq), proto),
3039                    sock_prot_memory_allocated(proto),
3040                    sock_prot_memory_pressure(proto),
3041                    proto->max_header,
3042                    proto->slab == NULL ? "no" : "yes",
3043                    module_name(proto->owner),
3044                    proto_method_implemented(proto->close),
3045                    proto_method_implemented(proto->connect),
3046                    proto_method_implemented(proto->disconnect),
3047                    proto_method_implemented(proto->accept),
3048                    proto_method_implemented(proto->ioctl),
3049                    proto_method_implemented(proto->init),
3050                    proto_method_implemented(proto->destroy),
3051                    proto_method_implemented(proto->shutdown),
3052                    proto_method_implemented(proto->setsockopt),
3053                    proto_method_implemented(proto->getsockopt),
3054                    proto_method_implemented(proto->sendmsg),
3055                    proto_method_implemented(proto->recvmsg),
3056                    proto_method_implemented(proto->sendpage),
3057                    proto_method_implemented(proto->bind),
3058                    proto_method_implemented(proto->backlog_rcv),
3059                    proto_method_implemented(proto->hash),
3060                    proto_method_implemented(proto->unhash),
3061                    proto_method_implemented(proto->get_port),
3062                    proto_method_implemented(proto->enter_memory_pressure));
3063 }
3064
3065 static int proto_seq_show(struct seq_file *seq, void *v)
3066 {
3067         if (v == &proto_list)
3068                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
3069                            "protocol",
3070                            "size",
3071                            "sockets",
3072                            "memory",
3073                            "press",
3074                            "maxhdr",
3075                            "slab",
3076                            "module",
3077                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
3078         else
3079                 proto_seq_printf(seq, list_entry(v, struct proto, node));
3080         return 0;
3081 }
3082
3083 static const struct seq_operations proto_seq_ops = {
3084         .start  = proto_seq_start,
3085         .next   = proto_seq_next,
3086         .stop   = proto_seq_stop,
3087         .show   = proto_seq_show,
3088 };
3089
3090 static int proto_seq_open(struct inode *inode, struct file *file)
3091 {
3092         return seq_open_net(inode, file, &proto_seq_ops,
3093                             sizeof(struct seq_net_private));
3094 }
3095
3096 static const struct file_operations proto_seq_fops = {
3097         .owner          = THIS_MODULE,
3098         .open           = proto_seq_open,
3099         .read           = seq_read,
3100         .llseek         = seq_lseek,
3101         .release        = seq_release_net,
3102 };
3103
3104 static __net_init int proto_init_net(struct net *net)
3105 {
3106         if (!proc_create("protocols", S_IRUGO, net->proc_net, &proto_seq_fops))
3107                 return -ENOMEM;
3108
3109         return 0;
3110 }
3111
3112 static __net_exit void proto_exit_net(struct net *net)
3113 {
3114         remove_proc_entry("protocols", net->proc_net);
3115 }
3116
3117
3118 static __net_initdata struct pernet_operations proto_net_ops = {
3119         .init = proto_init_net,
3120         .exit = proto_exit_net,
3121 };
3122
3123 static int __init proto_init(void)
3124 {
3125         return register_pernet_subsys(&proto_net_ops);
3126 }
3127
3128 subsys_initcall(proto_init);
3129
3130 #endif /* PROC_FS */