net/core/sock.c

   1 /*
   2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
   3  *              operating system.  INET is implemented using the  BSD Socket
   4  *              interface as the means of communication with the user level.
   5  *
   6  *              Generic socket support routines. Memory allocators, socket lock/release
   7  *              handler for protocols to use and generic option handler.
   8  *
   9  *
  10  * Version:     $Id: sock.c,v 1.117 2002/02/01 22:01:03 davem Exp $
  11  *
  12  * Authors:     Ross Biro
  13  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
  14  *              Florian La Roche, <flla@stud.uni-sb.de>
  15  *              Alan Cox, <A.Cox@swansea.ac.uk>
  16  *
  17  * Fixes:
  18  *              Alan Cox        :       Numerous verify_area() problems
  19  *              Alan Cox        :       Connecting on a connecting socket
  20  *                                      now returns an error for tcp.
  21  *              Alan Cox        :       sock->protocol is set correctly.
  22  *                                      and is not sometimes left as 0.
  23  *              Alan Cox        :       connect handles icmp errors on a
  24  *                                      connect properly. Unfortunately there
  25  *                                      is a restart syscall nasty there. I
  26  *                                      can't match BSD without hacking the C
  27  *                                      library. Ideas urgently sought!
  28  *              Alan Cox        :       Disallow bind() to addresses that are
  29  *                                      not ours - especially broadcast ones!!
  30  *              Alan Cox        :       Socket 1024 _IS_ ok for users. (fencepost)
  31  *              Alan Cox        :       sock_wfree/sock_rfree don't destroy sockets,
  32  *                                      instead they leave that for the DESTROY timer.
  33  *              Alan Cox        :       Clean up error flag in accept
  34  *              Alan Cox        :       TCP ack handling is buggy, the DESTROY timer
  35  *                                      was buggy. Put a remove_sock() in the handler
  36  *                                      for memory when we hit 0. Also altered the timer
  37  *                                      code. The ACK stuff can wait and needs major
  38  *                                      TCP layer surgery.
  39  *              Alan Cox        :       Fixed TCP ack bug, removed remove sock
  40  *                                      and fixed timer/inet_bh race.
  41  *              Alan Cox        :       Added zapped flag for TCP
  42  *              Alan Cox        :       Move kfree_skb into skbuff.c and tidied up surplus code
  43  *              Alan Cox        :       for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
  44  *              Alan Cox        :       kfree_s calls now are kfree_skbmem so we can track skb resources
  45  *              Alan Cox        :       Supports socket option broadcast now as does udp. Packet and raw need fixing.
  46  *              Alan Cox        :       Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
  47  *              Rick Sladkey    :       Relaxed UDP rules for matching packets.
  48  *              C.E.Hawkins     :       IFF_PROMISC/SIOCGHWADDR support
  49  *      Pauline Middelink       :       identd support
  50  *              Alan Cox        :       Fixed connect() taking signals I think.
  51  *              Alan Cox        :       SO_LINGER supported
  52  *              Alan Cox        :       Error reporting fixes
  53  *              Anonymous       :       inet_create tidied up (sk->reuse setting)
  54  *              Alan Cox        :       inet sockets don't set sk->type!
  55  *              Alan Cox        :       Split socket option code
  56  *              Alan Cox        :       Callbacks
  57  *              Alan Cox        :       Nagle flag for Charles & Johannes stuff
  58  *              Alex            :       Removed restriction on inet fioctl
  59  *              Alan Cox        :       Splitting INET from NET core
  60  *              Alan Cox        :       Fixed bogus SO_TYPE handling in getsockopt()
  61  *              Adam Caldwell   :       Missing return in SO_DONTROUTE/SO_DEBUG code
  62  *              Alan Cox        :       Split IP from generic code
  63  *              Alan Cox        :       New kfree_skbmem()
  64  *              Alan Cox        :       Make SO_DEBUG superuser only.
  65  *              Alan Cox        :       Allow anyone to clear SO_DEBUG
  66  *                                      (compatibility fix)
  67  *              Alan Cox        :       Added optimistic memory grabbing for AF_UNIX throughput.
  68  *              Alan Cox        :       Allocator for a socket is settable.
  69  *              Alan Cox        :       SO_ERROR includes soft errors.
  70  *              Alan Cox        :       Allow NULL arguments on some SO_ opts
  71  *              Alan Cox        :       Generic socket allocation to make hooks
  72  *                                      easier (suggested by Craig Metz).
  73  *              Michael Pall    :       SO_ERROR returns positive errno again
  74  *              Steve Whitehouse:       Added default destructor to free
  75  *                                      protocol private data.
  76  *              Steve Whitehouse:       Added various other default routines
  77  *                                      common to several socket families.
  78  *              Chris Evans     :       Call suser() check last on F_SETOWN
  79  *              Jay Schulist    :       Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
  80  *              Andi Kleen      :       Add sock_kmalloc()/sock_kfree_s()
  81  *              Andi Kleen      :       Fix write_space callback
  82  *              Chris Evans     :       Security fixes - signedness again
  83  *              Arnaldo C. Melo :       cleanups, use skb_queue_purge
  84  *
  85  * To Fix:
  86  *
  87  *
  88  *              This program is free software; you can redistribute it and/or
  89  *              modify it under the terms of the GNU General Public License
  90  *              as published by the Free Software Foundation; either version
  91  *              2 of the License, or (at your option) any later version.
  92  */
  93
  94 #include <linux/config.h>
  95 #include <linux/errno.h>
  96 #include <linux/types.h>
  97 #include <linux/socket.h>
  98 #include <linux/in.h>
  99 #include <linux/kernel.h>
 100 #include <linux/module.h>
 101 #include <linux/proc_fs.h>
 102 #include <linux/seq_file.h>
 103 #include <linux/sched.h>
 104 #include <linux/timer.h>
 105 #include <linux/string.h>
 106 #include <linux/sockios.h>
 107 #include <linux/net.h>
 108 #include <linux/mm.h>
 109 #include <linux/slab.h>
 110 #include <linux/interrupt.h>
 111 #include <linux/poll.h>
 112 #include <linux/tcp.h>
 113 #include <linux/init.h>
 114
 115 #include <asm/uaccess.h>
 116 #include <asm/system.h>
 117
 118 #include <linux/netdevice.h>
 119 #include <net/protocol.h>
 120 #include <linux/skbuff.h>
 121 #include <net/sock.h>
 122 #include <net/xfrm.h>
 123 #include <linux/ipsec.h>
 124
 125 #include <linux/filter.h>
 126
 127 #ifdef CONFIG_INET
 128 #include <net/tcp.h>
 129 #endif
 130
 131 /* Take into consideration the size of the struct sk_buff overhead in the
 132  * determination of these values, since that is non-constant across
 133  * platforms.  This makes socket queueing behavior and performance
 134  * not depend upon such differences.
 135  */
 136 #define _SK_MEM_PACKETS         256
 137 #define _SK_MEM_OVERHEAD        (sizeof(struct sk_buff) + 256)
 138 #define SK_WMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 139 #define SK_RMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
 140
 141 /* Run time adjustable parameters. */
 142 __u32 sysctl_wmem_max = SK_WMEM_MAX;
 143 __u32 sysctl_rmem_max = SK_RMEM_MAX;
 144 __u32 sysctl_wmem_default = SK_WMEM_MAX;
 145 __u32 sysctl_rmem_default = SK_RMEM_MAX;
 146
 147 /* Maximal space eaten by iovec or ancilliary data plus some space */
 148 int sysctl_optmem_max = sizeof(unsigned long)*(2*UIO_MAXIOV + 512);
 149
 150 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
 151 {
 152         struct timeval tv;
 153
 154         if (optlen < sizeof(tv))
 155                 return -EINVAL;
 156         if (copy_from_user(&tv, optval, sizeof(tv)))
 157                 return -EFAULT;
 158
 159         *timeo_p = MAX_SCHEDULE_TIMEOUT;
 160         if (tv.tv_sec == 0 && tv.tv_usec == 0)
 161                 return 0;
 162         if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
 163                 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
 164         return 0;
 165 }
 166
 167 static void sock_warn_obsolete_bsdism(const char *name)
 168 {
 169         static int warned;
 170         static char warncomm[TASK_COMM_LEN];
 171         if (strcmp(warncomm, current->comm) && warned < 5) {
 172                 strcpy(warncomm,  current->comm);
 173                 printk(KERN_WARNING "process `%s' is using obsolete "
 174                        "%s SO_BSDCOMPAT\n", warncomm, name);
 175                 warned++;
 176         }
 177 }
 178
 179 static void sock_disable_timestamp(struct sock *sk)
 180 {
 181         if (sock_flag(sk, SOCK_TIMESTAMP)) {
 182                 sock_reset_flag(sk, SOCK_TIMESTAMP);
 183                 net_disable_timestamp();
 184         }
 185 }
 186
 187
 188 /*
 189  *      This is meant for all protocols to use and covers goings on
 190  *      at the socket level. Everything here is generic.
 191  */
 192
 193 int sock_setsockopt(struct socket *sock, int level, int optname,
 194                     char __user *optval, int optlen)
 195 {
 196         struct sock *sk=sock->sk;
 197         struct sk_filter *filter;
 198         int val;
 199         int valbool;
 200         struct linger ling;
 201         int ret = 0;
 202
 203         /*
 204          *      Options without arguments
 205          */
 206
 207 #ifdef SO_DONTLINGER            /* Compatibility item... */
 208         switch (optname) {
 209                 case SO_DONTLINGER:
 210                         sock_reset_flag(sk, SOCK_LINGER);
 211                         return 0;
 212         }
 213 #endif
 214
 215         if(optlen<sizeof(int))
 216                 return(-EINVAL);
 217
 218         if (get_user(val, (int __user *)optval))
 219                 return -EFAULT;
 220
 221         valbool = val?1:0;
 222
 223         lock_sock(sk);
 224
 225         switch(optname)
 226         {
 227                 case SO_DEBUG:
 228                         if(val && !capable(CAP_NET_ADMIN))
 229                         {
 230                                 ret = -EACCES;
 231                         }
 232                         else if (valbool)
 233                                 sock_set_flag(sk, SOCK_DBG);
 234                         else
 235                                 sock_reset_flag(sk, SOCK_DBG);
 236                         break;
 237                 case SO_REUSEADDR:
 238                         sk->sk_reuse = valbool;
 239                         break;
 240                 case SO_TYPE:
 241                 case SO_ERROR:
 242                         ret = -ENOPROTOOPT;
 243                         break;
 244                 case SO_DONTROUTE:
 245                         if (valbool)
 246                                 sock_set_flag(sk, SOCK_LOCALROUTE);
 247                         else
 248                                 sock_reset_flag(sk, SOCK_LOCALROUTE);
 249                         break;
 250                 case SO_BROADCAST:
 251                         sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
 252                         break;
 253                 case SO_SNDBUF:
 254                         /* Don't error on this BSD doesn't and if you think
 255                            about it this is right. Otherwise apps have to
 256                            play 'guess the biggest size' games. RCVBUF/SNDBUF
 257                            are treated in BSD as hints */
 258
 259                         if (val > sysctl_wmem_max)
 260                                 val = sysctl_wmem_max;
 261
 262                         sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
 263                         if ((val * 2) < SOCK_MIN_SNDBUF)
 264                                 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
 265                         else
 266                                 sk->sk_sndbuf = val * 2;
 267
 268                         /*
 269                          *      Wake up sending tasks if we
 270                          *      upped the value.
 271                          */
 272                         sk->sk_write_space(sk);
 273                         break;
 274
 275                 case SO_RCVBUF:
 276                         /* Don't error on this BSD doesn't and if you think
 277                            about it this is right. Otherwise apps have to
 278                            play 'guess the biggest size' games. RCVBUF/SNDBUF
 279                            are treated in BSD as hints */
 280
 281                         if (val > sysctl_rmem_max)
 282                                 val = sysctl_rmem_max;
 283
 284                         sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
 285                         /* FIXME: is this lower bound the right one? */
 286                         if ((val * 2) < SOCK_MIN_RCVBUF)
 287                                 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
 288                         else
 289                                 sk->sk_rcvbuf = val * 2;
 290                         break;
 291
 292                 case SO_KEEPALIVE:
 293 #ifdef CONFIG_INET
 294                         if (sk->sk_protocol == IPPROTO_TCP)
 295                                 tcp_set_keepalive(sk, valbool);
 296 #endif
 297                         sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
 298                         break;
 299
 300                 case SO_OOBINLINE:
 301                         sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
 302                         break;
 303
 304                 case SO_NO_CHECK:
 305                         sk->sk_no_check = valbool;
 306                         break;
 307
 308                 case SO_PRIORITY:
 309                         if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
 310                                 sk->sk_priority = val;
 311                         else
 312                                 ret = -EPERM;
 313                         break;
 314
 315                 case SO_LINGER:
 316                         if(optlen<sizeof(ling)) {
 317                                 ret = -EINVAL;  /* 1003.1g */
 318                                 break;
 319                         }
 320                         if (copy_from_user(&ling,optval,sizeof(ling))) {
 321                                 ret = -EFAULT;
 322                                 break;
 323                         }
 324                         if (!ling.l_onoff)
 325                                 sock_reset_flag(sk, SOCK_LINGER);
 326                         else {
 327 #if (BITS_PER_LONG == 32)
 328                                 if (ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
 329                                         sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
 330                                 else
 331 #endif
 332                                         sk->sk_lingertime = ling.l_linger * HZ;
 333                                 sock_set_flag(sk, SOCK_LINGER);
 334                         }
 335                         break;
 336
 337                 case SO_BSDCOMPAT:
 338                         sock_warn_obsolete_bsdism("setsockopt");
 339                         break;
 340
 341                 case SO_PASSCRED:
 342                         if (valbool)
 343                                 set_bit(SOCK_PASSCRED, &sock->flags);
 344                         else
 345                                 clear_bit(SOCK_PASSCRED, &sock->flags);
 346                         break;
 347
 348                 case SO_TIMESTAMP:
 349                         if (valbool)  {
 350                                 sock_set_flag(sk, SOCK_RCVTSTAMP);
 351                                 sock_enable_timestamp(sk);
 352                         } else
 353                                 sock_reset_flag(sk, SOCK_RCVTSTAMP);
 354                         break;
 355
 356                 case SO_RCVLOWAT:
 357                         if (val < 0)
 358                                 val = INT_MAX;
 359                         sk->sk_rcvlowat = val ? : 1;
 360                         break;
 361
 362                 case SO_RCVTIMEO:
 363                         ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
 364                         break;
 365
 366                 case SO_SNDTIMEO:
 367                         ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
 368                         break;
 369
 370 #ifdef CONFIG_NETDEVICES
 371                 case SO_BINDTODEVICE:
 372                 {
 373                         char devname[IFNAMSIZ];
 374
 375                         /* Sorry... */
 376                         if (!capable(CAP_NET_RAW)) {
 377                                 ret = -EPERM;
 378                                 break;
 379                         }
 380
 381                         /* Bind this socket to a particular device like "eth0",
 382                          * as specified in the passed interface name. If the
 383                          * name is "" or the option length is zero the socket
 384                          * is not bound.
 385                          */
 386
 387                         if (!valbool) {
 388                                 sk->sk_bound_dev_if = 0;
 389                         } else {
 390                                 if (optlen > IFNAMSIZ)
 391                                         optlen = IFNAMSIZ;
 392                                 if (copy_from_user(devname, optval, optlen)) {
 393                                         ret = -EFAULT;
 394                                         break;
 395                                 }
 396
 397                                 /* Remove any cached route for this socket. */
 398                                 sk_dst_reset(sk);
 399
 400                                 if (devname[0] == '\0') {
 401                                         sk->sk_bound_dev_if = 0;
 402                                 } else {
 403                                         struct net_device *dev = dev_get_by_name(devname);
 404                                         if (!dev) {
 405                                                 ret = -ENODEV;
 406                                                 break;
 407                                         }
 408                                         sk->sk_bound_dev_if = dev->ifindex;
 409                                         dev_put(dev);
 410                                 }
 411                         }
 412                         break;
 413                 }
 414 #endif
 415
 416
 417                 case SO_ATTACH_FILTER:
 418                         ret = -EINVAL;
 419                         if (optlen == sizeof(struct sock_fprog)) {
 420                                 struct sock_fprog fprog;
 421
 422                                 ret = -EFAULT;
 423                                 if (copy_from_user(&fprog, optval, sizeof(fprog)))
 424                                         break;
 425
 426                                 ret = sk_attach_filter(&fprog, sk);
 427                         }
 428                         break;
 429
 430                 case SO_DETACH_FILTER:
 431                         spin_lock_bh(&sk->sk_lock.slock);
 432                         filter = sk->sk_filter;
 433                         if (filter) {
 434                                 sk->sk_filter = NULL;
 435                                 spin_unlock_bh(&sk->sk_lock.slock);
 436                                 sk_filter_release(sk, filter);
 437                                 break;
 438                         }
 439                         spin_unlock_bh(&sk->sk_lock.slock);
 440                         ret = -ENONET;
 441                         break;
 442
 443                 /* We implement the SO_SNDLOWAT etc to
 444                    not be settable (1003.1g 5.3) */
 445                 default:
 446                         ret = -ENOPROTOOPT;
 447                         break;
 448         }
 449         release_sock(sk);
 450         return ret;
 451 }
 452
 453
 454 int sock_getsockopt(struct socket *sock, int level, int optname,
 455                     char __user *optval, int __user *optlen)
 456 {
 457         struct sock *sk = sock->sk;
 458
 459         union
 460         {
 461                 int val;
 462                 struct linger ling;
 463                 struct timeval tm;
 464         } v;
 465
 466         unsigned int lv = sizeof(int);
 467         int len;
 468
 469         if(get_user(len,optlen))
 470                 return -EFAULT;
 471         if(len < 0)
 472                 return -EINVAL;
 473
 474         switch(optname)
 475         {
 476                 case SO_DEBUG:
 477                         v.val = sock_flag(sk, SOCK_DBG);
 478                         break;
 479
 480                 case SO_DONTROUTE:
 481                         v.val = sock_flag(sk, SOCK_LOCALROUTE);
 482                         break;
 483
 484                 case SO_BROADCAST:
 485                         v.val = !!sock_flag(sk, SOCK_BROADCAST);
 486                         break;
 487
 488                 case SO_SNDBUF:
 489                         v.val = sk->sk_sndbuf;
 490                         break;
 491
 492                 case SO_RCVBUF:
 493                         v.val = sk->sk_rcvbuf;
 494                         break;
 495
 496                 case SO_REUSEADDR:
 497                         v.val = sk->sk_reuse;
 498                         break;
 499
 500                 case SO_KEEPALIVE:
 501                         v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
 502                         break;
 503
 504                 case SO_TYPE:
 505                         v.val = sk->sk_type;
 506                         break;
 507
 508                 case SO_ERROR:
 509                         v.val = -sock_error(sk);
 510                         if(v.val==0)
 511                                 v.val = xchg(&sk->sk_err_soft, 0);
 512                         break;
 513
 514                 case SO_OOBINLINE:
 515                         v.val = !!sock_flag(sk, SOCK_URGINLINE);
 516                         break;
 517
 518                 case SO_NO_CHECK:
 519                         v.val = sk->sk_no_check;
 520                         break;
 521
 522                 case SO_PRIORITY:
 523                         v.val = sk->sk_priority;
 524                         break;
 525
 526                 case SO_LINGER:
 527                         lv              = sizeof(v.ling);
 528                         v.ling.l_onoff  = !!sock_flag(sk, SOCK_LINGER);
 529                         v.ling.l_linger = sk->sk_lingertime / HZ;
 530                         break;
 531
 532                 case SO_BSDCOMPAT:
 533                         sock_warn_obsolete_bsdism("getsockopt");
 534                         break;
 535
 536                 case SO_TIMESTAMP:
 537                         v.val = sock_flag(sk, SOCK_RCVTSTAMP);
 538                         break;
 539
 540                 case SO_RCVTIMEO:
 541                         lv=sizeof(struct timeval);
 542                         if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
 543                                 v.tm.tv_sec = 0;
 544                                 v.tm.tv_usec = 0;
 545                         } else {
 546                                 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
 547                                 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
 548                         }
 549                         break;
 550
 551                 case SO_SNDTIMEO:
 552                         lv=sizeof(struct timeval);
 553                         if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
 554                                 v.tm.tv_sec = 0;
 555                                 v.tm.tv_usec = 0;
 556                         } else {
 557                                 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
 558                                 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
 559                         }
 560                         break;
 561
 562                 case SO_RCVLOWAT:
 563                         v.val = sk->sk_rcvlowat;
 564                         break;
 565
 566                 case SO_SNDLOWAT:
 567                         v.val=1;
 568                         break;
 569
 570                 case SO_PASSCRED:
 571                         v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
 572                         break;
 573
 574                 case SO_PEERCRED:
 575                         if (len > sizeof(sk->sk_peercred))
 576                                 len = sizeof(sk->sk_peercred);
 577                         if (copy_to_user(optval, &sk->sk_peercred, len))
 578                                 return -EFAULT;
 579                         goto lenout;
 580
 581                 case SO_PEERNAME:
 582                 {
 583                         char address[128];
 584
 585                         if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
 586                                 return -ENOTCONN;
 587                         if (lv < len)
 588                                 return -EINVAL;
 589                         if (copy_to_user(optval, address, len))
 590                                 return -EFAULT;
 591                         goto lenout;
 592                 }
 593
 594                 /* Dubious BSD thing... Probably nobody even uses it, but
 595                  * the UNIX standard wants it for whatever reason... -DaveM
 596                  */
 597                 case SO_ACCEPTCONN:
 598                         v.val = sk->sk_state == TCP_LISTEN;
 599                         break;
 600
 601                 case SO_PEERSEC:
 602                         return security_socket_getpeersec(sock, optval, optlen, len);
 603
 604                 default:
 605                         return(-ENOPROTOOPT);
 606         }
 607         if (len > lv)
 608                 len = lv;
 609         if (copy_to_user(optval, &v, len))
 610                 return -EFAULT;
 611 lenout:
 612         if (put_user(len, optlen))
 613                 return -EFAULT;
 614         return 0;
 615 }
 616
 617 /**
 618  *      sk_alloc - All socket objects are allocated here
 619  *      @family: protocol family
 620  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
 621  *      @prot: struct proto associated with this new sock instance
 622  *      @zero_it: if we should zero the newly allocated sock
 623  */
 624 struct sock *sk_alloc(int family, int priority, struct proto *prot, int zero_it)
 625 {
 626         struct sock *sk = NULL;
 627         kmem_cache_t *slab = prot->slab;
 628
 629         if (slab != NULL)
 630                 sk = kmem_cache_alloc(slab, priority);
 631         else
 632                 sk = kmalloc(prot->obj_size, priority);
 633
 634         if (sk) {
 635                 if (zero_it) {
 636                         memset(sk, 0, prot->obj_size);
 637                         sk->sk_family = family;
 638                         /*
 639                          * See comment in struct sock definition to understand
 640                          * why we need sk_prot_creator -acme
 641                          */
 642                         sk->sk_prot = sk->sk_prot_creator = prot;
 643                         sock_lock_init(sk);
 644                 }
 645
 646                 if (security_sk_alloc(sk, family, priority)) {
 647                         if (slab != NULL)
 648                                 kmem_cache_free(slab, sk);
 649                         else
 650                                 kfree(sk);
 651                         sk = NULL;
 652                 } else
 653                         __module_get(prot->owner);
 654         }
 655         return sk;
 656 }
 657
 658 void sk_free(struct sock *sk)
 659 {
 660         struct sk_filter *filter;
 661         struct module *owner = sk->sk_prot_creator->owner;
 662
 663         if (sk->sk_destruct)
 664                 sk->sk_destruct(sk);
 665
 666         filter = sk->sk_filter;
 667         if (filter) {
 668                 sk_filter_release(sk, filter);
 669                 sk->sk_filter = NULL;
 670         }
 671
 672         sock_disable_timestamp(sk);
 673
 674         if (atomic_read(&sk->sk_omem_alloc))
 675                 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
 676                        __FUNCTION__, atomic_read(&sk->sk_omem_alloc));
 677
 678         security_sk_free(sk);
 679         if (sk->sk_prot_creator->slab != NULL)
 680                 kmem_cache_free(sk->sk_prot_creator->slab, sk);
 681         else
 682                 kfree(sk);
 683         module_put(owner);
 684 }
 685
 686 void __init sk_init(void)
 687 {
 688         if (num_physpages <= 4096) {
 689                 sysctl_wmem_max = 32767;
 690                 sysctl_rmem_max = 32767;
 691                 sysctl_wmem_default = 32767;
 692                 sysctl_rmem_default = 32767;
 693         } else if (num_physpages >= 131072) {
 694                 sysctl_wmem_max = 131071;
 695                 sysctl_rmem_max = 131071;
 696         }
 697 }
 698
 699 /*
 700  *      Simple resource managers for sockets.
 701  */
 702
 703
 704 /*
 705  * Write buffer destructor automatically called from kfree_skb.
 706  */
 707 void sock_wfree(struct sk_buff *skb)
 708 {
 709         struct sock *sk = skb->sk;
 710
 711         /* In case it might be waiting for more memory. */
 712         atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
 713         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
 714                 sk->sk_write_space(sk);
 715         sock_put(sk);
 716 }
 717
 718 /*
 719  * Read buffer destructor automatically called from kfree_skb.
 720  */
 721 void sock_rfree(struct sk_buff *skb)
 722 {
 723         struct sock *sk = skb->sk;
 724
 725         atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
 726 }
 727
 728
 729 int sock_i_uid(struct sock *sk)
 730 {
 731         int uid;
 732
 733         read_lock(&sk->sk_callback_lock);
 734         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
 735         read_unlock(&sk->sk_callback_lock);
 736         return uid;
 737 }
 738
 739 unsigned long sock_i_ino(struct sock *sk)
 740 {
 741         unsigned long ino;
 742
 743         read_lock(&sk->sk_callback_lock);
 744         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
 745         read_unlock(&sk->sk_callback_lock);
 746         return ino;
 747 }
 748
 749 /*
 750  * Allocate a skb from the socket's send buffer.
 751  */
 752 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
 753 {
 754         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
 755                 struct sk_buff * skb = alloc_skb(size, priority);
 756                 if (skb) {
 757                         skb_set_owner_w(skb, sk);
 758                         return skb;
 759                 }
 760         }
 761         return NULL;
 762 }
 763
 764 /*
 765  * Allocate a skb from the socket's receive buffer.
 766  */
 767 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
 768 {
 769         if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
 770                 struct sk_buff *skb = alloc_skb(size, priority);
 771                 if (skb) {
 772                         skb_set_owner_r(skb, sk);
 773                         return skb;
 774                 }
 775         }
 776         return NULL;
 777 }
 778
 779 /*
 780  * Allocate a memory block from the socket's option memory buffer.
 781  */
 782 void *sock_kmalloc(struct sock *sk, int size, int priority)
 783 {
 784         if ((unsigned)size <= sysctl_optmem_max &&
 785             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
 786                 void *mem;
 787                 /* First do the add, to avoid the race if kmalloc
 788                  * might sleep.
 789                  */
 790                 atomic_add(size, &sk->sk_omem_alloc);
 791                 mem = kmalloc(size, priority);
 792                 if (mem)
 793                         return mem;
 794                 atomic_sub(size, &sk->sk_omem_alloc);
 795         }
 796         return NULL;
 797 }
 798
 799 /*
 800  * Free an option memory block.
 801  */
 802 void sock_kfree_s(struct sock *sk, void *mem, int size)
 803 {
 804         kfree(mem);
 805         atomic_sub(size, &sk->sk_omem_alloc);
 806 }
 807
 808 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
 809    I think, these locks should be removed for datagram sockets.
 810  */
 811 static long sock_wait_for_wmem(struct sock * sk, long timeo)
 812 {
 813         DEFINE_WAIT(wait);
 814
 815         clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 816         for (;;) {
 817                 if (!timeo)
 818                         break;
 819                 if (signal_pending(current))
 820                         break;
 821                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
 822                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
 823                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
 824                         break;
 825                 if (sk->sk_shutdown & SEND_SHUTDOWN)
 826                         break;
 827                 if (sk->sk_err)
 828                         break;
 829                 timeo = schedule_timeout(timeo);
 830         }
 831         finish_wait(sk->sk_sleep, &wait);
 832         return timeo;
 833 }
 834
 835
 836 /*
 837  *      Generic send/receive buffer handlers
 838  */
 839
 840 static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
 841                                             unsigned long header_len,
 842                                             unsigned long data_len,
 843                                             int noblock, int *errcode)
 844 {
 845         struct sk_buff *skb;
 846         unsigned int gfp_mask;
 847         long timeo;
 848         int err;
 849
 850         gfp_mask = sk->sk_allocation;
 851         if (gfp_mask & __GFP_WAIT)
 852                 gfp_mask |= __GFP_REPEAT;
 853
 854         timeo = sock_sndtimeo(sk, noblock);
 855         while (1) {
 856                 err = sock_error(sk);
 857                 if (err != 0)
 858                         goto failure;
 859
 860                 err = -EPIPE;
 861                 if (sk->sk_shutdown & SEND_SHUTDOWN)
 862                         goto failure;
 863
 864                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
 865                         skb = alloc_skb(header_len, sk->sk_allocation);
 866                         if (skb) {
 867                                 int npages;
 868                                 int i;
 869
 870                                 /* No pages, we're done... */
 871                                 if (!data_len)
 872                                         break;
 873
 874                                 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
 875                                 skb->truesize += data_len;
 876                                 skb_shinfo(skb)->nr_frags = npages;
 877                                 for (i = 0; i < npages; i++) {
 878                                         struct page *page;
 879                                         skb_frag_t *frag;
 880
 881                                         page = alloc_pages(sk->sk_allocation, 0);
 882                                         if (!page) {
 883                                                 err = -ENOBUFS;
 884                                                 skb_shinfo(skb)->nr_frags = i;
 885                                                 kfree_skb(skb);
 886                                                 goto failure;
 887                                         }
 888
 889                                         frag = &skb_shinfo(skb)->frags[i];
 890                                         frag->page = page;
 891                                         frag->page_offset = 0;
 892                                         frag->size = (data_len >= PAGE_SIZE ?
 893                                                       PAGE_SIZE :
 894                                                       data_len);
 895                                         data_len -= PAGE_SIZE;
 896                                 }
 897
 898                                 /* Full success... */
 899                                 break;
 900                         }
 901                         err = -ENOBUFS;
 902                         goto failure;
 903                 }
 904                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
 905                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
 906                 err = -EAGAIN;
 907                 if (!timeo)
 908                         goto failure;
 909                 if (signal_pending(current))
 910                         goto interrupted;
 911                 timeo = sock_wait_for_wmem(sk, timeo);
 912         }
 913
 914         skb_set_owner_w(skb, sk);
 915         return skb;
 916
 917 interrupted:
 918         err = sock_intr_errno(timeo);
 919 failure:
 920         *errcode = err;
 921         return NULL;
 922 }
 923
 924 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
 925                                     int noblock, int *errcode)
 926 {
 927         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
 928 }
 929
 930 static void __lock_sock(struct sock *sk)
 931 {
 932         DEFINE_WAIT(wait);
 933
 934         for(;;) {
 935                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
 936                                         TASK_UNINTERRUPTIBLE);
 937                 spin_unlock_bh(&sk->sk_lock.slock);
 938                 schedule();
 939                 spin_lock_bh(&sk->sk_lock.slock);
 940                 if(!sock_owned_by_user(sk))
 941                         break;
 942         }
 943         finish_wait(&sk->sk_lock.wq, &wait);
 944 }
 945
 946 static void __release_sock(struct sock *sk)
 947 {
 948         struct sk_buff *skb = sk->sk_backlog.head;
 949
 950         do {
 951                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
 952                 bh_unlock_sock(sk);
 953
 954                 do {
 955                         struct sk_buff *next = skb->next;
 956
 957                         skb->next = NULL;
 958                         sk->sk_backlog_rcv(sk, skb);
 959
 960                         /*
 961                          * We are in process context here with softirqs
 962                          * disabled, use cond_resched_softirq() to preempt.
 963                          * This is safe to do because we've taken the backlog
 964                          * queue private:
 965                          */
 966                         cond_resched_softirq();
 967
 968                         skb = next;
 969                 } while (skb != NULL);
 970
 971                 bh_lock_sock(sk);
 972         } while((skb = sk->sk_backlog.head) != NULL);
 973 }
 974
 975 /**
 976  * sk_wait_data - wait for data to arrive at sk_receive_queue
 977  * @sk:    sock to wait on
 978  * @timeo: for how long
 979  *
 980  * Now socket state including sk->sk_err is changed only under lock,
 981  * hence we may omit checks after joining wait queue.
 982  * We check receive queue before schedule() only as optimization;
 983  * it is very likely that release_sock() added new data.
 984  */
 985 int sk_wait_data(struct sock *sk, long *timeo)
 986 {
 987         int rc;
 988         DEFINE_WAIT(wait);
 989
 990         prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
 991         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 992         rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
 993         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
 994         finish_wait(sk->sk_sleep, &wait);
 995         return rc;
 996 }
 997
 998 EXPORT_SYMBOL(sk_wait_data);
 999
1000 /*
1001  * Set of default routines for initialising struct proto_ops when
1002  * the protocol does not support a particular function. In certain
1003  * cases where it makes no sense for a protocol to have a "do nothing"
1004  * function, some default processing is provided.
1005  */
1006
1007 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1008 {
1009         return -EOPNOTSUPP;
1010 }
1011
1012 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1013                     int len, int flags)
1014 {
1015         return -EOPNOTSUPP;
1016 }
1017
1018 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1019 {
1020         return -EOPNOTSUPP;
1021 }
1022
1023 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1024 {
1025         return -EOPNOTSUPP;
1026 }
1027
1028 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1029                     int *len, int peer)
1030 {
1031         return -EOPNOTSUPP;
1032 }
1033
1034 unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
1035 {
1036         return 0;
1037 }
1038
1039 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1040 {
1041         return -EOPNOTSUPP;
1042 }
1043
1044 int sock_no_listen(struct socket *sock, int backlog)
1045 {
1046         return -EOPNOTSUPP;
1047 }
1048
1049 int sock_no_shutdown(struct socket *sock, int how)
1050 {
1051         return -EOPNOTSUPP;
1052 }
1053
1054 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1055                     char __user *optval, int optlen)
1056 {
1057         return -EOPNOTSUPP;
1058 }
1059
1060 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1061                     char __user *optval, int __user *optlen)
1062 {
1063         return -EOPNOTSUPP;
1064 }
1065
1066 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1067                     size_t len)
1068 {
1069         return -EOPNOTSUPP;
1070 }
1071
1072 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1073                     size_t len, int flags)
1074 {
1075         return -EOPNOTSUPP;
1076 }
1077
1078 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1079 {
1080         /* Mirror missing mmap method error code */
1081         return -ENODEV;
1082 }
1083
1084 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1085 {
1086         ssize_t res;
1087         struct msghdr msg = {.msg_flags = flags};
1088         struct kvec iov;
1089         char *kaddr = kmap(page);
1090         iov.iov_base = kaddr + offset;
1091         iov.iov_len = size;
1092         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1093         kunmap(page);
1094         return res;
1095 }
1096
1097 /*
1098  *      Default Socket Callbacks
1099  */
1100
1101 static void sock_def_wakeup(struct sock *sk)
1102 {
1103         read_lock(&sk->sk_callback_lock);
1104         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1105                 wake_up_interruptible_all(sk->sk_sleep);
1106         read_unlock(&sk->sk_callback_lock);
1107 }
1108
1109 static void sock_def_error_report(struct sock *sk)
1110 {
1111         read_lock(&sk->sk_callback_lock);
1112         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1113                 wake_up_interruptible(sk->sk_sleep);
1114         sk_wake_async(sk,0,POLL_ERR);
1115         read_unlock(&sk->sk_callback_lock);
1116 }
1117
1118 static void sock_def_readable(struct sock *sk, int len)
1119 {
1120         read_lock(&sk->sk_callback_lock);
1121         if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1122                 wake_up_interruptible(sk->sk_sleep);
1123         sk_wake_async(sk,1,POLL_IN);
1124         read_unlock(&sk->sk_callback_lock);
1125 }
1126
1127 static void sock_def_write_space(struct sock *sk)
1128 {
1129         read_lock(&sk->sk_callback_lock);
1130
1131         /* Do not wake up a writer until he can make "significant"
1132          * progress.  --DaveM
1133          */
1134         if((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1135                 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1136                         wake_up_interruptible(sk->sk_sleep);
1137
1138                 /* Should agree with poll, otherwise some programs break */
1139                 if (sock_writeable(sk))
1140                         sk_wake_async(sk, 2, POLL_OUT);
1141         }
1142
1143         read_unlock(&sk->sk_callback_lock);
1144 }
1145
1146 static void sock_def_destruct(struct sock *sk)
1147 {
1148         if (sk->sk_protinfo)
1149                 kfree(sk->sk_protinfo);
1150 }
1151
1152 void sk_send_sigurg(struct sock *sk)
1153 {
1154         if (sk->sk_socket && sk->sk_socket->file)
1155                 if (send_sigurg(&sk->sk_socket->file->f_owner))
1156                         sk_wake_async(sk, 3, POLL_PRI);
1157 }
1158
1159 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1160                     unsigned long expires)
1161 {
1162         if (!mod_timer(timer, expires))
1163                 sock_hold(sk);
1164 }
1165
1166 EXPORT_SYMBOL(sk_reset_timer);
1167
1168 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1169 {
1170         if (timer_pending(timer) && del_timer(timer))
1171                 __sock_put(sk);
1172 }
1173
1174 EXPORT_SYMBOL(sk_stop_timer);
1175
1176 void sock_init_data(struct socket *sock, struct sock *sk)
1177 {
1178         skb_queue_head_init(&sk->sk_receive_queue);
1179         skb_queue_head_init(&sk->sk_write_queue);
1180         skb_queue_head_init(&sk->sk_error_queue);
1181
1182         sk->sk_send_head        =       NULL;
1183
1184         init_timer(&sk->sk_timer);
1185
1186         sk->sk_allocation       =       GFP_KERNEL;
1187         sk->sk_rcvbuf           =       sysctl_rmem_default;
1188         sk->sk_sndbuf           =       sysctl_wmem_default;
1189         sk->sk_state            =       TCP_CLOSE;
1190         sk->sk_socket           =       sock;
1191
1192         sock_set_flag(sk, SOCK_ZAPPED);
1193
1194         if(sock)
1195         {
1196                 sk->sk_type     =       sock->type;
1197                 sk->sk_sleep    =       &sock->wait;
1198                 sock->sk        =       sk;
1199         } else
1200                 sk->sk_sleep    =       NULL;
1201
1202         rwlock_init(&sk->sk_dst_lock);
1203         rwlock_init(&sk->sk_callback_lock);
1204
1205         sk->sk_state_change     =       sock_def_wakeup;
1206         sk->sk_data_ready       =       sock_def_readable;
1207         sk->sk_write_space      =       sock_def_write_space;
1208         sk->sk_error_report     =       sock_def_error_report;
1209         sk->sk_destruct         =       sock_def_destruct;
1210
1211         sk->sk_sndmsg_page      =       NULL;
1212         sk->sk_sndmsg_off       =       0;
1213
1214         sk->sk_peercred.pid     =       0;
1215         sk->sk_peercred.uid     =       -1;
1216         sk->sk_peercred.gid     =       -1;
1217         sk->sk_write_pending    =       0;
1218         sk->sk_rcvlowat         =       1;
1219         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
1220         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
1221
1222         sk->sk_stamp.tv_sec     = -1L;
1223         sk->sk_stamp.tv_usec    = -1L;
1224
1225         atomic_set(&sk->sk_refcnt, 1);
1226 }
1227
1228 void fastcall lock_sock(struct sock *sk)
1229 {
1230         might_sleep();
1231         spin_lock_bh(&(sk->sk_lock.slock));
1232         if (sk->sk_lock.owner)
1233                 __lock_sock(sk);
1234         sk->sk_lock.owner = (void *)1;
1235         spin_unlock_bh(&(sk->sk_lock.slock));
1236 }
1237
1238 EXPORT_SYMBOL(lock_sock);
1239
1240 void fastcall release_sock(struct sock *sk)
1241 {
1242         spin_lock_bh(&(sk->sk_lock.slock));
1243         if (sk->sk_backlog.tail)
1244                 __release_sock(sk);
1245         sk->sk_lock.owner = NULL;
1246         if (waitqueue_active(&(sk->sk_lock.wq)))
1247                 wake_up(&(sk->sk_lock.wq));
1248         spin_unlock_bh(&(sk->sk_lock.slock));
1249 }
1250 EXPORT_SYMBOL(release_sock);
1251
1252 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
1253 {
1254         if (!sock_flag(sk, SOCK_TIMESTAMP))
1255                 sock_enable_timestamp(sk);
1256         if (sk->sk_stamp.tv_sec == -1)
1257                 return -ENOENT;
1258         if (sk->sk_stamp.tv_sec == 0)
1259                 do_gettimeofday(&sk->sk_stamp);
1260         return copy_to_user(userstamp, &sk->sk_stamp, sizeof(struct timeval)) ?
1261                 -EFAULT : 0;
1262 }
1263 EXPORT_SYMBOL(sock_get_timestamp);
1264
1265 void sock_enable_timestamp(struct sock *sk)
1266 {
1267         if (!sock_flag(sk, SOCK_TIMESTAMP)) {
1268                 sock_set_flag(sk, SOCK_TIMESTAMP);
1269                 net_enable_timestamp();
1270         }
1271 }
1272 EXPORT_SYMBOL(sock_enable_timestamp);
1273
1274 /*
1275  *      Get a socket option on an socket.
1276  *
1277  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
1278  *      asynchronous errors should be reported by getsockopt. We assume
1279  *      this means if you specify SO_ERROR (otherwise whats the point of it).
1280  */
1281 int sock_common_getsockopt(struct socket *sock, int level, int optname,
1282                            char __user *optval, int __user *optlen)
1283 {
1284         struct sock *sk = sock->sk;
1285
1286         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1287 }
1288
1289 EXPORT_SYMBOL(sock_common_getsockopt);
1290
1291 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1292                         struct msghdr *msg, size_t size, int flags)
1293 {
1294         struct sock *sk = sock->sk;
1295         int addr_len = 0;
1296         int err;
1297
1298         err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
1299                                    flags & ~MSG_DONTWAIT, &addr_len);
1300         if (err >= 0)
1301                 msg->msg_namelen = addr_len;
1302         return err;
1303 }
1304
1305 EXPORT_SYMBOL(sock_common_recvmsg);
1306
1307 /*
1308  *      Set socket options on an inet socket.
1309  */
1310 int sock_common_setsockopt(struct socket *sock, int level, int optname,
1311                            char __user *optval, int optlen)
1312 {
1313         struct sock *sk = sock->sk;
1314
1315         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1316 }
1317
1318 EXPORT_SYMBOL(sock_common_setsockopt);
1319
1320 void sk_common_release(struct sock *sk)
1321 {
1322         if (sk->sk_prot->destroy)
1323                 sk->sk_prot->destroy(sk);
1324
1325         /*
1326          * Observation: when sock_common_release is called, processes have
1327          * no access to socket. But net still has.
1328          * Step one, detach it from networking:
1329          *
1330          * A. Remove from hash tables.
1331          */
1332
1333         sk->sk_prot->unhash(sk);
1334
1335         /*
1336          * In this point socket cannot receive new packets, but it is possible
1337          * that some packets are in flight because some CPU runs receiver and
1338          * did hash table lookup before we unhashed socket. They will achieve
1339          * receive queue and will be purged by socket destructor.
1340          *
1341          * Also we still have packets pending on receive queue and probably,
1342          * our own packets waiting in device queues. sock_destroy will drain
1343          * receive queue, but transmitted packets will delay socket destruction
1344          * until the last reference will be released.
1345          */
1346
1347         sock_orphan(sk);
1348
1349         xfrm_sk_free_policy(sk);
1350
1351 #ifdef INET_REFCNT_DEBUG
1352         if (atomic_read(&sk->sk_refcnt) != 1)
1353                 printk(KERN_DEBUG "Destruction of the socket %p delayed, c=%d\n",
1354                        sk, atomic_read(&sk->sk_refcnt));
1355 #endif
1356         sock_put(sk);
1357 }
1358
1359 EXPORT_SYMBOL(sk_common_release);
1360
1361 static DEFINE_RWLOCK(proto_list_lock);
1362 static LIST_HEAD(proto_list);
1363
1364 int proto_register(struct proto *prot, int alloc_slab)
1365 {
1366         int rc = -ENOBUFS;
1367
1368         if (alloc_slab) {
1369                 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
1370                                                SLAB_HWCACHE_ALIGN, NULL, NULL);
1371
1372                 if (prot->slab == NULL) {
1373                         printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
1374                                prot->name);
1375                         goto out;
1376                 }
1377         }
1378
1379         write_lock(&proto_list_lock);
1380         list_add(&prot->node, &proto_list);
1381         write_unlock(&proto_list_lock);
1382         rc = 0;
1383 out:
1384         return rc;
1385 }
1386
1387 EXPORT_SYMBOL(proto_register);
1388
1389 void proto_unregister(struct proto *prot)
1390 {
1391         write_lock(&proto_list_lock);
1392
1393         if (prot->slab != NULL) {
1394                 kmem_cache_destroy(prot->slab);
1395                 prot->slab = NULL;
1396         }
1397
1398         list_del(&prot->node);
1399         write_unlock(&proto_list_lock);
1400 }
1401
1402 EXPORT_SYMBOL(proto_unregister);
1403
1404 #ifdef CONFIG_PROC_FS
1405 static inline struct proto *__proto_head(void)
1406 {
1407         return list_entry(proto_list.next, struct proto, node);
1408 }
1409
1410 static inline struct proto *proto_head(void)
1411 {
1412         return list_empty(&proto_list) ? NULL : __proto_head();
1413 }
1414
1415 static inline struct proto *proto_next(struct proto *proto)
1416 {
1417         return proto->node.next == &proto_list ? NULL :
1418                 list_entry(proto->node.next, struct proto, node);
1419 }
1420
1421 static inline struct proto *proto_get_idx(loff_t pos)
1422 {
1423         struct proto *proto;
1424         loff_t i = 0;
1425
1426         list_for_each_entry(proto, &proto_list, node)
1427                 if (i++ == pos)
1428                         goto out;
1429
1430         proto = NULL;
1431 out:
1432         return proto;
1433 }
1434
1435 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
1436 {
1437         read_lock(&proto_list_lock);
1438         return *pos ? proto_get_idx(*pos - 1) : SEQ_START_TOKEN;
1439 }
1440
1441 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1442 {
1443         ++*pos;
1444         return v == SEQ_START_TOKEN ? proto_head() : proto_next(v);
1445 }
1446
1447 static void proto_seq_stop(struct seq_file *seq, void *v)
1448 {
1449         read_unlock(&proto_list_lock);
1450 }
1451
1452 static char proto_method_implemented(const void *method)
1453 {
1454         return method == NULL ? 'n' : 'y';
1455 }
1456
1457 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
1458 {
1459         seq_printf(seq, "%-9s %4u %6d  %6d   %-3s %6u   %-3s  %-10s "
1460                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
1461                    proto->name,
1462                    proto->obj_size,
1463                    proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
1464                    proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
1465                    proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
1466                    proto->max_header,
1467                    proto->slab == NULL ? "no" : "yes",
1468                    module_name(proto->owner),
1469                    proto_method_implemented(proto->close),
1470                    proto_method_implemented(proto->connect),
1471                    proto_method_implemented(proto->disconnect),
1472                    proto_method_implemented(proto->accept),
1473                    proto_method_implemented(proto->ioctl),
1474                    proto_method_implemented(proto->init),
1475                    proto_method_implemented(proto->destroy),
1476                    proto_method_implemented(proto->shutdown),
1477                    proto_method_implemented(proto->setsockopt),
1478                    proto_method_implemented(proto->getsockopt),
1479                    proto_method_implemented(proto->sendmsg),
1480                    proto_method_implemented(proto->recvmsg),
1481                    proto_method_implemented(proto->sendpage),
1482                    proto_method_implemented(proto->bind),
1483                    proto_method_implemented(proto->backlog_rcv),
1484                    proto_method_implemented(proto->hash),
1485                    proto_method_implemented(proto->unhash),
1486                    proto_method_implemented(proto->get_port),
1487                    proto_method_implemented(proto->enter_memory_pressure));
1488 }
1489
1490 static int proto_seq_show(struct seq_file *seq, void *v)
1491 {
1492         if (v == SEQ_START_TOKEN)
1493                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
1494                            "protocol",
1495                            "size",
1496                            "sockets",
1497                            "memory",
1498                            "press",
1499                            "maxhdr",
1500                            "slab",
1501                            "module",
1502                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
1503         else
1504                 proto_seq_printf(seq, v);
1505         return 0;
1506 }
1507
1508 static struct seq_operations proto_seq_ops = {
1509         .start  = proto_seq_start,
1510         .next   = proto_seq_next,
1511         .stop   = proto_seq_stop,
1512         .show   = proto_seq_show,
1513 };
1514
1515 static int proto_seq_open(struct inode *inode, struct file *file)
1516 {
1517         return seq_open(file, &proto_seq_ops);
1518 }
1519
1520 static struct file_operations proto_seq_fops = {
1521         .owner          = THIS_MODULE,
1522         .open           = proto_seq_open,
1523         .read           = seq_read,
1524         .llseek         = seq_lseek,
1525         .release        = seq_release,
1526 };
1527
1528 static int __init proto_init(void)
1529 {
1530         /* register /proc/net/protocols */
1531         return proc_net_fops_create("protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
1532 }
1533
1534 subsys_initcall(proto_init);
1535
1536 #endif /* PROC_FS */
1537
1538 EXPORT_SYMBOL(sk_alloc);
1539 EXPORT_SYMBOL(sk_free);
1540 EXPORT_SYMBOL(sk_send_sigurg);
1541 EXPORT_SYMBOL(sock_alloc_send_skb);
1542 EXPORT_SYMBOL(sock_init_data);
1543 EXPORT_SYMBOL(sock_kfree_s);
1544 EXPORT_SYMBOL(sock_kmalloc);
1545 EXPORT_SYMBOL(sock_no_accept);
1546 EXPORT_SYMBOL(sock_no_bind);
1547 EXPORT_SYMBOL(sock_no_connect);
1548 EXPORT_SYMBOL(sock_no_getname);
1549 EXPORT_SYMBOL(sock_no_getsockopt);
1550 EXPORT_SYMBOL(sock_no_ioctl);
1551 EXPORT_SYMBOL(sock_no_listen);
1552 EXPORT_SYMBOL(sock_no_mmap);
1553 EXPORT_SYMBOL(sock_no_poll);
1554 EXPORT_SYMBOL(sock_no_recvmsg);
1555 EXPORT_SYMBOL(sock_no_sendmsg);
1556 EXPORT_SYMBOL(sock_no_sendpage);
1557 EXPORT_SYMBOL(sock_no_setsockopt);
1558 EXPORT_SYMBOL(sock_no_shutdown);
1559 EXPORT_SYMBOL(sock_no_socketpair);
1560 EXPORT_SYMBOL(sock_rfree);
1561 EXPORT_SYMBOL(sock_setsockopt);
1562 EXPORT_SYMBOL(sock_wfree);
1563 EXPORT_SYMBOL(sock_wmalloc);
1564 EXPORT_SYMBOL(sock_i_uid);
1565 EXPORT_SYMBOL(sock_i_ino);
1566 #ifdef CONFIG_SYSCTL
1567 EXPORT_SYMBOL(sysctl_optmem_max);
1568 EXPORT_SYMBOL(sysctl_rmem_max);
1569 EXPORT_SYMBOL(sysctl_wmem_max);
1570 #endif