net: implement a SO_DOMAIN getsockoption
[linux-2.6.git] / 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         }
1039
1040         return sk;
1041 }
1042 EXPORT_SYMBOL(sk_alloc);
1043
1044 static void __sk_free(struct sock *sk)
1045 {
1046         struct sk_filter *filter;
1047
1048         if (sk->sk_destruct)
1049                 sk->sk_destruct(sk);
1050
1051         filter = rcu_dereference(sk->sk_filter);
1052         if (filter) {
1053                 sk_filter_uncharge(sk, filter);
1054                 rcu_assign_pointer(sk->sk_filter, NULL);
1055         }
1056
1057         sock_disable_timestamp(sk, SOCK_TIMESTAMP);
1058         sock_disable_timestamp(sk, SOCK_TIMESTAMPING_RX_SOFTWARE);
1059
1060         if (atomic_read(&sk->sk_omem_alloc))
1061                 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
1062                        __func__, atomic_read(&sk->sk_omem_alloc));
1063
1064         put_net(sock_net(sk));
1065         sk_prot_free(sk->sk_prot_creator, sk);
1066 }
1067
1068 void sk_free(struct sock *sk)
1069 {
1070         /*
1071          * We substract one from sk_wmem_alloc and can know if
1072          * some packets are still in some tx queue.
1073          * If not null, sock_wfree() will call __sk_free(sk) later
1074          */
1075         if (atomic_dec_and_test(&sk->sk_wmem_alloc))
1076                 __sk_free(sk);
1077 }
1078 EXPORT_SYMBOL(sk_free);
1079
1080 /*
1081  * Last sock_put should drop referrence to sk->sk_net. It has already
1082  * been dropped in sk_change_net. Taking referrence to stopping namespace
1083  * is not an option.
1084  * Take referrence to a socket to remove it from hash _alive_ and after that
1085  * destroy it in the context of init_net.
1086  */
1087 void sk_release_kernel(struct sock *sk)
1088 {
1089         if (sk == NULL || sk->sk_socket == NULL)
1090                 return;
1091
1092         sock_hold(sk);
1093         sock_release(sk->sk_socket);
1094         release_net(sock_net(sk));
1095         sock_net_set(sk, get_net(&init_net));
1096         sock_put(sk);
1097 }
1098 EXPORT_SYMBOL(sk_release_kernel);
1099
1100 struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
1101 {
1102         struct sock *newsk;
1103
1104         newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
1105         if (newsk != NULL) {
1106                 struct sk_filter *filter;
1107
1108                 sock_copy(newsk, sk);
1109
1110                 /* SANITY */
1111                 get_net(sock_net(newsk));
1112                 sk_node_init(&newsk->sk_node);
1113                 sock_lock_init(newsk);
1114                 bh_lock_sock(newsk);
1115                 newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
1116
1117                 atomic_set(&newsk->sk_rmem_alloc, 0);
1118                 /*
1119                  * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1120                  */
1121                 atomic_set(&newsk->sk_wmem_alloc, 1);
1122                 atomic_set(&newsk->sk_omem_alloc, 0);
1123                 skb_queue_head_init(&newsk->sk_receive_queue);
1124                 skb_queue_head_init(&newsk->sk_write_queue);
1125 #ifdef CONFIG_NET_DMA
1126                 skb_queue_head_init(&newsk->sk_async_wait_queue);
1127 #endif
1128
1129                 rwlock_init(&newsk->sk_dst_lock);
1130                 rwlock_init(&newsk->sk_callback_lock);
1131                 lockdep_set_class_and_name(&newsk->sk_callback_lock,
1132                                 af_callback_keys + newsk->sk_family,
1133                                 af_family_clock_key_strings[newsk->sk_family]);
1134
1135                 newsk->sk_dst_cache     = NULL;
1136                 newsk->sk_wmem_queued   = 0;
1137                 newsk->sk_forward_alloc = 0;
1138                 newsk->sk_send_head     = NULL;
1139                 newsk->sk_userlocks     = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1140
1141                 sock_reset_flag(newsk, SOCK_DONE);
1142                 skb_queue_head_init(&newsk->sk_error_queue);
1143
1144                 filter = newsk->sk_filter;
1145                 if (filter != NULL)
1146                         sk_filter_charge(newsk, filter);
1147
1148                 if (unlikely(xfrm_sk_clone_policy(newsk))) {
1149                         /* It is still raw copy of parent, so invalidate
1150                          * destructor and make plain sk_free() */
1151                         newsk->sk_destruct = NULL;
1152                         sk_free(newsk);
1153                         newsk = NULL;
1154                         goto out;
1155                 }
1156
1157                 newsk->sk_err      = 0;
1158                 newsk->sk_priority = 0;
1159                 /*
1160                  * Before updating sk_refcnt, we must commit prior changes to memory
1161                  * (Documentation/RCU/rculist_nulls.txt for details)
1162                  */
1163                 smp_wmb();
1164                 atomic_set(&newsk->sk_refcnt, 2);
1165
1166                 /*
1167                  * Increment the counter in the same struct proto as the master
1168                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1169                  * is the same as sk->sk_prot->socks, as this field was copied
1170                  * with memcpy).
1171                  *
1172                  * This _changes_ the previous behaviour, where
1173                  * tcp_create_openreq_child always was incrementing the
1174                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1175                  * to be taken into account in all callers. -acme
1176                  */
1177                 sk_refcnt_debug_inc(newsk);
1178                 sk_set_socket(newsk, NULL);
1179                 newsk->sk_sleep  = NULL;
1180
1181                 if (newsk->sk_prot->sockets_allocated)
1182                         percpu_counter_inc(newsk->sk_prot->sockets_allocated);
1183         }
1184 out:
1185         return newsk;
1186 }
1187 EXPORT_SYMBOL_GPL(sk_clone);
1188
1189 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1190 {
1191         __sk_dst_set(sk, dst);
1192         sk->sk_route_caps = dst->dev->features;
1193         if (sk->sk_route_caps & NETIF_F_GSO)
1194                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1195         if (sk_can_gso(sk)) {
1196                 if (dst->header_len) {
1197                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1198                 } else {
1199                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1200                         sk->sk_gso_max_size = dst->dev->gso_max_size;
1201                 }
1202         }
1203 }
1204 EXPORT_SYMBOL_GPL(sk_setup_caps);
1205
1206 void __init sk_init(void)
1207 {
1208         if (num_physpages <= 4096) {
1209                 sysctl_wmem_max = 32767;
1210                 sysctl_rmem_max = 32767;
1211                 sysctl_wmem_default = 32767;
1212                 sysctl_rmem_default = 32767;
1213         } else if (num_physpages >= 131072) {
1214                 sysctl_wmem_max = 131071;
1215                 sysctl_rmem_max = 131071;
1216         }
1217 }
1218
1219 /*
1220  *      Simple resource managers for sockets.
1221  */
1222
1223
1224 /*
1225  * Write buffer destructor automatically called from kfree_skb.
1226  */
1227 void sock_wfree(struct sk_buff *skb)
1228 {
1229         struct sock *sk = skb->sk;
1230         int res;
1231
1232         /* In case it might be waiting for more memory. */
1233         res = atomic_sub_return(skb->truesize, &sk->sk_wmem_alloc);
1234         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
1235                 sk->sk_write_space(sk);
1236         /*
1237          * if sk_wmem_alloc reached 0, we are last user and should
1238          * free this sock, as sk_free() call could not do it.
1239          */
1240         if (res == 0)
1241                 __sk_free(sk);
1242 }
1243 EXPORT_SYMBOL(sock_wfree);
1244
1245 /*
1246  * Read buffer destructor automatically called from kfree_skb.
1247  */
1248 void sock_rfree(struct sk_buff *skb)
1249 {
1250         struct sock *sk = skb->sk;
1251
1252         atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
1253         sk_mem_uncharge(skb->sk, skb->truesize);
1254 }
1255 EXPORT_SYMBOL(sock_rfree);
1256
1257
1258 int sock_i_uid(struct sock *sk)
1259 {
1260         int uid;
1261
1262         read_lock(&sk->sk_callback_lock);
1263         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1264         read_unlock(&sk->sk_callback_lock);
1265         return uid;
1266 }
1267 EXPORT_SYMBOL(sock_i_uid);
1268
1269 unsigned long sock_i_ino(struct sock *sk)
1270 {
1271         unsigned long ino;
1272
1273         read_lock(&sk->sk_callback_lock);
1274         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1275         read_unlock(&sk->sk_callback_lock);
1276         return ino;
1277 }
1278 EXPORT_SYMBOL(sock_i_ino);
1279
1280 /*
1281  * Allocate a skb from the socket's send buffer.
1282  */
1283 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1284                              gfp_t priority)
1285 {
1286         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1287                 struct sk_buff *skb = alloc_skb(size, priority);
1288                 if (skb) {
1289                         skb_set_owner_w(skb, sk);
1290                         return skb;
1291                 }
1292         }
1293         return NULL;
1294 }
1295 EXPORT_SYMBOL(sock_wmalloc);
1296
1297 /*
1298  * Allocate a skb from the socket's receive buffer.
1299  */
1300 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
1301                              gfp_t priority)
1302 {
1303         if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1304                 struct sk_buff *skb = alloc_skb(size, priority);
1305                 if (skb) {
1306                         skb_set_owner_r(skb, sk);
1307                         return skb;
1308                 }
1309         }
1310         return NULL;
1311 }
1312
1313 /*
1314  * Allocate a memory block from the socket's option memory buffer.
1315  */
1316 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1317 {
1318         if ((unsigned)size <= sysctl_optmem_max &&
1319             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1320                 void *mem;
1321                 /* First do the add, to avoid the race if kmalloc
1322                  * might sleep.
1323                  */
1324                 atomic_add(size, &sk->sk_omem_alloc);
1325                 mem = kmalloc(size, priority);
1326                 if (mem)
1327                         return mem;
1328                 atomic_sub(size, &sk->sk_omem_alloc);
1329         }
1330         return NULL;
1331 }
1332 EXPORT_SYMBOL(sock_kmalloc);
1333
1334 /*
1335  * Free an option memory block.
1336  */
1337 void sock_kfree_s(struct sock *sk, void *mem, int size)
1338 {
1339         kfree(mem);
1340         atomic_sub(size, &sk->sk_omem_alloc);
1341 }
1342 EXPORT_SYMBOL(sock_kfree_s);
1343
1344 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1345    I think, these locks should be removed for datagram sockets.
1346  */
1347 static long sock_wait_for_wmem(struct sock *sk, long timeo)
1348 {
1349         DEFINE_WAIT(wait);
1350
1351         clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1352         for (;;) {
1353                 if (!timeo)
1354                         break;
1355                 if (signal_pending(current))
1356                         break;
1357                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1358                 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1359                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1360                         break;
1361                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1362                         break;
1363                 if (sk->sk_err)
1364                         break;
1365                 timeo = schedule_timeout(timeo);
1366         }
1367         finish_wait(sk->sk_sleep, &wait);
1368         return timeo;
1369 }
1370
1371
1372 /*
1373  *      Generic send/receive buffer handlers
1374  */
1375
1376 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1377                                      unsigned long data_len, int noblock,
1378                                      int *errcode)
1379 {
1380         struct sk_buff *skb;
1381         gfp_t gfp_mask;
1382         long timeo;
1383         int err;
1384
1385         gfp_mask = sk->sk_allocation;
1386         if (gfp_mask & __GFP_WAIT)
1387                 gfp_mask |= __GFP_REPEAT;
1388
1389         timeo = sock_sndtimeo(sk, noblock);
1390         while (1) {
1391                 err = sock_error(sk);
1392                 if (err != 0)
1393                         goto failure;
1394
1395                 err = -EPIPE;
1396                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1397                         goto failure;
1398
1399                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1400                         skb = alloc_skb(header_len, gfp_mask);
1401                         if (skb) {
1402                                 int npages;
1403                                 int i;
1404
1405                                 /* No pages, we're done... */
1406                                 if (!data_len)
1407                                         break;
1408
1409                                 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1410                                 skb->truesize += data_len;
1411                                 skb_shinfo(skb)->nr_frags = npages;
1412                                 for (i = 0; i < npages; i++) {
1413                                         struct page *page;
1414                                         skb_frag_t *frag;
1415
1416                                         page = alloc_pages(sk->sk_allocation, 0);
1417                                         if (!page) {
1418                                                 err = -ENOBUFS;
1419                                                 skb_shinfo(skb)->nr_frags = i;
1420                                                 kfree_skb(skb);
1421                                                 goto failure;
1422                                         }
1423
1424                                         frag = &skb_shinfo(skb)->frags[i];
1425                                         frag->page = page;
1426                                         frag->page_offset = 0;
1427                                         frag->size = (data_len >= PAGE_SIZE ?
1428                                                       PAGE_SIZE :
1429                                                       data_len);
1430                                         data_len -= PAGE_SIZE;
1431                                 }
1432
1433                                 /* Full success... */
1434                                 break;
1435                         }
1436                         err = -ENOBUFS;
1437                         goto failure;
1438                 }
1439                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1440                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1441                 err = -EAGAIN;
1442                 if (!timeo)
1443                         goto failure;
1444                 if (signal_pending(current))
1445                         goto interrupted;
1446                 timeo = sock_wait_for_wmem(sk, timeo);
1447         }
1448
1449         skb_set_owner_w(skb, sk);
1450         return skb;
1451
1452 interrupted:
1453         err = sock_intr_errno(timeo);
1454 failure:
1455         *errcode = err;
1456         return NULL;
1457 }
1458 EXPORT_SYMBOL(sock_alloc_send_pskb);
1459
1460 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1461                                     int noblock, int *errcode)
1462 {
1463         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1464 }
1465 EXPORT_SYMBOL(sock_alloc_send_skb);
1466
1467 static void __lock_sock(struct sock *sk)
1468 {
1469         DEFINE_WAIT(wait);
1470
1471         for (;;) {
1472                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1473                                         TASK_UNINTERRUPTIBLE);
1474                 spin_unlock_bh(&sk->sk_lock.slock);
1475                 schedule();
1476                 spin_lock_bh(&sk->sk_lock.slock);
1477                 if (!sock_owned_by_user(sk))
1478                         break;
1479         }
1480         finish_wait(&sk->sk_lock.wq, &wait);
1481 }
1482
1483 static void __release_sock(struct sock *sk)
1484 {
1485         struct sk_buff *skb = sk->sk_backlog.head;
1486
1487         do {
1488                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1489                 bh_unlock_sock(sk);
1490
1491                 do {
1492                         struct sk_buff *next = skb->next;
1493
1494                         skb->next = NULL;
1495                         sk_backlog_rcv(sk, skb);
1496
1497                         /*
1498                          * We are in process context here with softirqs
1499                          * disabled, use cond_resched_softirq() to preempt.
1500                          * This is safe to do because we've taken the backlog
1501                          * queue private:
1502                          */
1503                         cond_resched_softirq();
1504
1505                         skb = next;
1506                 } while (skb != NULL);
1507
1508                 bh_lock_sock(sk);
1509         } while ((skb = sk->sk_backlog.head) != NULL);
1510 }
1511
1512 /**
1513  * sk_wait_data - wait for data to arrive at sk_receive_queue
1514  * @sk:    sock to wait on
1515  * @timeo: for how long
1516  *
1517  * Now socket state including sk->sk_err is changed only under lock,
1518  * hence we may omit checks after joining wait queue.
1519  * We check receive queue before schedule() only as optimization;
1520  * it is very likely that release_sock() added new data.
1521  */
1522 int sk_wait_data(struct sock *sk, long *timeo)
1523 {
1524         int rc;
1525         DEFINE_WAIT(wait);
1526
1527         prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1528         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1529         rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1530         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1531         finish_wait(sk->sk_sleep, &wait);
1532         return rc;
1533 }
1534 EXPORT_SYMBOL(sk_wait_data);
1535
1536 /**
1537  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
1538  *      @sk: socket
1539  *      @size: memory size to allocate
1540  *      @kind: allocation type
1541  *
1542  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
1543  *      rmem allocation. This function assumes that protocols which have
1544  *      memory_pressure use sk_wmem_queued as write buffer accounting.
1545  */
1546 int __sk_mem_schedule(struct sock *sk, int size, int kind)
1547 {
1548         struct proto *prot = sk->sk_prot;
1549         int amt = sk_mem_pages(size);
1550         int allocated;
1551
1552         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
1553         allocated = atomic_add_return(amt, prot->memory_allocated);
1554
1555         /* Under limit. */
1556         if (allocated <= prot->sysctl_mem[0]) {
1557                 if (prot->memory_pressure && *prot->memory_pressure)
1558                         *prot->memory_pressure = 0;
1559                 return 1;
1560         }
1561
1562         /* Under pressure. */
1563         if (allocated > prot->sysctl_mem[1])
1564                 if (prot->enter_memory_pressure)
1565                         prot->enter_memory_pressure(sk);
1566
1567         /* Over hard limit. */
1568         if (allocated > prot->sysctl_mem[2])
1569                 goto suppress_allocation;
1570
1571         /* guarantee minimum buffer size under pressure */
1572         if (kind == SK_MEM_RECV) {
1573                 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
1574                         return 1;
1575         } else { /* SK_MEM_SEND */
1576                 if (sk->sk_type == SOCK_STREAM) {
1577                         if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
1578                                 return 1;
1579                 } else if (atomic_read(&sk->sk_wmem_alloc) <
1580                            prot->sysctl_wmem[0])
1581                                 return 1;
1582         }
1583
1584         if (prot->memory_pressure) {
1585                 int alloc;
1586
1587                 if (!*prot->memory_pressure)
1588                         return 1;
1589                 alloc = percpu_counter_read_positive(prot->sockets_allocated);
1590                 if (prot->sysctl_mem[2] > alloc *
1591                     sk_mem_pages(sk->sk_wmem_queued +
1592                                  atomic_read(&sk->sk_rmem_alloc) +
1593                                  sk->sk_forward_alloc))
1594                         return 1;
1595         }
1596
1597 suppress_allocation:
1598
1599         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
1600                 sk_stream_moderate_sndbuf(sk);
1601
1602                 /* Fail only if socket is _under_ its sndbuf.
1603                  * In this case we cannot block, so that we have to fail.
1604                  */
1605                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
1606                         return 1;
1607         }
1608
1609         /* Alas. Undo changes. */
1610         sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
1611         atomic_sub(amt, prot->memory_allocated);
1612         return 0;
1613 }
1614 EXPORT_SYMBOL(__sk_mem_schedule);
1615
1616 /**
1617  *      __sk_reclaim - reclaim memory_allocated
1618  *      @sk: socket
1619  */
1620 void __sk_mem_reclaim(struct sock *sk)
1621 {
1622         struct proto *prot = sk->sk_prot;
1623
1624         atomic_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,
1625                    prot->memory_allocated);
1626         sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
1627
1628         if (prot->memory_pressure && *prot->memory_pressure &&
1629             (atomic_read(prot->memory_allocated) < prot->sysctl_mem[0]))
1630                 *prot->memory_pressure = 0;
1631 }
1632 EXPORT_SYMBOL(__sk_mem_reclaim);
1633
1634
1635 /*
1636  * Set of default routines for initialising struct proto_ops when
1637  * the protocol does not support a particular function. In certain
1638  * cases where it makes no sense for a protocol to have a "do nothing"
1639  * function, some default processing is provided.
1640  */
1641
1642 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1643 {
1644         return -EOPNOTSUPP;
1645 }
1646 EXPORT_SYMBOL(sock_no_bind);
1647
1648 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1649                     int len, int flags)
1650 {
1651         return -EOPNOTSUPP;
1652 }
1653 EXPORT_SYMBOL(sock_no_connect);
1654
1655 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1656 {
1657         return -EOPNOTSUPP;
1658 }
1659 EXPORT_SYMBOL(sock_no_socketpair);
1660
1661 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1662 {
1663         return -EOPNOTSUPP;
1664 }
1665 EXPORT_SYMBOL(sock_no_accept);
1666
1667 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1668                     int *len, int peer)
1669 {
1670         return -EOPNOTSUPP;
1671 }
1672 EXPORT_SYMBOL(sock_no_getname);
1673
1674 unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
1675 {
1676         return 0;
1677 }
1678 EXPORT_SYMBOL(sock_no_poll);
1679
1680 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1681 {
1682         return -EOPNOTSUPP;
1683 }
1684 EXPORT_SYMBOL(sock_no_ioctl);
1685
1686 int sock_no_listen(struct socket *sock, int backlog)
1687 {
1688         return -EOPNOTSUPP;
1689 }
1690 EXPORT_SYMBOL(sock_no_listen);
1691
1692 int sock_no_shutdown(struct socket *sock, int how)
1693 {
1694         return -EOPNOTSUPP;
1695 }
1696 EXPORT_SYMBOL(sock_no_shutdown);
1697
1698 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1699                     char __user *optval, int optlen)
1700 {
1701         return -EOPNOTSUPP;
1702 }
1703 EXPORT_SYMBOL(sock_no_setsockopt);
1704
1705 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1706                     char __user *optval, int __user *optlen)
1707 {
1708         return -EOPNOTSUPP;
1709 }
1710 EXPORT_SYMBOL(sock_no_getsockopt);
1711
1712 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1713                     size_t len)
1714 {
1715         return -EOPNOTSUPP;
1716 }
1717 EXPORT_SYMBOL(sock_no_sendmsg);
1718
1719 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1720                     size_t len, int flags)
1721 {
1722         return -EOPNOTSUPP;
1723 }
1724 EXPORT_SYMBOL(sock_no_recvmsg);
1725
1726 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1727 {
1728         /* Mirror missing mmap method error code */
1729         return -ENODEV;
1730 }
1731 EXPORT_SYMBOL(sock_no_mmap);
1732
1733 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1734 {
1735         ssize_t res;
1736         struct msghdr msg = {.msg_flags = flags};
1737         struct kvec iov;
1738         char *kaddr = kmap(page);
1739         iov.iov_base = kaddr + offset;
1740         iov.iov_len = size;
1741         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1742         kunmap(page);
1743         return res;
1744 }
1745 EXPORT_SYMBOL(sock_no_sendpage);
1746
1747 /*
1748  *      Default Socket Callbacks
1749  */
1750
1751 static void sock_def_wakeup(struct sock *sk)
1752 {
1753         read_lock(&sk->sk_callback_lock);
1754         if (sk_has_sleeper(sk))
1755                 wake_up_interruptible_all(sk->sk_sleep);
1756         read_unlock(&sk->sk_callback_lock);
1757 }
1758
1759 static void sock_def_error_report(struct sock *sk)
1760 {
1761         read_lock(&sk->sk_callback_lock);
1762         if (sk_has_sleeper(sk))
1763                 wake_up_interruptible_poll(sk->sk_sleep, POLLERR);
1764         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
1765         read_unlock(&sk->sk_callback_lock);
1766 }
1767
1768 static void sock_def_readable(struct sock *sk, int len)
1769 {
1770         read_lock(&sk->sk_callback_lock);
1771         if (sk_has_sleeper(sk))
1772                 wake_up_interruptible_sync_poll(sk->sk_sleep, POLLIN |
1773                                                 POLLRDNORM | POLLRDBAND);
1774         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
1775         read_unlock(&sk->sk_callback_lock);
1776 }
1777
1778 static void sock_def_write_space(struct sock *sk)
1779 {
1780         read_lock(&sk->sk_callback_lock);
1781
1782         /* Do not wake up a writer until he can make "significant"
1783          * progress.  --DaveM
1784          */
1785         if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1786                 if (sk_has_sleeper(sk))
1787                         wake_up_interruptible_sync_poll(sk->sk_sleep, POLLOUT |
1788                                                 POLLWRNORM | POLLWRBAND);
1789
1790                 /* Should agree with poll, otherwise some programs break */
1791                 if (sock_writeable(sk))
1792                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
1793         }
1794
1795         read_unlock(&sk->sk_callback_lock);
1796 }
1797
1798 static void sock_def_destruct(struct sock *sk)
1799 {
1800         kfree(sk->sk_protinfo);
1801 }
1802
1803 void sk_send_sigurg(struct sock *sk)
1804 {
1805         if (sk->sk_socket && sk->sk_socket->file)
1806                 if (send_sigurg(&sk->sk_socket->file->f_owner))
1807                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
1808 }
1809 EXPORT_SYMBOL(sk_send_sigurg);
1810
1811 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1812                     unsigned long expires)
1813 {
1814         if (!mod_timer(timer, expires))
1815                 sock_hold(sk);
1816 }
1817 EXPORT_SYMBOL(sk_reset_timer);
1818
1819 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1820 {
1821         if (timer_pending(timer) && del_timer(timer))
1822                 __sock_put(sk);
1823 }
1824 EXPORT_SYMBOL(sk_stop_timer);
1825
1826 void sock_init_data(struct socket *sock, struct sock *sk)
1827 {
1828         skb_queue_head_init(&sk->sk_receive_queue);
1829         skb_queue_head_init(&sk->sk_write_queue);
1830         skb_queue_head_init(&sk->sk_error_queue);
1831 #ifdef CONFIG_NET_DMA
1832         skb_queue_head_init(&sk->sk_async_wait_queue);
1833 #endif
1834
1835         sk->sk_send_head        =       NULL;
1836
1837         init_timer(&sk->sk_timer);
1838
1839         sk->sk_allocation       =       GFP_KERNEL;
1840         sk->sk_rcvbuf           =       sysctl_rmem_default;
1841         sk->sk_sndbuf           =       sysctl_wmem_default;
1842         sk->sk_state            =       TCP_CLOSE;
1843         sk_set_socket(sk, sock);
1844
1845         sock_set_flag(sk, SOCK_ZAPPED);
1846
1847         if (sock) {
1848                 sk->sk_type     =       sock->type;
1849                 sk->sk_sleep    =       &sock->wait;
1850                 sock->sk        =       sk;
1851         } else
1852                 sk->sk_sleep    =       NULL;
1853
1854         rwlock_init(&sk->sk_dst_lock);
1855         rwlock_init(&sk->sk_callback_lock);
1856         lockdep_set_class_and_name(&sk->sk_callback_lock,
1857                         af_callback_keys + sk->sk_family,
1858                         af_family_clock_key_strings[sk->sk_family]);
1859
1860         sk->sk_state_change     =       sock_def_wakeup;
1861         sk->sk_data_ready       =       sock_def_readable;
1862         sk->sk_write_space      =       sock_def_write_space;
1863         sk->sk_error_report     =       sock_def_error_report;
1864         sk->sk_destruct         =       sock_def_destruct;
1865
1866         sk->sk_sndmsg_page      =       NULL;
1867         sk->sk_sndmsg_off       =       0;
1868
1869         sk->sk_peercred.pid     =       0;
1870         sk->sk_peercred.uid     =       -1;
1871         sk->sk_peercred.gid     =       -1;
1872         sk->sk_write_pending    =       0;
1873         sk->sk_rcvlowat         =       1;
1874         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
1875         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
1876
1877         sk->sk_stamp = ktime_set(-1L, 0);
1878
1879         /*
1880          * Before updating sk_refcnt, we must commit prior changes to memory
1881          * (Documentation/RCU/rculist_nulls.txt for details)
1882          */
1883         smp_wmb();
1884         atomic_set(&sk->sk_refcnt, 1);
1885         atomic_set(&sk->sk_wmem_alloc, 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 */