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