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