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