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