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 #include <linux/capability.h>
  93 #include <linux/errno.h>
  94 #include <linux/types.h>
  95 #include <linux/socket.h>
  96 #include <linux/in.h>
  97 #include <linux/kernel.h>
  98 #include <linux/module.h>
  99 #include <linux/proc_fs.h>
 100 #include <linux/seq_file.h>
 101 #include <linux/sched.h>
 102 #include <linux/timer.h>
 103 #include <linux/string.h>
 104 #include <linux/sockios.h>
 105 #include <linux/net.h>
 106 #include <linux/mm.h>
 107 #include <linux/slab.h>
 108 #include <linux/interrupt.h>
 109 #include <linux/poll.h>
 110 #include <linux/tcp.h>
 111 #include <linux/init.h>
 112 #include <linux/highmem.h>
 113 #include <linux/reserve.h>
 114
 115 #include <asm/uaccess.h>
 116 #include <asm/system.h>
 117
 118 #include <linux/netdevice.h>
 119 #include <net/protocol.h>
 120 #include <linux/skbuff.h>
 121 #include <net/net_namespace.h>
 122 #include <net/request_sock.h>
 123 #include <net/sock.h>
 124 #include <linux/net_tstamp.h>
 125 #include <net/xfrm.h>
 126 #include <linux/ipsec.h>
 127
 128 #include <linux/filter.h>
 129
 130 #ifdef CONFIG_INET
 131 #include <net/tcp.h>
 132 #endif
 133
 134 /*
 135  * Each address family might have different locking rules, so we have
 136  * one slock key per address family:
 137  */
 138 static struct lock_class_key af_family_keys[AF_MAX];
 139 static struct lock_class_key af_family_slock_keys[AF_MAX];
 140
 141 /*
 142  * Make lock validator output more readable. (we pre-construct these
 143  * strings build-time, so that runtime initialization of socket
 144  * locks is fast):
 145  */
 146 static const char *const af_family_key_strings[AF_MAX+1] = {
 147   "sk_lock-AF_UNSPEC", "sk_lock-AF_UNIX"     , "sk_lock-AF_INET"     ,
 148   "sk_lock-AF_AX25"  , "sk_lock-AF_IPX"      , "sk_lock-AF_APPLETALK",
 149   "sk_lock-AF_NETROM", "sk_lock-AF_BRIDGE"   , "sk_lock-AF_ATMPVC"   ,
 150   "sk_lock-AF_X25"   , "sk_lock-AF_INET6"    , "sk_lock-AF_ROSE"     ,
 151   "sk_lock-AF_DECnet", "sk_lock-AF_NETBEUI"  , "sk_lock-AF_SECURITY" ,
 152   "sk_lock-AF_KEY"   , "sk_lock-AF_NETLINK"  , "sk_lock-AF_PACKET"   ,
 153   "sk_lock-AF_ASH"   , "sk_lock-AF_ECONET"   , "sk_lock-AF_ATMSVC"   ,
 154   "sk_lock-AF_RDS"   , "sk_lock-AF_SNA"      , "sk_lock-AF_IRDA"     ,
 155   "sk_lock-AF_PPPOX" , "sk_lock-AF_WANPIPE"  , "sk_lock-AF_LLC"      ,
 156   "sk_lock-27"       , "sk_lock-28"          , "sk_lock-AF_CAN"      ,
 157   "sk_lock-AF_TIPC"  , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV"        ,
 158   "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN"     , "sk_lock-AF_PHONET"   ,
 159   "sk_lock-AF_IEEE802154",
 160   "sk_lock-AF_MAX"
 161 };
 162 static const char *const af_family_slock_key_strings[AF_MAX+1] = {
 163   "slock-AF_UNSPEC", "slock-AF_UNIX"     , "slock-AF_INET"     ,
 164   "slock-AF_AX25"  , "slock-AF_IPX"      , "slock-AF_APPLETALK",
 165   "slock-AF_NETROM", "slock-AF_BRIDGE"   , "slock-AF_ATMPVC"   ,
 166   "slock-AF_X25"   , "slock-AF_INET6"    , "slock-AF_ROSE"     ,
 167   "slock-AF_DECnet", "slock-AF_NETBEUI"  , "slock-AF_SECURITY" ,
 168   "slock-AF_KEY"   , "slock-AF_NETLINK"  , "slock-AF_PACKET"   ,
 169   "slock-AF_ASH"   , "slock-AF_ECONET"   , "slock-AF_ATMSVC"   ,
 170   "slock-AF_RDS"   , "slock-AF_SNA"      , "slock-AF_IRDA"     ,
 171   "slock-AF_PPPOX" , "slock-AF_WANPIPE"  , "slock-AF_LLC"      ,
 172   "slock-27"       , "slock-28"          , "slock-AF_CAN"      ,
 173   "slock-AF_TIPC"  , "slock-AF_BLUETOOTH", "slock-AF_IUCV"     ,
 174   "slock-AF_RXRPC" , "slock-AF_ISDN"     , "slock-AF_PHONET"   ,
 175   "slock-AF_IEEE802154",
 176   "slock-AF_MAX"
 177 };
 178 static const char *const af_family_clock_key_strings[AF_MAX+1] = {
 179   "clock-AF_UNSPEC", "clock-AF_UNIX"     , "clock-AF_INET"     ,
 180   "clock-AF_AX25"  , "clock-AF_IPX"      , "clock-AF_APPLETALK",
 181   "clock-AF_NETROM", "clock-AF_BRIDGE"   , "clock-AF_ATMPVC"   ,
 182   "clock-AF_X25"   , "clock-AF_INET6"    , "clock-AF_ROSE"     ,
 183   "clock-AF_DECnet", "clock-AF_NETBEUI"  , "clock-AF_SECURITY" ,
 184   "clock-AF_KEY"   , "clock-AF_NETLINK"  , "clock-AF_PACKET"   ,
 185   "clock-AF_ASH"   , "clock-AF_ECONET"   , "clock-AF_ATMSVC"   ,
 186   "clock-AF_RDS"   , "clock-AF_SNA"      , "clock-AF_IRDA"     ,
 187   "clock-AF_PPPOX" , "clock-AF_WANPIPE"  , "clock-AF_LLC"      ,
 188   "clock-27"       , "clock-28"          , "clock-AF_CAN"      ,
 189   "clock-AF_TIPC"  , "clock-AF_BLUETOOTH", "clock-AF_IUCV"     ,
 190   "clock-AF_RXRPC" , "clock-AF_ISDN"     , "clock-AF_PHONET"   ,
 191   "clock-AF_IEEE802154",
 192   "clock-AF_MAX"
 193 };
 194
 195 /*
 196  * sk_callback_lock locking rules are per-address-family,
 197  * so split the lock classes by using a per-AF key:
 198  */
 199 static struct lock_class_key af_callback_keys[AF_MAX];
 200
 201 /* Take into consideration the size of the struct sk_buff overhead in the
 202  * determination of these values, since that is non-constant across
 203  * platforms.  This makes socket queueing behavior and performance
 204  * not depend upon such differences.
 205  */
 206 #define _SK_MEM_PACKETS         256
 207 #define _SK_MEM_OVERHEAD        (sizeof(struct sk_buff) + 256)
 208 #define SK_WMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 209 #define SK_RMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 210
 211 /* Run time adjustable parameters. */
 212 __u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
 213 __u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
 214 __u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
 215 __u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
 216
 217 /* Maximal space eaten by iovec or ancilliary data plus some space */
 218 int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
 219 EXPORT_SYMBOL(sysctl_optmem_max);
 220
 221 static struct mem_reserve net_reserve;
 222 struct mem_reserve net_rx_reserve;
 223 EXPORT_SYMBOL_GPL(net_rx_reserve); /* modular ipv6 only */
 224 struct mem_reserve net_skb_reserve;
 225 EXPORT_SYMBOL_GPL(net_skb_reserve); /* modular ipv6 only */
 226 static struct mem_reserve net_tx_reserve;
 227 static struct mem_reserve net_tx_pages;
 228
 229 #ifdef CONFIG_NETVM
 230 static DEFINE_MUTEX(memalloc_socks_lock);
 231 int memalloc_socks;
 232
 233 /**
 234  *      sk_adjust_memalloc - adjust the global memalloc reserve for critical RX
 235  *      @socks: number of new %SOCK_MEMALLOC sockets
 236  *      @tx_resserve_pages: number of pages to (un)reserve for TX
 237  *
 238  *      This function adjusts the memalloc reserve based on system demand.
 239  *      The RX reserve is a limit, and only added once, not for each socket.
 240  *
 241  *      NOTE:
 242  *         @tx_reserve_pages is an upper-bound of memory used for TX hence
 243  *         we need not account the pages like we do for RX pages.
 244  */
 245 int sk_adjust_memalloc(int socks, long tx_reserve_pages)
 246 {
 247         int err;
 248
 249         mutex_lock(&memalloc_socks_lock);
 250         err = mem_reserve_pages_add(&net_tx_pages, tx_reserve_pages);
 251         if (err)
 252                 goto unlock;
 253
 254         /*
 255          * either socks is positive and we need to check for 0 -> !0
 256          * transition and connect the reserve tree when we observe it.
 257          */
 258         if (!memalloc_socks && socks > 0) {
 259                 err = mem_reserve_connect(&net_reserve, &mem_reserve_root);
 260                 if (err) {
 261                         /*
 262                          * if we failed to connect the tree, undo the tx
 263                          * reserve so that failure has no side effects.
 264                          */
 265                         mem_reserve_pages_add(&net_tx_pages, -tx_reserve_pages);
 266                         goto unlock;
 267                 }
 268         }
 269         memalloc_socks += socks;
 270         /*
 271          * or socks is negative and we must observe the !0 -> 0 transition
 272          * and disconnect the reserve tree.
 273          */
 274         if (!memalloc_socks && socks)
 275                 mem_reserve_disconnect(&net_reserve);
 276
 277 unlock:
 278         mutex_unlock(&memalloc_socks_lock);
 279
 280         return err;
 281 }
 282 EXPORT_SYMBOL_GPL(sk_adjust_memalloc);
 283
 284 /**
 285  *      sk_set_memalloc - sets %SOCK_MEMALLOC
 286  *      @sk: socket to set it on
 287  *
 288  *      Set %SOCK_MEMALLOC on a socket and increase the memalloc reserve
 289  *      accordingly.
 290  */
 291 int sk_set_memalloc(struct sock *sk)
 292 {
 293         int set = sock_flag(sk, SOCK_MEMALLOC);
 294
 295         if (!set) {
 296                 int err = sk_adjust_memalloc(1, 0);
 297                 if (err)
 298                         return err;
 299
 300                 sock_set_flag(sk, SOCK_MEMALLOC);
 301                 sk->sk_allocation |= __GFP_MEMALLOC;
 302         }
 303         return !set;
 304 }
 305 EXPORT_SYMBOL_GPL(sk_set_memalloc);
 306
 307 int sk_clear_memalloc(struct sock *sk)
 308 {
 309         int set = sock_flag(sk, SOCK_MEMALLOC);
 310         if (set) {
 311                 sk_adjust_memalloc(-1, 0);
 312                 sock_reset_flag(sk, SOCK_MEMALLOC);
 313                 sk->sk_allocation &= ~__GFP_MEMALLOC;
 314         }
 315         return set;
 316 }
 317 EXPORT_SYMBOL_GPL(sk_clear_memalloc);
 318
 319 int __sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
 320 {
 321         int ret;
 322         unsigned long pflags = current->flags;
 323
 324         /* these should have been dropped before queueing */
 325         BUG_ON(!sk_has_memalloc(sk));
 326
 327         current->flags |= PF_MEMALLOC;
 328         ret = sk->sk_backlog_rcv(sk, skb);
 329         tsk_restore_flags(current, pflags, PF_MEMALLOC);
 330
 331         return ret;
 332 }
 333 EXPORT_SYMBOL(__sk_backlog_rcv);
 334 #endif
 335
 336 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
 337 {
 338         struct timeval tv;
 339
 340         if (optlen < sizeof(tv))
 341                 return -EINVAL;
 342         if (copy_from_user(&tv, optval, sizeof(tv)))
 343                 return -EFAULT;
 344         if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
 345                 return -EDOM;
 346
 347         if (tv.tv_sec < 0) {
 348                 static int warned __read_mostly;
 349
 350                 *timeo_p = 0;
 351                 if (warned < 10 && net_ratelimit()) {
 352                         warned++;
 353                         printk(KERN_INFO "sock_set_timeout: `%s' (pid %d) "
 354                                "tries to set negative timeout\n",
 355                                 current->comm, task_pid_nr(current));
 356                 }
 357                 return 0;
 358         }
 359         *timeo_p = MAX_SCHEDULE_TIMEOUT;
 360         if (tv.tv_sec == 0 && tv.tv_usec == 0)
 361                 return 0;
 362         if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
 363                 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
 364         return 0;
 365 }
 366
 367 static void sock_warn_obsolete_bsdism(const char *name)
 368 {
 369         static int warned;
 370         static char warncomm[TASK_COMM_LEN];
 371         if (strcmp(warncomm, current->comm) && warned < 5) {
 372                 strcpy(warncomm,  current->comm);
 373                 printk(KERN_WARNING "process `%s' is using obsolete "
 374                        "%s SO_BSDCOMPAT\n", warncomm, name);
 375                 warned++;
 376         }
 377 }
 378
 379 static void sock_disable_timestamp(struct sock *sk, int flag)
 380 {
 381         if (sock_flag(sk, flag)) {
 382                 sock_reset_flag(sk, flag);
 383                 if (!sock_flag(sk, SOCK_TIMESTAMP) &&
 384                     !sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE)) {
 385                         net_disable_timestamp();
 386                 }
 387         }
 388 }
 389
 390
 391 int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
 392 {
 393         int err;
 394         int skb_len;
 395         unsigned long flags;
 396         struct sk_buff_head *list = &sk->sk_receive_queue;
 397
 398         /* Cast sk->rcvbuf to unsigned... It's pointless, but reduces
 399            number of warnings when compiling with -W --ANK
 400          */
 401         if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
 402             (unsigned)sk->sk_rcvbuf) {
 403                 atomic_inc(&sk->sk_drops);
 404                 return -ENOMEM;
 405         }
 406
 407         err = sk_filter(sk, skb);
 408         if (err)
 409                 return err;
 410
 411         if (!sk_rmem_schedule(sk, skb)) {
 412                 atomic_inc(&sk->sk_drops);
 413                 return -ENOBUFS;
 414         }
 415
 416         skb->dev = NULL;
 417         skb_set_owner_r(skb, sk);
 418
 419         /* Cache the SKB length before we tack it onto the receive
 420          * queue.  Once it is added it no longer belongs to us and
 421          * may be freed by other threads of control pulling packets
 422          * from the queue.
 423          */
 424         skb_len = skb->len;
 425
 426         spin_lock_irqsave(&list->lock, flags);
 427         skb->dropcount = atomic_read(&sk->sk_drops);
 428         __skb_queue_tail(list, skb);
 429         spin_unlock_irqrestore(&list->lock, flags);
 430
 431         if (!sock_flag(sk, SOCK_DEAD))
 432                 sk->sk_data_ready(sk, skb_len);
 433         return 0;
 434 }
 435 EXPORT_SYMBOL(sock_queue_rcv_skb);
 436
 437 int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
 438 {
 439         int rc = NET_RX_SUCCESS;
 440
 441         if (sk_filter(sk, skb))
 442                 goto discard_and_relse;
 443
 444         skb->dev = NULL;
 445
 446         if (nested)
 447                 bh_lock_sock_nested(sk);
 448         else
 449                 bh_lock_sock(sk);
 450         if (!sock_owned_by_user(sk)) {
 451                 /*
 452                  * trylock + unlock semantics:
 453                  */
 454                 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
 455
 456                 rc = sk_backlog_rcv(sk, skb);
 457
 458                 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
 459         } else
 460                 sk_add_backlog(sk, skb);
 461         bh_unlock_sock(sk);
 462 out:
 463         sock_put(sk);
 464         return rc;
 465 discard_and_relse:
 466         kfree_skb(skb);
 467         goto out;
 468 }
 469 EXPORT_SYMBOL(sk_receive_skb);
 470
 471 void sk_reset_txq(struct sock *sk)
 472 {
 473         sk_tx_queue_clear(sk);
 474 }
 475 EXPORT_SYMBOL(sk_reset_txq);
 476
 477 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
 478 {
 479         struct dst_entry *dst = sk->sk_dst_cache;
 480
 481         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
 482                 sk_tx_queue_clear(sk);
 483                 sk->sk_dst_cache = NULL;
 484                 dst_release(dst);
 485                 return NULL;
 486         }
 487
 488         return dst;
 489 }
 490 EXPORT_SYMBOL(__sk_dst_check);
 491
 492 struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
 493 {
 494         struct dst_entry *dst = sk_dst_get(sk);
 495
 496         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
 497                 sk_dst_reset(sk);
 498                 dst_release(dst);
 499                 return NULL;
 500         }
 501
 502         return dst;
 503 }
 504 EXPORT_SYMBOL(sk_dst_check);
 505
 506 static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
 507 {
 508         int ret = -ENOPROTOOPT;
 509 #ifdef CONFIG_NETDEVICES
 510         struct net *net = sock_net(sk);
 511         char devname[IFNAMSIZ];
 512         int index;
 513
 514         /* Sorry... */
 515         ret = -EPERM;
 516         if (!capable(CAP_NET_RAW))
 517                 goto out;
 518
 519         ret = -EINVAL;
 520         if (optlen < 0)
 521                 goto out;
 522
 523         /* Bind this socket to a particular device like "eth0",
 524          * as specified in the passed interface name. If the
 525          * name is "" or the option length is zero the socket
 526          * is not bound.
 527          */
 528         if (optlen > IFNAMSIZ - 1)
 529                 optlen = IFNAMSIZ - 1;
 530         memset(devname, 0, sizeof(devname));
 531
 532         ret = -EFAULT;
 533         if (copy_from_user(devname, optval, optlen))
 534                 goto out;
 535
 536         index = 0;
 537         if (devname[0] != '\0') {
 538                 struct net_device *dev;
 539
 540                 rcu_read_lock();
 541                 dev = dev_get_by_name_rcu(net, devname);
 542                 if (dev)
 543                         index = dev->ifindex;
 544                 rcu_read_unlock();
 545                 ret = -ENODEV;
 546                 if (!dev)
 547                         goto out;
 548         }
 549
 550         lock_sock(sk);
 551         sk->sk_bound_dev_if = index;
 552         sk_dst_reset(sk);
 553         release_sock(sk);
 554
 555         ret = 0;
 556
 557 out:
 558 #endif
 559
 560         return ret;
 561 }
 562
 563 static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
 564 {
 565         if (valbool)
 566                 sock_set_flag(sk, bit);
 567         else
 568                 sock_reset_flag(sk, bit);
 569 }
 570
 571 /*
 572  *      This is meant for all protocols to use and covers goings on
 573  *      at the socket level. Everything here is generic.
 574  */
 575
 576 int sock_setsockopt(struct socket *sock, int level, int optname,
 577                     char __user *optval, unsigned int optlen)
 578 {
 579         struct sock *sk = sock->sk;
 580         int val;
 581         int valbool;
 582         struct linger ling;
 583         int ret = 0;
 584
 585         /*
 586          *      Options without arguments
 587          */
 588
 589         if (optname == SO_BINDTODEVICE)
 590                 return sock_bindtodevice(sk, optval, optlen);
 591
 592         if (optlen < sizeof(int))
 593                 return -EINVAL;
 594
 595         if (get_user(val, (int __user *)optval))
 596                 return -EFAULT;
 597
 598         valbool = val ? 1 : 0;
 599
 600         lock_sock(sk);
 601
 602         switch (optname) {
 603         case SO_DEBUG:
 604                 if (val && !capable(CAP_NET_ADMIN))
 605                         ret = -EACCES;
 606                 else
 607                         sock_valbool_flag(sk, SOCK_DBG, valbool);
 608                 break;
 609         case SO_REUSEADDR:
 610                 sk->sk_reuse = valbool;
 611                 break;
 612         case SO_TYPE:
 613         case SO_PROTOCOL:
 614         case SO_DOMAIN:
 615         case SO_ERROR:
 616                 ret = -ENOPROTOOPT;
 617                 break;
 618         case SO_DONTROUTE:
 619                 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
 620                 break;
 621         case SO_BROADCAST:
 622                 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
 623                 break;
 624         case SO_SNDBUF:
 625                 /* Don't error on this BSD doesn't and if you think
 626                    about it this is right. Otherwise apps have to
 627                    play 'guess the biggest size' games. RCVBUF/SNDBUF
 628                    are treated in BSD as hints */
 629
 630                 if (val > sysctl_wmem_max)
 631                         val = sysctl_wmem_max;
 632 set_sndbuf:
 633                 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 634                 if ((val * 2) < SOCK_MIN_SNDBUF)
 635                         sk->sk_sndbuf = SOCK_MIN_SNDBUF;
 636                 else
 637                         sk->sk_sndbuf = val * 2;
 638
 639                 /*
 640                  *      Wake up sending tasks if we
 641                  *      upped the value.
 642                  */
 643                 sk->sk_write_space(sk);
 644                 break;
 645
 646         case SO_SNDBUFFORCE:
 647                 if (!capable(CAP_NET_ADMIN)) {
 648                         ret = -EPERM;
 649                         break;
 650                 }
 651                 goto set_sndbuf;
 652
 653         case SO_RCVBUF:
 654                 /* Don't error on this BSD doesn't and if you think
 655                    about it this is right. Otherwise apps have to
 656                    play 'guess the biggest size' games. RCVBUF/SNDBUF
 657                    are treated in BSD as hints */
 658
 659                 if (val > sysctl_rmem_max)
 660                         val = sysctl_rmem_max;
 661 set_rcvbuf:
 662                 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 663                 /*
 664                  * We double it on the way in to account for
 665                  * "struct sk_buff" etc. overhead.   Applications
 666                  * assume that the SO_RCVBUF setting they make will
 667                  * allow that much actual data to be received on that
 668                  * socket.
 669                  *
 670                  * Applications are unaware that "struct sk_buff" and
 671                  * other overheads allocate from the receive buffer
 672                  * during socket buffer allocation.
 673                  *
 674                  * And after considering the possible alternatives,
 675                  * returning the value we actually used in getsockopt
 676                  * is the most desirable behavior.
 677                  */
 678                 if ((val * 2) < SOCK_MIN_RCVBUF)
 679                         sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
 680                 else
 681                         sk->sk_rcvbuf = val * 2;
 682                 break;
 683
 684         case SO_RCVBUFFORCE:
 685                 if (!capable(CAP_NET_ADMIN)) {
 686                         ret = -EPERM;
 687                         break;
 688                 }
 689                 goto set_rcvbuf;
 690
 691         case SO_KEEPALIVE:
 692 #ifdef CONFIG_INET
 693                 if (sk->sk_protocol == IPPROTO_TCP)
 694                         tcp_set_keepalive(sk, valbool);
 695 #endif
 696                 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
 697                 break;
 698
 699         case SO_OOBINLINE:
 700                 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
 701                 break;
 702
 703         case SO_NO_CHECK:
 704                 sk->sk_no_check = valbool;
 705                 break;
 706
 707         case SO_PRIORITY:
 708                 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
 709                         sk->sk_priority = val;
 710                 else
 711                         ret = -EPERM;
 712                 break;
 713
 714         case SO_LINGER:
 715                 if (optlen < sizeof(ling)) {
 716                         ret = -EINVAL;  /* 1003.1g */
 717                         break;
 718                 }
 719                 if (copy_from_user(&ling, optval, sizeof(ling))) {
 720                         ret = -EFAULT;
 721                         break;
 722                 }
 723                 if (!ling.l_onoff)
 724                         sock_reset_flag(sk, SOCK_LINGER);
 725                 else {
 726 #if (BITS_PER_LONG == 32)
 727                         if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
 728                                 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
 729                         else
 730 #endif
 731                                 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
 732                         sock_set_flag(sk, SOCK_LINGER);
 733                 }
 734                 break;
 735
 736         case SO_BSDCOMPAT:
 737                 sock_warn_obsolete_bsdism("setsockopt");
 738                 break;
 739
 740         case SO_PASSCRED:
 741                 if (valbool)
 742                         set_bit(SOCK_PASSCRED, &sock->flags);
 743                 else
 744                         clear_bit(SOCK_PASSCRED, &sock->flags);
 745                 break;
 746
 747         case SO_TIMESTAMP:
 748         case SO_TIMESTAMPNS:
 749                 if (valbool)  {
 750                         if (optname == SO_TIMESTAMP)
 751                                 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 752                         else
 753                                 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
 754                         sock_set_flag(sk, SOCK_RCVTSTAMP);
 755                         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
 756                 } else {
 757                         sock_reset_flag(sk, SOCK_RCVTSTAMP);
 758                         sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
 759                 }
 760                 break;
 761
 762         case SO_TIMESTAMPING:
 763                 if (val & ~SOF_TIMESTAMPING_MASK) {
 764                         ret = -EINVAL;
 765                         break;
 766                 }
 767                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE,
 768                                   val & SOF_TIMESTAMPING_TX_HARDWARE);
 769                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE,
 770                                   val & SOF_TIMESTAMPING_TX_SOFTWARE);
 771                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE,
 772                                   val & SOF_TIMESTAMPING_RX_HARDWARE);
 773                 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
 774                         sock_enable_timestamp(sk,
 775                                               SOCK_TIMESTAMPING_RX_SOFTWARE);
 776                 else
 777                         sock_disable_timestamp(sk,
 778                                                SOCK_TIMESTAMPING_RX_SOFTWARE);
 779                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SOFTWARE,
 780                                   val & SOF_TIMESTAMPING_SOFTWARE);
 781                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE,
 782                                   val & SOF_TIMESTAMPING_SYS_HARDWARE);
 783                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE,
 784                                   val & SOF_TIMESTAMPING_RAW_HARDWARE);
 785                 break;
 786
 787         case SO_RCVLOWAT:
 788                 if (val < 0)
 789                         val = INT_MAX;
 790                 sk->sk_rcvlowat = val ? : 1;
 791                 break;
 792
 793         case SO_RCVTIMEO:
 794                 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
 795                 break;
 796
 797         case SO_SNDTIMEO:
 798                 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
 799                 break;
 800
 801         case SO_ATTACH_FILTER:
 802                 ret = -EINVAL;
 803                 if (optlen == sizeof(struct sock_fprog)) {
 804                         struct sock_fprog fprog;
 805
 806                         ret = -EFAULT;
 807                         if (copy_from_user(&fprog, optval, sizeof(fprog)))
 808                                 break;
 809
 810                         ret = sk_attach_filter(&fprog, sk);
 811                 }
 812                 break;
 813
 814         case SO_DETACH_FILTER:
 815                 ret = sk_detach_filter(sk);
 816                 break;
 817
 818         case SO_PASSSEC:
 819                 if (valbool)
 820                         set_bit(SOCK_PASSSEC, &sock->flags);
 821                 else
 822                         clear_bit(SOCK_PASSSEC, &sock->flags);
 823                 break;
 824         case SO_MARK:
 825                 if (!capable(CAP_NET_ADMIN))
 826                         ret = -EPERM;
 827                 else
 828                         sk->sk_mark = val;
 829                 break;
 830
 831                 /* We implement the SO_SNDLOWAT etc to
 832                    not be settable (1003.1g 5.3) */
 833         case SO_RXQ_OVFL:
 834                 if (valbool)
 835                         sock_set_flag(sk, SOCK_RXQ_OVFL);
 836                 else
 837                         sock_reset_flag(sk, SOCK_RXQ_OVFL);
 838                 break;
 839         default:
 840                 ret = -ENOPROTOOPT;
 841                 break;
 842         }
 843         release_sock(sk);
 844         return ret;
 845 }
 846 EXPORT_SYMBOL(sock_setsockopt);
 847
 848
 849 int sock_getsockopt(struct socket *sock, int level, int optname,
 850                     char __user *optval, int __user *optlen)
 851 {
 852         struct sock *sk = sock->sk;
 853
 854         union {
 855                 int val;
 856                 struct linger ling;
 857                 struct timeval tm;
 858         } v;
 859
 860         unsigned int lv = sizeof(int);
 861         int len;
 862
 863         if (get_user(len, optlen))
 864                 return -EFAULT;
 865         if (len < 0)
 866                 return -EINVAL;
 867
 868         memset(&v, 0, sizeof(v));
 869
 870         switch (optname) {
 871         case SO_DEBUG:
 872                 v.val = sock_flag(sk, SOCK_DBG);
 873                 break;
 874
 875         case SO_DONTROUTE:
 876                 v.val = sock_flag(sk, SOCK_LOCALROUTE);
 877                 break;
 878
 879         case SO_BROADCAST:
 880                 v.val = !!sock_flag(sk, SOCK_BROADCAST);
 881                 break;
 882
 883         case SO_SNDBUF:
 884                 v.val = sk->sk_sndbuf;
 885                 break;
 886
 887         case SO_RCVBUF:
 888                 v.val = sk->sk_rcvbuf;
 889                 break;
 890
 891         case SO_REUSEADDR:
 892                 v.val = sk->sk_reuse;
 893                 break;
 894
 895         case SO_KEEPALIVE:
 896                 v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
 897                 break;
 898
 899         case SO_TYPE:
 900                 v.val = sk->sk_type;
 901                 break;
 902
 903         case SO_PROTOCOL:
 904                 v.val = sk->sk_protocol;
 905                 break;
 906
 907         case SO_DOMAIN:
 908                 v.val = sk->sk_family;
 909                 break;
 910
 911         case SO_ERROR:
 912                 v.val = -sock_error(sk);
 913                 if (v.val == 0)
 914                         v.val = xchg(&sk->sk_err_soft, 0);
 915                 break;
 916
 917         case SO_OOBINLINE:
 918                 v.val = !!sock_flag(sk, SOCK_URGINLINE);
 919                 break;
 920
 921         case SO_NO_CHECK:
 922                 v.val = sk->sk_no_check;
 923                 break;
 924
 925         case SO_PRIORITY:
 926                 v.val = sk->sk_priority;
 927                 break;
 928
 929         case SO_LINGER:
 930                 lv              = sizeof(v.ling);
 931                 v.ling.l_onoff  = !!sock_flag(sk, SOCK_LINGER);
 932                 v.ling.l_linger = sk->sk_lingertime / HZ;
 933                 break;
 934
 935         case SO_BSDCOMPAT:
 936                 sock_warn_obsolete_bsdism("getsockopt");
 937                 break;
 938
 939         case SO_TIMESTAMP:
 940                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
 941                                 !sock_flag(sk, SOCK_RCVTSTAMPNS);
 942                 break;
 943
 944         case SO_TIMESTAMPNS:
 945                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
 946                 break;
 947
 948         case SO_TIMESTAMPING:
 949                 v.val = 0;
 950                 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))
 951                         v.val |= SOF_TIMESTAMPING_TX_HARDWARE;
 952                 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))
 953                         v.val |= SOF_TIMESTAMPING_TX_SOFTWARE;
 954                 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE))
 955                         v.val |= SOF_TIMESTAMPING_RX_HARDWARE;
 956                 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE))
 957                         v.val |= SOF_TIMESTAMPING_RX_SOFTWARE;
 958                 if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE))
 959                         v.val |= SOF_TIMESTAMPING_SOFTWARE;
 960                 if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE))
 961                         v.val |= SOF_TIMESTAMPING_SYS_HARDWARE;
 962                 if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE))
 963                         v.val |= SOF_TIMESTAMPING_RAW_HARDWARE;
 964                 break;
 965
 966         case SO_RCVTIMEO:
 967                 lv = sizeof(struct timeval);
 968                 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
 969                         v.tm.tv_sec = 0;
 970                         v.tm.tv_usec = 0;
 971                 } else {
 972                         v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
 973                         v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
 974                 }
 975                 break;
 976
 977         case SO_SNDTIMEO:
 978                 lv = sizeof(struct timeval);
 979                 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
 980                         v.tm.tv_sec = 0;
 981                         v.tm.tv_usec = 0;
 982                 } else {
 983                         v.tm.tv_sec = sk->sk_sndtimeo / HZ;
 984                         v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
 985                 }
 986                 break;
 987
 988         case SO_RCVLOWAT:
 989                 v.val = sk->sk_rcvlowat;
 990                 break;
 991
 992         case SO_SNDLOWAT:
 993                 v.val = 1;
 994                 break;
 995
 996         case SO_PASSCRED:
 997                 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
 998                 break;
 999
1000         case SO_PEERCRED:
1001                 if (len > sizeof(sk->sk_peercred))
1002                         len = sizeof(sk->sk_peercred);
1003                 if (copy_to_user(optval, &sk->sk_peercred, len))
1004                         return -EFAULT;
1005                 goto lenout;
1006
1007         case SO_PEERNAME:
1008         {
1009                 char address[128];
1010
1011                 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
1012                         return -ENOTCONN;
1013                 if (lv < len)
1014                         return -EINVAL;
1015                 if (copy_to_user(optval, address, len))
1016                         return -EFAULT;
1017                 goto lenout;
1018         }
1019
1020         /* Dubious BSD thing... Probably nobody even uses it, but
1021          * the UNIX standard wants it for whatever reason... -DaveM
1022          */
1023         case SO_ACCEPTCONN:
1024                 v.val = sk->sk_state == TCP_LISTEN;
1025                 break;
1026
1027         case SO_PASSSEC:
1028                 v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0;
1029                 break;
1030
1031         case SO_PEERSEC:
1032                 return security_socket_getpeersec_stream(sock, optval, optlen, len);
1033
1034         case SO_MARK:
1035                 v.val = sk->sk_mark;
1036                 break;
1037
1038         case SO_RXQ_OVFL:
1039                 v.val = !!sock_flag(sk, SOCK_RXQ_OVFL);
1040                 break;
1041
1042         default:
1043                 return -ENOPROTOOPT;
1044         }
1045
1046         if (len > lv)
1047                 len = lv;
1048         if (copy_to_user(optval, &v, len))
1049                 return -EFAULT;
1050 lenout:
1051         if (put_user(len, optlen))
1052                 return -EFAULT;
1053         return 0;
1054 }
1055
1056 /*
1057  * Initialize an sk_lock.
1058  *
1059  * (We also register the sk_lock with the lock validator.)
1060  */
1061 static inline void sock_lock_init(struct sock *sk)
1062 {
1063         sock_lock_init_class_and_name(sk,
1064                         af_family_slock_key_strings[sk->sk_family],
1065                         af_family_slock_keys + sk->sk_family,
1066                         af_family_key_strings[sk->sk_family],
1067                         af_family_keys + sk->sk_family);
1068 }
1069
1070 /*
1071  * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
1072  * even temporarly, because of RCU lookups. sk_node should also be left as is.
1073  */
1074 static void sock_copy(struct sock *nsk, const struct sock *osk)
1075 {
1076 #ifdef CONFIG_SECURITY_NETWORK
1077         void *sptr = nsk->sk_security;
1078 #endif
1079         BUILD_BUG_ON(offsetof(struct sock, sk_copy_start) !=
1080                      sizeof(osk->sk_node) + sizeof(osk->sk_refcnt) +
1081                      sizeof(osk->sk_tx_queue_mapping));
1082         memcpy(&nsk->sk_copy_start, &osk->sk_copy_start,
1083                osk->sk_prot->obj_size - offsetof(struct sock, sk_copy_start));
1084 #ifdef CONFIG_SECURITY_NETWORK
1085         nsk->sk_security = sptr;
1086         security_sk_clone(osk, nsk);
1087 #endif
1088 }
1089
1090 static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
1091                 int family)
1092 {
1093         struct sock *sk;
1094         struct kmem_cache *slab;
1095
1096         slab = prot->slab;
1097         if (slab != NULL) {
1098                 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
1099                 if (!sk)
1100                         return sk;
1101                 if (priority & __GFP_ZERO) {
1102                         /*
1103                          * caches using SLAB_DESTROY_BY_RCU should let
1104                          * sk_node.next un-modified. Special care is taken
1105                          * when initializing object to zero.
1106                          */
1107                         if (offsetof(struct sock, sk_node.next) != 0)
1108                                 memset(sk, 0, offsetof(struct sock, sk_node.next));
1109                         memset(&sk->sk_node.pprev, 0,
1110                                prot->obj_size - offsetof(struct sock,
1111                                                          sk_node.pprev));
1112                 }
1113         }
1114         else
1115                 sk = kmalloc(prot->obj_size, priority);
1116
1117         if (sk != NULL) {
1118                 kmemcheck_annotate_bitfield(sk, flags);
1119
1120                 if (security_sk_alloc(sk, family, priority))
1121                         goto out_free;
1122
1123                 if (!try_module_get(prot->owner))
1124                         goto out_free_sec;
1125                 sk_tx_queue_clear(sk);
1126         }
1127
1128         return sk;
1129
1130 out_free_sec:
1131         security_sk_free(sk);
1132 out_free:
1133         if (slab != NULL)
1134                 kmem_cache_free(slab, sk);
1135         else
1136                 kfree(sk);
1137         return NULL;
1138 }
1139
1140 static void sk_prot_free(struct proto *prot, struct sock *sk)
1141 {
1142         struct kmem_cache *slab;
1143         struct module *owner;
1144
1145         owner = prot->owner;
1146         slab = prot->slab;
1147
1148         security_sk_free(sk);
1149         if (slab != NULL)
1150                 kmem_cache_free(slab, sk);
1151         else
1152                 kfree(sk);
1153         module_put(owner);
1154 }
1155
1156 /**
1157  *      sk_alloc - All socket objects are allocated here
1158  *      @net: the applicable net namespace
1159  *      @family: protocol family
1160  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1161  *      @prot: struct proto associated with this new sock instance
1162  */
1163 struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
1164                       struct proto *prot)
1165 {
1166         struct sock *sk;
1167
1168         sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
1169         if (sk) {
1170                 sk->sk_family = family;
1171                 /*
1172                  * See comment in struct sock definition to understand
1173                  * why we need sk_prot_creator -acme
1174                  */
1175                 sk->sk_prot = sk->sk_prot_creator = prot;
1176                 sock_lock_init(sk);
1177                 sock_net_set(sk, get_net(net));
1178                 atomic_set(&sk->sk_wmem_alloc, 1);
1179         }
1180
1181         return sk;
1182 }
1183 EXPORT_SYMBOL(sk_alloc);
1184
1185 static void __sk_free(struct sock *sk)
1186 {
1187         struct sk_filter *filter;
1188
1189         sk_clear_memalloc(sk);
1190         if (sk->sk_destruct)
1191                 sk->sk_destruct(sk);
1192
1193         filter = rcu_dereference(sk->sk_filter);
1194         if (filter) {
1195                 sk_filter_uncharge(sk, filter);
1196                 rcu_assign_pointer(sk->sk_filter, NULL);
1197         }
1198
1199         sock_disable_timestamp(sk, SOCK_TIMESTAMP);
1200         sock_disable_timestamp(sk, SOCK_TIMESTAMPING_RX_SOFTWARE);
1201
1202         if (atomic_read(&sk->sk_omem_alloc))
1203                 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
1204                        __func__, atomic_read(&sk->sk_omem_alloc));
1205
1206         put_net(sock_net(sk));
1207         sk_prot_free(sk->sk_prot_creator, sk);
1208 }
1209
1210 void sk_free(struct sock *sk)
1211 {
1212         /*
1213          * We substract one from sk_wmem_alloc and can know if
1214          * some packets are still in some tx queue.
1215          * If not null, sock_wfree() will call __sk_free(sk) later
1216          */
1217         if (atomic_dec_and_test(&sk->sk_wmem_alloc))
1218                 __sk_free(sk);
1219 }
1220 EXPORT_SYMBOL(sk_free);
1221
1222 /*
1223  * Last sock_put should drop referrence to sk->sk_net. It has already
1224  * been dropped in sk_change_net. Taking referrence to stopping namespace
1225  * is not an option.
1226  * Take referrence to a socket to remove it from hash _alive_ and after that
1227  * destroy it in the context of init_net.
1228  */
1229 void sk_release_kernel(struct sock *sk)
1230 {
1231         if (sk == NULL || sk->sk_socket == NULL)
1232                 return;
1233
1234         sock_hold(sk);
1235         sock_release(sk->sk_socket);
1236         release_net(sock_net(sk));
1237         sock_net_set(sk, get_net(&init_net));
1238         sock_put(sk);
1239 }
1240 EXPORT_SYMBOL(sk_release_kernel);
1241
1242 struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
1243 {
1244         struct sock *newsk;
1245
1246         newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
1247         if (newsk != NULL) {
1248                 struct sk_filter *filter;
1249
1250                 sock_copy(newsk, sk);
1251
1252                 /* SANITY */
1253                 get_net(sock_net(newsk));
1254                 sk_node_init(&newsk->sk_node);
1255                 sock_lock_init(newsk);
1256                 bh_lock_sock(newsk);
1257                 newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
1258
1259                 atomic_set(&newsk->sk_rmem_alloc, 0);
1260                 /*
1261                  * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1262                  */
1263                 atomic_set(&newsk->sk_wmem_alloc, 1);
1264                 atomic_set(&newsk->sk_omem_alloc, 0);
1265                 skb_queue_head_init(&newsk->sk_receive_queue);
1266                 skb_queue_head_init(&newsk->sk_write_queue);
1267 #ifdef CONFIG_NET_DMA
1268                 skb_queue_head_init(&newsk->sk_async_wait_queue);
1269 #endif
1270
1271                 rwlock_init(&newsk->sk_dst_lock);
1272                 rwlock_init(&newsk->sk_callback_lock);
1273                 lockdep_set_class_and_name(&newsk->sk_callback_lock,
1274                                 af_callback_keys + newsk->sk_family,
1275                                 af_family_clock_key_strings[newsk->sk_family]);
1276
1277                 newsk->sk_dst_cache     = NULL;
1278                 newsk->sk_wmem_queued   = 0;
1279                 newsk->sk_forward_alloc = 0;
1280                 newsk->sk_send_head     = NULL;
1281                 newsk->sk_userlocks     = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1282
1283                 sock_reset_flag(newsk, SOCK_DONE);
1284                 skb_queue_head_init(&newsk->sk_error_queue);
1285
1286                 filter = newsk->sk_filter;
1287                 if (filter != NULL)
1288                         sk_filter_charge(newsk, filter);
1289
1290                 if (unlikely(xfrm_sk_clone_policy(newsk))) {
1291                         /* It is still raw copy of parent, so invalidate
1292                          * destructor and make plain sk_free() */
1293                         newsk->sk_destruct = NULL;
1294                         sk_free(newsk);
1295                         newsk = NULL;
1296                         goto out;
1297                 }
1298
1299                 newsk->sk_err      = 0;
1300                 newsk->sk_priority = 0;
1301                 /*
1302                  * Before updating sk_refcnt, we must commit prior changes to memory
1303                  * (Documentation/RCU/rculist_nulls.txt for details)
1304                  */
1305                 smp_wmb();
1306                 atomic_set(&newsk->sk_refcnt, 2);
1307
1308                 /*
1309                  * Increment the counter in the same struct proto as the master
1310                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1311                  * is the same as sk->sk_prot->socks, as this field was copied
1312                  * with memcpy).
1313                  *
1314                  * This _changes_ the previous behaviour, where
1315                  * tcp_create_openreq_child always was incrementing the
1316                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1317                  * to be taken into account in all callers. -acme
1318                  */
1319                 sk_refcnt_debug_inc(newsk);
1320                 sk_set_socket(newsk, NULL);
1321                 newsk->sk_sleep  = NULL;
1322
1323                 if (newsk->sk_prot->sockets_allocated)
1324                         percpu_counter_inc(newsk->sk_prot->sockets_allocated);
1325
1326                 if (sock_flag(newsk, SOCK_TIMESTAMP) ||
1327                     sock_flag(newsk, SOCK_TIMESTAMPING_RX_SOFTWARE))
1328                         net_enable_timestamp();
1329         }
1330 out:
1331         return newsk;
1332 }
1333 EXPORT_SYMBOL_GPL(sk_clone);
1334
1335 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1336 {
1337         __sk_dst_set(sk, dst);
1338         sk->sk_route_caps = dst->dev->features;
1339         if (sk->sk_route_caps & NETIF_F_GSO)
1340                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1341         if (sk_can_gso(sk)) {
1342                 if (dst->header_len) {
1343                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1344                 } else {
1345                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1346                         sk->sk_gso_max_size = dst->dev->gso_max_size;
1347                 }
1348         }
1349 }
1350 EXPORT_SYMBOL_GPL(sk_setup_caps);
1351
1352 void __init sk_init(void)
1353 {
1354         if (totalram_pages <= 4096) {
1355                 sysctl_wmem_max = 32767;
1356                 sysctl_rmem_max = 32767;
1357                 sysctl_wmem_default = 32767;
1358                 sysctl_rmem_default = 32767;
1359         } else if (totalram_pages >= 131072) {
1360                 sysctl_wmem_max = 131071;
1361                 sysctl_rmem_max = 131071;
1362         }
1363
1364         mem_reserve_init(&net_reserve, "total network reserve", NULL);
1365         mem_reserve_init(&net_rx_reserve, "network RX reserve", &net_reserve);
1366         mem_reserve_init(&net_skb_reserve, "SKB data reserve", &net_rx_reserve);
1367         mem_reserve_init(&net_tx_reserve, "network TX reserve", &net_reserve);
1368         mem_reserve_init(&net_tx_pages, "protocol TX pages", &net_tx_reserve);
1369 }
1370
1371 /*
1372  *      Simple resource managers for sockets.
1373  */
1374
1375
1376 /*
1377  * Write buffer destructor automatically called from kfree_skb.
1378  */
1379 void sock_wfree(struct sk_buff *skb)
1380 {
1381         struct sock *sk = skb->sk;
1382         unsigned int len = skb->truesize;
1383
1384         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1385                 /*
1386                  * Keep a reference on sk_wmem_alloc, this will be released
1387                  * after sk_write_space() call
1388                  */
1389                 atomic_sub(len - 1, &sk->sk_wmem_alloc);
1390                 sk->sk_write_space(sk);
1391                 len = 1;
1392         }
1393         /*
1394          * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1395          * could not do because of in-flight packets
1396          */
1397         if (atomic_sub_and_test(len, &sk->sk_wmem_alloc))
1398                 __sk_free(sk);
1399 }
1400 EXPORT_SYMBOL(sock_wfree);
1401
1402 /*
1403  * Read buffer destructor automatically called from kfree_skb.
1404  */
1405 void sock_rfree(struct sk_buff *skb)
1406 {
1407         struct sock *sk = skb->sk;
1408
1409         atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
1410         sk_mem_uncharge(skb->sk, skb->truesize);
1411 }
1412 EXPORT_SYMBOL(sock_rfree);
1413
1414
1415 int sock_i_uid(struct sock *sk)
1416 {
1417         int uid;
1418
1419         read_lock(&sk->sk_callback_lock);
1420         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1421         read_unlock(&sk->sk_callback_lock);
1422         return uid;
1423 }
1424 EXPORT_SYMBOL(sock_i_uid);
1425
1426 unsigned long sock_i_ino(struct sock *sk)
1427 {
1428         unsigned long ino;
1429
1430         read_lock(&sk->sk_callback_lock);
1431         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1432         read_unlock(&sk->sk_callback_lock);
1433         return ino;
1434 }
1435 EXPORT_SYMBOL(sock_i_ino);
1436
1437 /*
1438  * Allocate a skb from the socket's send buffer.
1439  */
1440 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1441                              gfp_t priority)
1442 {
1443         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1444                 struct sk_buff *skb = alloc_skb(size, priority);
1445                 if (skb) {
1446                         skb_set_owner_w(skb, sk);
1447                         return skb;
1448                 }
1449         }
1450         return NULL;
1451 }
1452 EXPORT_SYMBOL(sock_wmalloc);
1453
1454 /*
1455  * Allocate a skb from the socket's receive buffer.
1456  */
1457 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
1458                              gfp_t priority)
1459 {
1460         if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1461                 struct sk_buff *skb = alloc_skb(size, priority);
1462                 if (skb) {
1463                         skb_set_owner_r(skb, sk);
1464                         return skb;
1465                 }
1466         }
1467         return NULL;
1468 }
1469
1470 /*
1471  * Allocate a memory block from the socket's option memory buffer.
1472  */
1473 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1474 {
1475         if ((unsigned)size <= sysctl_optmem_max &&
1476             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1477                 void *mem;
1478                 /* First do the add, to avoid the race if kmalloc
1479                  * might sleep.
1480                  */
1481                 atomic_add(size, &sk->sk_omem_alloc);
1482                 mem = kmalloc(size, priority);
1483                 if (mem)
1484                         return mem;
1485                 atomic_sub(size, &sk->sk_omem_alloc);
1486         }
1487         return NULL;
1488 }
1489 EXPORT_SYMBOL(sock_kmalloc);
1490
1491 /*
1492  * Free an option memory block.
1493  */
1494 void sock_kfree_s(struct sock *sk, void *mem, int size)
1495 {
1496         kfree(mem);
1497         atomic_sub(size, &sk->sk_omem_alloc);
1498 }
1499 EXPORT_SYMBOL(sock_kfree_s);
1500
1501 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1502    I think, these locks should be removed for datagram sockets.
1503  */
1504 static long sock_wait_for_wmem(struct sock *sk, long timeo)
1505 {
1506         DEFINE_WAIT(wait);
1507
1508         clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1509         for (;;) {
1510                 if (!timeo)
1511                         break;
1512                 if (signal_pending(current))
1513                         break;
1514                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1515                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1516                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1517                         break;
1518                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1519                         break;
1520                 if (sk->sk_err)
1521                         break;
1522                 timeo = schedule_timeout(timeo);
1523         }
1524         finish_wait(sk->sk_sleep, &wait);
1525         return timeo;
1526 }
1527
1528
1529 /*
1530  *      Generic send/receive buffer handlers
1531  */
1532
1533 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1534                                      unsigned long data_len, int noblock,
1535                                      int *errcode)
1536 {
1537         struct sk_buff *skb;
1538         gfp_t gfp_mask;
1539         long timeo;
1540         int err;
1541
1542         gfp_mask = sk->sk_allocation;
1543         if (gfp_mask & __GFP_WAIT)
1544                 gfp_mask |= __GFP_REPEAT;
1545
1546         timeo = sock_sndtimeo(sk, noblock);
1547         while (1) {
1548                 err = sock_error(sk);
1549                 if (err != 0)
1550                         goto failure;
1551
1552                 err = -EPIPE;
1553                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1554                         goto failure;
1555
1556                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1557                         skb = alloc_skb(header_len, gfp_mask);
1558                         if (skb) {
1559                                 int npages;
1560                                 int i;
1561
1562                                 /* No pages, we're done... */
1563                                 if (!data_len)
1564                                         break;
1565
1566                                 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1567                                 skb->truesize += data_len;
1568                                 skb_shinfo(skb)->nr_frags = npages;
1569                                 for (i = 0; i < npages; i++) {
1570                                         struct page *page;
1571                                         skb_frag_t *frag;
1572
1573                                         page = alloc_pages(sk->sk_allocation, 0);
1574                                         if (!page) {
1575                                                 err = -ENOBUFS;
1576                                                 skb_shinfo(skb)->nr_frags = i;
1577                                                 kfree_skb(skb);
1578                                                 goto failure;
1579                                         }
1580
1581                                         frag = &skb_shinfo(skb)->frags[i];
1582                                         frag->page = page;
1583                                         frag->page_offset = 0;
1584                                         frag->size = (data_len >= PAGE_SIZE ?
1585                                                       PAGE_SIZE :
1586                                                       data_len);
1587                                         data_len -= PAGE_SIZE;
1588                                 }
1589
1590                                 /* Full success... */
1591                                 break;
1592                         }
1593                         err = -ENOBUFS;
1594                         goto failure;
1595                 }
1596                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1597                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1598                 err = -EAGAIN;
1599                 if (!timeo)
1600                         goto failure;
1601                 if (signal_pending(current))
1602                         goto interrupted;
1603                 timeo = sock_wait_for_wmem(sk, timeo);
1604         }
1605
1606         skb_set_owner_w(skb, sk);
1607         return skb;
1608
1609 interrupted:
1610         err = sock_intr_errno(timeo);
1611 failure:
1612         *errcode = err;
1613         return NULL;
1614 }
1615 EXPORT_SYMBOL(sock_alloc_send_pskb);
1616
1617 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1618                                     int noblock, int *errcode)
1619 {
1620         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1621 }
1622 EXPORT_SYMBOL(sock_alloc_send_skb);
1623
1624 static void __lock_sock(struct sock *sk)
1625 {
1626         DEFINE_WAIT(wait);
1627
1628         for (;;) {
1629                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1630                                         TASK_UNINTERRUPTIBLE);
1631                 spin_unlock_bh(&sk->sk_lock.slock);
1632                 schedule();
1633                 spin_lock_bh(&sk->sk_lock.slock);
1634                 if (!sock_owned_by_user(sk))
1635                         break;
1636         }
1637         finish_wait(&sk->sk_lock.wq, &wait);
1638 }
1639
1640 static void __release_sock(struct sock *sk)
1641 {
1642         struct sk_buff *skb = sk->sk_backlog.head;
1643
1644         do {
1645                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1646                 bh_unlock_sock(sk);
1647
1648                 do {
1649                         struct sk_buff *next = skb->next;
1650
1651                         skb->next = NULL;
1652                         sk_backlog_rcv(sk, skb);
1653
1654                         /*
1655                          * We are in process context here with softirqs
1656                          * disabled, use cond_resched_softirq() to preempt.
1657                          * This is safe to do because we've taken the backlog
1658                          * queue private:
1659                          */
1660                         cond_resched_softirq();
1661
1662                         skb = next;
1663                 } while (skb != NULL);
1664
1665                 bh_lock_sock(sk);
1666         } while ((skb = sk->sk_backlog.head) != NULL);
1667 }
1668
1669 /**
1670  * sk_wait_data - wait for data to arrive at sk_receive_queue
1671  * @sk:    sock to wait on
1672  * @timeo: for how long
1673  *
1674  * Now socket state including sk->sk_err is changed only under lock,
1675  * hence we may omit checks after joining wait queue.
1676  * We check receive queue before schedule() only as optimization;
1677  * it is very likely that release_sock() added new data.
1678  */
1679 int sk_wait_data(struct sock *sk, long *timeo)
1680 {
1681         int rc;
1682         DEFINE_WAIT(wait);
1683
1684         prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1685         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1686         rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1687         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1688         finish_wait(sk->sk_sleep, &wait);
1689         return rc;
1690 }
1691 EXPORT_SYMBOL(sk_wait_data);
1692
1693 /**
1694  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
1695  *      @sk: socket
1696  *      @size: memory size to allocate
1697  *      @kind: allocation type
1698  *
1699  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
1700  *      rmem allocation. This function assumes that protocols which have
1701  *      memory_pressure use sk_wmem_queued as write buffer accounting.
1702  */
1703 int __sk_mem_schedule(struct sock *sk, int size, int kind)
1704 {
1705         struct proto *prot = sk->sk_prot;
1706         int amt = sk_mem_pages(size);
1707         int allocated;
1708
1709         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
1710         allocated = atomic_add_return(amt, prot->memory_allocated);
1711
1712         /* Under limit. */
1713         if (allocated <= prot->sysctl_mem[0]) {
1714                 if (prot->memory_pressure && *prot->memory_pressure)
1715                         *prot->memory_pressure = 0;
1716                 return 1;
1717         }
1718
1719         /* Under pressure. */
1720         if (allocated > prot->sysctl_mem[1])
1721                 if (prot->enter_memory_pressure)
1722                         prot->enter_memory_pressure(sk);
1723
1724         /* Over hard limit. */
1725         if (allocated > prot->sysctl_mem[2])
1726                 goto suppress_allocation;
1727
1728         /* guarantee minimum buffer size under pressure */
1729         if (kind == SK_MEM_RECV) {
1730                 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
1731                         return 1;
1732         } else { /* SK_MEM_SEND */
1733                 if (sk->sk_type == SOCK_STREAM) {
1734                         if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
1735                                 return 1;
1736                 } else if (atomic_read(&sk->sk_wmem_alloc) <
1737                            prot->sysctl_wmem[0])
1738                                 return 1;
1739         }
1740
1741         if (prot->memory_pressure) {
1742                 int alloc;
1743
1744                 if (!*prot->memory_pressure)
1745                         return 1;
1746                 alloc = percpu_counter_read_positive(prot->sockets_allocated);
1747                 if (prot->sysctl_mem[2] > alloc *
1748                     sk_mem_pages(sk->sk_wmem_queued +
1749                                  atomic_read(&sk->sk_rmem_alloc) +
1750                                  sk->sk_forward_alloc))
1751                         return 1;
1752         }
1753
1754 suppress_allocation:
1755
1756         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
1757                 sk_stream_moderate_sndbuf(sk);
1758
1759                 /* Fail only if socket is _under_ its sndbuf.
1760                  * In this case we cannot block, so that we have to fail.
1761                  */
1762                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
1763                         return 1;
1764         }
1765
1766         /* Alas. Undo changes. */
1767         sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
1768         atomic_sub(amt, prot->memory_allocated);
1769         return 0;
1770 }
1771 EXPORT_SYMBOL(__sk_mem_schedule);
1772
1773 /**
1774  *      __sk_reclaim - reclaim memory_allocated
1775  *      @sk: socket
1776  */
1777 void __sk_mem_reclaim(struct sock *sk)
1778 {
1779         struct proto *prot = sk->sk_prot;
1780
1781         atomic_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,
1782                    prot->memory_allocated);
1783         sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
1784
1785         if (prot->memory_pressure && *prot->memory_pressure &&
1786             (atomic_read(prot->memory_allocated) < prot->sysctl_mem[0]))
1787                 *prot->memory_pressure = 0;
1788 }
1789 EXPORT_SYMBOL(__sk_mem_reclaim);
1790
1791
1792 /*
1793  * Set of default routines for initialising struct proto_ops when
1794  * the protocol does not support a particular function. In certain
1795  * cases where it makes no sense for a protocol to have a "do nothing"
1796  * function, some default processing is provided.
1797  */
1798
1799 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1800 {
1801         return -EOPNOTSUPP;
1802 }
1803 EXPORT_SYMBOL(sock_no_bind);
1804
1805 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1806                     int len, int flags)
1807 {
1808         return -EOPNOTSUPP;
1809 }
1810 EXPORT_SYMBOL(sock_no_connect);
1811
1812 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1813 {
1814         return -EOPNOTSUPP;
1815 }
1816 EXPORT_SYMBOL(sock_no_socketpair);
1817
1818 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1819 {
1820         return -EOPNOTSUPP;
1821 }
1822 EXPORT_SYMBOL(sock_no_accept);
1823
1824 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1825                     int *len, int peer)
1826 {
1827         return -EOPNOTSUPP;
1828 }
1829 EXPORT_SYMBOL(sock_no_getname);
1830
1831 unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
1832 {
1833         return 0;
1834 }
1835 EXPORT_SYMBOL(sock_no_poll);
1836
1837 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1838 {
1839         return -EOPNOTSUPP;
1840 }
1841 EXPORT_SYMBOL(sock_no_ioctl);
1842
1843 int sock_no_listen(struct socket *sock, int backlog)
1844 {
1845         return -EOPNOTSUPP;
1846 }
1847 EXPORT_SYMBOL(sock_no_listen);
1848
1849 int sock_no_shutdown(struct socket *sock, int how)
1850 {
1851         return -EOPNOTSUPP;
1852 }
1853 EXPORT_SYMBOL(sock_no_shutdown);
1854
1855 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1856                     char __user *optval, unsigned int optlen)
1857 {
1858         return -EOPNOTSUPP;
1859 }
1860 EXPORT_SYMBOL(sock_no_setsockopt);
1861
1862 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1863                     char __user *optval, int __user *optlen)
1864 {
1865         return -EOPNOTSUPP;
1866 }
1867 EXPORT_SYMBOL(sock_no_getsockopt);
1868
1869 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1870                     size_t len)
1871 {
1872         return -EOPNOTSUPP;
1873 }
1874 EXPORT_SYMBOL(sock_no_sendmsg);
1875
1876 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1877                     size_t len, int flags)
1878 {
1879         return -EOPNOTSUPP;
1880 }
1881 EXPORT_SYMBOL(sock_no_recvmsg);
1882
1883 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1884 {
1885         /* Mirror missing mmap method error code */
1886         return -ENODEV;
1887 }
1888 EXPORT_SYMBOL(sock_no_mmap);
1889
1890 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1891 {
1892         ssize_t res;
1893         struct msghdr msg = {.msg_flags = flags};
1894         struct kvec iov;
1895         char *kaddr = kmap(page);
1896         iov.iov_base = kaddr + offset;
1897         iov.iov_len = size;
1898         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1899         kunmap(page);
1900         return res;
1901 }
1902 EXPORT_SYMBOL(sock_no_sendpage);
1903
1904 /*
1905  *      Default Socket Callbacks
1906  */
1907
1908 static void sock_def_wakeup(struct sock *sk)
1909 {
1910         read_lock(&sk->sk_callback_lock);
1911         if (sk_has_sleeper(sk))
1912                 wake_up_interruptible_all(sk->sk_sleep);
1913         read_unlock(&sk->sk_callback_lock);
1914 }
1915
1916 static void sock_def_error_report(struct sock *sk)
1917 {
1918         read_lock(&sk->sk_callback_lock);
1919         if (sk_has_sleeper(sk))
1920                 wake_up_interruptible_poll(sk->sk_sleep, POLLERR);
1921         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
1922         read_unlock(&sk->sk_callback_lock);
1923 }
1924
1925 static void sock_def_readable(struct sock *sk, int len)
1926 {
1927         read_lock(&sk->sk_callback_lock);
1928         if (sk_has_sleeper(sk))
1929                 wake_up_interruptible_sync_poll(sk->sk_sleep, POLLIN |
1930                                                 POLLRDNORM | POLLRDBAND);
1931         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
1932         read_unlock(&sk->sk_callback_lock);
1933 }
1934
1935 static void sock_def_write_space(struct sock *sk)
1936 {
1937         read_lock(&sk->sk_callback_lock);
1938
1939         /* Do not wake up a writer until he can make "significant"
1940          * progress.  --DaveM
1941          */
1942         if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1943                 if (sk_has_sleeper(sk))
1944                         wake_up_interruptible_sync_poll(sk->sk_sleep, POLLOUT |
1945                                                 POLLWRNORM | POLLWRBAND);
1946
1947                 /* Should agree with poll, otherwise some programs break */
1948                 if (sock_writeable(sk))
1949                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
1950         }
1951
1952         read_unlock(&sk->sk_callback_lock);
1953 }
1954
1955 static void sock_def_destruct(struct sock *sk)
1956 {
1957         kfree(sk->sk_protinfo);
1958 }
1959
1960 void sk_send_sigurg(struct sock *sk)
1961 {
1962         if (sk->sk_socket && sk->sk_socket->file)
1963                 if (send_sigurg(&sk->sk_socket->file->f_owner))
1964                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
1965 }
1966 EXPORT_SYMBOL(sk_send_sigurg);
1967
1968 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1969                     unsigned long expires)
1970 {
1971         if (!mod_timer(timer, expires))
1972                 sock_hold(sk);
1973 }
1974 EXPORT_SYMBOL(sk_reset_timer);
1975
1976 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1977 {
1978         if (timer_pending(timer) && del_timer(timer))
1979                 __sock_put(sk);
1980 }
1981 EXPORT_SYMBOL(sk_stop_timer);
1982
1983 void sock_init_data(struct socket *sock, struct sock *sk)
1984 {
1985         skb_queue_head_init(&sk->sk_receive_queue);
1986         skb_queue_head_init(&sk->sk_write_queue);
1987         skb_queue_head_init(&sk->sk_error_queue);
1988 #ifdef CONFIG_NET_DMA
1989         skb_queue_head_init(&sk->sk_async_wait_queue);
1990 #endif
1991
1992         sk->sk_send_head        =       NULL;
1993
1994         init_timer(&sk->sk_timer);
1995
1996         sk->sk_allocation       =       GFP_KERNEL;
1997         sk->sk_rcvbuf           =       sysctl_rmem_default;
1998         sk->sk_sndbuf           =       sysctl_wmem_default;
1999         sk->sk_state            =       TCP_CLOSE;
2000         sk_set_socket(sk, sock);
2001
2002         sock_set_flag(sk, SOCK_ZAPPED);
2003
2004         if (sock) {
2005                 sk->sk_type     =       sock->type;
2006                 sk->sk_sleep    =       &sock->wait;
2007                 sock->sk        =       sk;
2008         } else
2009                 sk->sk_sleep    =       NULL;
2010
2011         rwlock_init(&sk->sk_dst_lock);
2012         rwlock_init(&sk->sk_callback_lock);
2013         lockdep_set_class_and_name(&sk->sk_callback_lock,
2014                         af_callback_keys + sk->sk_family,
2015                         af_family_clock_key_strings[sk->sk_family]);
2016
2017         sk->sk_state_change     =       sock_def_wakeup;
2018         sk->sk_data_ready       =       sock_def_readable;
2019         sk->sk_write_space      =       sock_def_write_space;
2020         sk->sk_error_report     =       sock_def_error_report;
2021         sk->sk_destruct         =       sock_def_destruct;
2022
2023         sk->sk_sndmsg_page      =       NULL;
2024         sk->sk_sndmsg_off       =       0;
2025
2026         sk->sk_peercred.pid     =       0;
2027         sk->sk_peercred.uid     =       -1;
2028         sk->sk_peercred.gid     =       -1;
2029         sk->sk_write_pending    =       0;
2030         sk->sk_rcvlowat         =       1;
2031         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
2032         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
2033
2034         sk->sk_stamp = ktime_set(-1L, 0);
2035
2036         /*
2037          * Before updating sk_refcnt, we must commit prior changes to memory
2038          * (Documentation/RCU/rculist_nulls.txt for details)
2039          */
2040         smp_wmb();
2041         atomic_set(&sk->sk_refcnt, 1);
2042         atomic_set(&sk->sk_drops, 0);
2043 }
2044 EXPORT_SYMBOL(sock_init_data);
2045
2046 void lock_sock_nested(struct sock *sk, int subclass)
2047 {
2048         might_sleep();
2049         spin_lock_bh(&sk->sk_lock.slock);
2050         if (sk->sk_lock.owned)
2051                 __lock_sock(sk);
2052         sk->sk_lock.owned = 1;
2053         spin_unlock(&sk->sk_lock.slock);
2054         /*
2055          * The sk_lock has mutex_lock() semantics here:
2056          */
2057         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
2058         local_bh_enable();
2059 }
2060 EXPORT_SYMBOL(lock_sock_nested);
2061
2062 void release_sock(struct sock *sk)
2063 {
2064         /*
2065          * The sk_lock has mutex_unlock() semantics:
2066          */
2067         mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
2068
2069         spin_lock_bh(&sk->sk_lock.slock);
2070         if (sk->sk_backlog.tail)
2071                 __release_sock(sk);
2072         sk->sk_lock.owned = 0;
2073         if (waitqueue_active(&sk->sk_lock.wq))
2074                 wake_up(&sk->sk_lock.wq);
2075         spin_unlock_bh(&sk->sk_lock.slock);
2076 }
2077 EXPORT_SYMBOL(release_sock);
2078
2079 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
2080 {
2081         struct timeval tv;
2082         if (!sock_flag(sk, SOCK_TIMESTAMP))
2083                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2084         tv = ktime_to_timeval(sk->sk_stamp);
2085         if (tv.tv_sec == -1)
2086                 return -ENOENT;
2087         if (tv.tv_sec == 0) {
2088                 sk->sk_stamp = ktime_get_real();
2089                 tv = ktime_to_timeval(sk->sk_stamp);
2090         }
2091         return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
2092 }
2093 EXPORT_SYMBOL(sock_get_timestamp);
2094
2095 int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2096 {
2097         struct timespec ts;
2098         if (!sock_flag(sk, SOCK_TIMESTAMP))
2099                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2100         ts = ktime_to_timespec(sk->sk_stamp);
2101         if (ts.tv_sec == -1)
2102                 return -ENOENT;
2103         if (ts.tv_sec == 0) {
2104                 sk->sk_stamp = ktime_get_real();
2105                 ts = ktime_to_timespec(sk->sk_stamp);
2106         }
2107         return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2108 }
2109 EXPORT_SYMBOL(sock_get_timestampns);
2110
2111 void sock_enable_timestamp(struct sock *sk, int flag)
2112 {
2113         if (!sock_flag(sk, flag)) {
2114                 sock_set_flag(sk, flag);
2115                 /*
2116                  * we just set one of the two flags which require net
2117                  * time stamping, but time stamping might have been on
2118                  * already because of the other one
2119                  */
2120                 if (!sock_flag(sk,
2121                                 flag == SOCK_TIMESTAMP ?
2122                                 SOCK_TIMESTAMPING_RX_SOFTWARE :
2123                                 SOCK_TIMESTAMP))
2124                         net_enable_timestamp();
2125         }
2126 }
2127
2128 /*
2129  *      Get a socket option on an socket.
2130  *
2131  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
2132  *      asynchronous errors should be reported by getsockopt. We assume
2133  *      this means if you specify SO_ERROR (otherwise whats the point of it).
2134  */
2135 int sock_common_getsockopt(struct socket *sock, int level, int optname,
2136                            char __user *optval, int __user *optlen)
2137 {
2138         struct sock *sk = sock->sk;
2139
2140         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2141 }
2142 EXPORT_SYMBOL(sock_common_getsockopt);
2143
2144 #ifdef CONFIG_COMPAT
2145 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
2146                                   char __user *optval, int __user *optlen)
2147 {
2148         struct sock *sk = sock->sk;
2149
2150         if (sk->sk_prot->compat_getsockopt != NULL)
2151                 return sk->sk_prot->compat_getsockopt(sk, level, optname,
2152                                                       optval, optlen);
2153         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2154 }
2155 EXPORT_SYMBOL(compat_sock_common_getsockopt);
2156 #endif
2157
2158 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
2159                         struct msghdr *msg, size_t size, int flags)
2160 {
2161         struct sock *sk = sock->sk;
2162         int addr_len = 0;
2163         int err;
2164
2165         err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
2166                                    flags & ~MSG_DONTWAIT, &addr_len);
2167         if (err >= 0)
2168                 msg->msg_namelen = addr_len;
2169         return err;
2170 }
2171 EXPORT_SYMBOL(sock_common_recvmsg);
2172
2173 /*
2174  *      Set socket options on an inet socket.
2175  */
2176 int sock_common_setsockopt(struct socket *sock, int level, int optname,
2177                            char __user *optval, unsigned int optlen)
2178 {
2179         struct sock *sk = sock->sk;
2180
2181         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2182 }
2183 EXPORT_SYMBOL(sock_common_setsockopt);
2184
2185 #ifdef CONFIG_COMPAT
2186 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
2187                                   char __user *optval, unsigned int optlen)
2188 {
2189         struct sock *sk = sock->sk;
2190
2191         if (sk->sk_prot->compat_setsockopt != NULL)
2192                 return sk->sk_prot->compat_setsockopt(sk, level, optname,
2193                                                       optval, optlen);
2194         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2195 }
2196 EXPORT_SYMBOL(compat_sock_common_setsockopt);
2197 #endif
2198
2199 void sk_common_release(struct sock *sk)
2200 {
2201         if (sk->sk_prot->destroy)
2202                 sk->sk_prot->destroy(sk);
2203
2204         /*
2205          * Observation: when sock_common_release is called, processes have
2206          * no access to socket. But net still has.
2207          * Step one, detach it from networking:
2208          *
2209          * A. Remove from hash tables.
2210          */
2211
2212         sk->sk_prot->unhash(sk);
2213
2214         /*
2215          * In this point socket cannot receive new packets, but it is possible
2216          * that some packets are in flight because some CPU runs receiver and
2217          * did hash table lookup before we unhashed socket. They will achieve
2218          * receive queue and will be purged by socket destructor.
2219          *
2220          * Also we still have packets pending on receive queue and probably,
2221          * our own packets waiting in device queues. sock_destroy will drain
2222          * receive queue, but transmitted packets will delay socket destruction
2223          * until the last reference will be released.
2224          */
2225
2226         sock_orphan(sk);
2227
2228         xfrm_sk_free_policy(sk);
2229
2230         sk_refcnt_debug_release(sk);
2231         sock_put(sk);
2232 }
2233 EXPORT_SYMBOL(sk_common_release);
2234
2235 static DEFINE_RWLOCK(proto_list_lock);
2236 static LIST_HEAD(proto_list);
2237
2238 #ifdef CONFIG_PROC_FS
2239 #define PROTO_INUSE_NR  64      /* should be enough for the first time */
2240 struct prot_inuse {
2241         int val[PROTO_INUSE_NR];
2242 };
2243
2244 static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
2245
2246 #ifdef CONFIG_NET_NS
2247 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2248 {
2249         int cpu = smp_processor_id();
2250         per_cpu_ptr(net->core.inuse, cpu)->val[prot->inuse_idx] += val;
2251 }
2252 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2253
2254 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2255 {
2256         int cpu, idx = prot->inuse_idx;
2257         int res = 0;
2258
2259         for_each_possible_cpu(cpu)
2260                 res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2261
2262         return res >= 0 ? res : 0;
2263 }
2264 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2265
2266 static int sock_inuse_init_net(struct net *net)
2267 {
2268         net->core.inuse = alloc_percpu(struct prot_inuse);
2269         return net->core.inuse ? 0 : -ENOMEM;
2270 }
2271
2272 static void sock_inuse_exit_net(struct net *net)
2273 {
2274         free_percpu(net->core.inuse);
2275 }
2276
2277 static struct pernet_operations net_inuse_ops = {
2278         .init = sock_inuse_init_net,
2279         .exit = sock_inuse_exit_net,
2280 };
2281
2282 static __init int net_inuse_init(void)
2283 {
2284         if (register_pernet_subsys(&net_inuse_ops))
2285                 panic("Cannot initialize net inuse counters");
2286
2287         return 0;
2288 }
2289
2290 core_initcall(net_inuse_init);
2291 #else
2292 static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2293
2294 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2295 {
2296         __get_cpu_var(prot_inuse).val[prot->inuse_idx] += val;
2297 }
2298 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2299
2300 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2301 {
2302         int cpu, idx = prot->inuse_idx;
2303         int res = 0;
2304
2305         for_each_possible_cpu(cpu)
2306                 res += per_cpu(prot_inuse, cpu).val[idx];
2307
2308         return res >= 0 ? res : 0;
2309 }
2310 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2311 #endif
2312
2313 static void assign_proto_idx(struct proto *prot)
2314 {
2315         prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2316
2317         if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
2318                 printk(KERN_ERR "PROTO_INUSE_NR exhausted\n");
2319                 return;
2320         }
2321
2322         set_bit(prot->inuse_idx, proto_inuse_idx);
2323 }
2324
2325 static void release_proto_idx(struct proto *prot)
2326 {
2327         if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2328                 clear_bit(prot->inuse_idx, proto_inuse_idx);
2329 }
2330 #else
2331 static inline void assign_proto_idx(struct proto *prot)
2332 {
2333 }
2334
2335 static inline void release_proto_idx(struct proto *prot)
2336 {
2337 }
2338 #endif
2339
2340 int proto_register(struct proto *prot, int alloc_slab)
2341 {
2342         if (alloc_slab) {
2343                 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
2344                                         SLAB_HWCACHE_ALIGN | prot->slab_flags,
2345                                         NULL);
2346
2347                 if (prot->slab == NULL) {
2348                         printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
2349                                prot->name);
2350                         goto out;
2351                 }
2352
2353                 if (prot->rsk_prot != NULL) {
2354                         static const char mask[] = "request_sock_%s";
2355
2356                         prot->rsk_prot->slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
2357                         if (prot->rsk_prot->slab_name == NULL)
2358                                 goto out_free_sock_slab;
2359
2360                         sprintf(prot->rsk_prot->slab_name, mask, prot->name);
2361                         prot->rsk_prot->slab = kmem_cache_create(prot->rsk_prot->slab_name,
2362                                                                  prot->rsk_prot->obj_size, 0,
2363                                                                  SLAB_HWCACHE_ALIGN, NULL);
2364
2365                         if (prot->rsk_prot->slab == NULL) {
2366                                 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
2367                                        prot->name);
2368                                 goto out_free_request_sock_slab_name;
2369                         }
2370                 }
2371
2372                 if (prot->twsk_prot != NULL) {
2373                         static const char mask[] = "tw_sock_%s";
2374
2375                         prot->twsk_prot->twsk_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
2376
2377                         if (prot->twsk_prot->twsk_slab_name == NULL)
2378                                 goto out_free_request_sock_slab;
2379
2380                         sprintf(prot->twsk_prot->twsk_slab_name, mask, prot->name);
2381                         prot->twsk_prot->twsk_slab =
2382                                 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
2383                                                   prot->twsk_prot->twsk_obj_size,
2384                                                   0,
2385                                                   SLAB_HWCACHE_ALIGN |
2386                                                         prot->slab_flags,
2387                                                   NULL);
2388                         if (prot->twsk_prot->twsk_slab == NULL)
2389                                 goto out_free_timewait_sock_slab_name;
2390                 }
2391         }
2392
2393         write_lock(&proto_list_lock);
2394         list_add(&prot->node, &proto_list);
2395         assign_proto_idx(prot);
2396         write_unlock(&proto_list_lock);
2397         return 0;
2398
2399 out_free_timewait_sock_slab_name:
2400         kfree(prot->twsk_prot->twsk_slab_name);
2401 out_free_request_sock_slab:
2402         if (prot->rsk_prot && prot->rsk_prot->slab) {
2403                 kmem_cache_destroy(prot->rsk_prot->slab);
2404                 prot->rsk_prot->slab = NULL;
2405         }
2406 out_free_request_sock_slab_name:
2407         kfree(prot->rsk_prot->slab_name);
2408 out_free_sock_slab:
2409         kmem_cache_destroy(prot->slab);
2410         prot->slab = NULL;
2411 out:
2412         return -ENOBUFS;
2413 }
2414 EXPORT_SYMBOL(proto_register);
2415
2416 void proto_unregister(struct proto *prot)
2417 {
2418         write_lock(&proto_list_lock);
2419         release_proto_idx(prot);
2420         list_del(&prot->node);
2421         write_unlock(&proto_list_lock);
2422
2423         if (prot->slab != NULL) {
2424                 kmem_cache_destroy(prot->slab);
2425                 prot->slab = NULL;
2426         }
2427
2428         if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
2429                 kmem_cache_destroy(prot->rsk_prot->slab);
2430                 kfree(prot->rsk_prot->slab_name);
2431                 prot->rsk_prot->slab = NULL;
2432         }
2433
2434         if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
2435                 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
2436                 kfree(prot->twsk_prot->twsk_slab_name);
2437                 prot->twsk_prot->twsk_slab = NULL;
2438         }
2439 }
2440 EXPORT_SYMBOL(proto_unregister);
2441
2442 #ifdef CONFIG_PROC_FS
2443 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
2444         __acquires(proto_list_lock)
2445 {
2446         read_lock(&proto_list_lock);
2447         return seq_list_start_head(&proto_list, *pos);
2448 }
2449
2450 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2451 {
2452         return seq_list_next(v, &proto_list, pos);
2453 }
2454
2455 static void proto_seq_stop(struct seq_file *seq, void *v)
2456         __releases(proto_list_lock)
2457 {
2458         read_unlock(&proto_list_lock);
2459 }
2460
2461 static char proto_method_implemented(const void *method)
2462 {
2463         return method == NULL ? 'n' : 'y';
2464 }
2465
2466 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
2467 {
2468         seq_printf(seq, "%-9s %4u %6d  %6d   %-3s %6u   %-3s  %-10s "
2469                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
2470                    proto->name,
2471                    proto->obj_size,
2472                    sock_prot_inuse_get(seq_file_net(seq), proto),
2473                    proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
2474                    proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
2475                    proto->max_header,
2476                    proto->slab == NULL ? "no" : "yes",
2477                    module_name(proto->owner),
2478                    proto_method_implemented(proto->close),
2479                    proto_method_implemented(proto->connect),
2480                    proto_method_implemented(proto->disconnect),
2481                    proto_method_implemented(proto->accept),
2482                    proto_method_implemented(proto->ioctl),
2483                    proto_method_implemented(proto->init),
2484                    proto_method_implemented(proto->destroy),
2485                    proto_method_implemented(proto->shutdown),
2486                    proto_method_implemented(proto->setsockopt),
2487                    proto_method_implemented(proto->getsockopt),
2488                    proto_method_implemented(proto->sendmsg),
2489                    proto_method_implemented(proto->recvmsg),
2490                    proto_method_implemented(proto->sendpage),
2491                    proto_method_implemented(proto->bind),
2492                    proto_method_implemented(proto->backlog_rcv),
2493                    proto_method_implemented(proto->hash),
2494                    proto_method_implemented(proto->unhash),
2495                    proto_method_implemented(proto->get_port),
2496                    proto_method_implemented(proto->enter_memory_pressure));
2497 }
2498
2499 static int proto_seq_show(struct seq_file *seq, void *v)
2500 {
2501         if (v == &proto_list)
2502                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
2503                            "protocol",
2504                            "size",
2505                            "sockets",
2506                            "memory",
2507                            "press",
2508                            "maxhdr",
2509                            "slab",
2510                            "module",
2511                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
2512         else
2513                 proto_seq_printf(seq, list_entry(v, struct proto, node));
2514         return 0;
2515 }
2516
2517 static const struct seq_operations proto_seq_ops = {
2518         .start  = proto_seq_start,
2519         .next   = proto_seq_next,
2520         .stop   = proto_seq_stop,
2521         .show   = proto_seq_show,
2522 };
2523
2524 static int proto_seq_open(struct inode *inode, struct file *file)
2525 {
2526         return seq_open_net(inode, file, &proto_seq_ops,
2527                             sizeof(struct seq_net_private));
2528 }
2529
2530 static const struct file_operations proto_seq_fops = {
2531         .owner          = THIS_MODULE,
2532         .open           = proto_seq_open,
2533         .read           = seq_read,
2534         .llseek         = seq_lseek,
2535         .release        = seq_release_net,
2536 };
2537
2538 static __net_init int proto_init_net(struct net *net)
2539 {
2540         if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
2541                 return -ENOMEM;
2542
2543         return 0;
2544 }
2545
2546 static __net_exit void proto_exit_net(struct net *net)
2547 {
2548         proc_net_remove(net, "protocols");
2549 }
2550
2551
2552 static __net_initdata struct pernet_operations proto_net_ops = {
2553         .init = proto_init_net,
2554         .exit = proto_exit_net,
2555 };
2556
2557 static int __init proto_init(void)
2558 {
2559         return register_pernet_subsys(&proto_net_ops);
2560 }
2561
2562 subsys_initcall(proto_init);
2563
2564 #endif /* PROC_FS */