]> git.ipfire.org Git - thirdparty/kernel/stable.git/blob - net/core/sock.c
projects / thirdparty / kernel / stable.git / blob
? search:
summary | shortlog | log | commit | commitdiff | tree
blame | history | raw | HEAD
[NET]: Make /proc/net per network namespace
[thirdparty/kernel/stable.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 * Version: $Id: sock.c,v 1.117 2002/02/01 22:01:03 davem Exp $
11 *
12 * Authors: Ross Biro
13 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
14 * Florian La Roche, <flla@stud.uni-sb.de>
15 * Alan Cox, <A.Cox@swansea.ac.uk>
16 *
17 * Fixes:
18 * Alan Cox : Numerous verify_area() problems
19 * Alan Cox : Connecting on a connecting socket
20 * now returns an error for tcp.
21 * Alan Cox : sock->protocol is set correctly.
22 * and is not sometimes left as 0.
23 * Alan Cox : connect handles icmp errors on a
24 * connect properly. Unfortunately there
25 * is a restart syscall nasty there. I
26 * can't match BSD without hacking the C
27 * library. Ideas urgently sought!
28 * Alan Cox : Disallow bind() to addresses that are
29 * not ours - especially broadcast ones!!
30 * Alan Cox : Socket 1024 _IS_ ok for users. (fencepost)
31 * Alan Cox : sock_wfree/sock_rfree don't destroy sockets,
32 * instead they leave that for the DESTROY timer.
33 * Alan Cox : Clean up error flag in accept
34 * Alan Cox : TCP ack handling is buggy, the DESTROY timer
35 * was buggy. Put a remove_sock() in the handler
36 * for memory when we hit 0. Also altered the timer
37 * code. The ACK stuff can wait and needs major
38 * TCP layer surgery.
39 * Alan Cox : Fixed TCP ack bug, removed remove sock
40 * and fixed timer/inet_bh race.
41 * Alan Cox : Added zapped flag for TCP
42 * Alan Cox : Move kfree_skb into skbuff.c and tidied up surplus code
43 * Alan Cox : for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
44 * Alan Cox : kfree_s calls now are kfree_skbmem so we can track skb resources
45 * Alan Cox : Supports socket option broadcast now as does udp. Packet and raw need fixing.
46 * Alan Cox : Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
47 * Rick Sladkey : Relaxed UDP rules for matching packets.
48 * C.E.Hawkins : IFF_PROMISC/SIOCGHWADDR support
49 * Pauline Middelink : identd support
50 * Alan Cox : Fixed connect() taking signals I think.
51 * Alan Cox : SO_LINGER supported
52 * Alan Cox : Error reporting fixes
53 * Anonymous : inet_create tidied up (sk->reuse setting)
54 * Alan Cox : inet sockets don't set sk->type!
55 * Alan Cox : Split socket option code
56 * Alan Cox : Callbacks
57 * Alan Cox : Nagle flag for Charles & Johannes stuff
58 * Alex : Removed restriction on inet fioctl
59 * Alan Cox : Splitting INET from NET core
60 * Alan Cox : Fixed bogus SO_TYPE handling in getsockopt()
61 * Adam Caldwell : Missing return in SO_DONTROUTE/SO_DEBUG code
62 * Alan Cox : Split IP from generic code
63 * Alan Cox : New kfree_skbmem()
64 * Alan Cox : Make SO_DEBUG superuser only.
65 * Alan Cox : Allow anyone to clear SO_DEBUG
66 * (compatibility fix)
67 * Alan Cox : Added optimistic memory grabbing for AF_UNIX throughput.
68 * Alan Cox : Allocator for a socket is settable.
69 * Alan Cox : SO_ERROR includes soft errors.
70 * Alan Cox : Allow NULL arguments on some SO_ opts
71 * Alan Cox : Generic socket allocation to make hooks
72 * easier (suggested by Craig Metz).
73 * Michael Pall : SO_ERROR returns positive errno again
74 * Steve Whitehouse: Added default destructor to free
75 * protocol private data.
76 * Steve Whitehouse: Added various other default routines
77 * common to several socket families.
78 * Chris Evans : Call suser() check last on F_SETOWN
79 * Jay Schulist : Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
80 * Andi Kleen : Add sock_kmalloc()/sock_kfree_s()
81 * Andi Kleen : Fix write_space callback
82 * Chris Evans : Security fixes - signedness again
83 * Arnaldo C. Melo : cleanups, use skb_queue_purge
84 *
85 * To Fix:
86 *
87 *
88 * This program is free software; you can redistribute it and/or
89 * modify it under the terms of the GNU General Public License
90 * as published by the Free Software Foundation; either version
91 * 2 of the License, or (at your option) any later version.
92 */
93
94 #include <linux/capability.h>
95 #include <linux/errno.h>
96 #include <linux/types.h>
97 #include <linux/socket.h>
98 #include <linux/in.h>
99 #include <linux/kernel.h>
100 #include <linux/module.h>
101 #include <linux/proc_fs.h>
102 #include <linux/seq_file.h>
103 #include <linux/sched.h>
104 #include <linux/timer.h>
105 #include <linux/string.h>
106 #include <linux/sockios.h>
107 #include <linux/net.h>
108 #include <linux/mm.h>
109 #include <linux/slab.h>
110 #include <linux/interrupt.h>
111 #include <linux/poll.h>
112 #include <linux/tcp.h>
113 #include <linux/init.h>
114 #include <linux/highmem.h>
115
116 #include <asm/uaccess.h>
117 #include <asm/system.h>
118
119 #include <linux/netdevice.h>
120 #include <net/protocol.h>
121 #include <linux/skbuff.h>
122 #include <net/net_namespace.h>
123 #include <net/request_sock.h>
124 #include <net/sock.h>
125 #include <net/xfrm.h>
126 #include <linux/ipsec.h>
127
128 #include <linux/filter.h>
129
130 #ifdef CONFIG_INET
131 #include <net/tcp.h>
132 #endif
133
134 /*
135 * Each address family might have different locking rules, so we have
136 * one slock key per address family:
137 */
138 static struct lock_class_key af_family_keys[AF_MAX];
139 static struct lock_class_key af_family_slock_keys[AF_MAX];
140
141 #ifdef CONFIG_DEBUG_LOCK_ALLOC
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 *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-21" , "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-29" ,
158 "sk_lock-AF_TIPC" , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV" ,
159 "sk_lock-AF_RXRPC" , "sk_lock-AF_MAX"
160 };
161 static const char *af_family_slock_key_strings[AF_MAX+1] = {
162 "slock-AF_UNSPEC", "slock-AF_UNIX" , "slock-AF_INET" ,
163 "slock-AF_AX25" , "slock-AF_IPX" , "slock-AF_APPLETALK",
164 "slock-AF_NETROM", "slock-AF_BRIDGE" , "slock-AF_ATMPVC" ,
165 "slock-AF_X25" , "slock-AF_INET6" , "slock-AF_ROSE" ,
166 "slock-AF_DECnet", "slock-AF_NETBEUI" , "slock-AF_SECURITY" ,
167 "slock-AF_KEY" , "slock-AF_NETLINK" , "slock-AF_PACKET" ,
168 "slock-AF_ASH" , "slock-AF_ECONET" , "slock-AF_ATMSVC" ,
169 "slock-21" , "slock-AF_SNA" , "slock-AF_IRDA" ,
170 "slock-AF_PPPOX" , "slock-AF_WANPIPE" , "slock-AF_LLC" ,
171 "slock-27" , "slock-28" , "slock-29" ,
172 "slock-AF_TIPC" , "slock-AF_BLUETOOTH", "slock-AF_IUCV" ,
173 "slock-AF_RXRPC" , "slock-AF_MAX"
174 };
175 static const char *af_family_clock_key_strings[AF_MAX+1] = {
176 "clock-AF_UNSPEC", "clock-AF_UNIX" , "clock-AF_INET" ,
177 "clock-AF_AX25" , "clock-AF_IPX" , "clock-AF_APPLETALK",
178 "clock-AF_NETROM", "clock-AF_BRIDGE" , "clock-AF_ATMPVC" ,
179 "clock-AF_X25" , "clock-AF_INET6" , "clock-AF_ROSE" ,
180 "clock-AF_DECnet", "clock-AF_NETBEUI" , "clock-AF_SECURITY" ,
181 "clock-AF_KEY" , "clock-AF_NETLINK" , "clock-AF_PACKET" ,
182 "clock-AF_ASH" , "clock-AF_ECONET" , "clock-AF_ATMSVC" ,
183 "clock-21" , "clock-AF_SNA" , "clock-AF_IRDA" ,
184 "clock-AF_PPPOX" , "clock-AF_WANPIPE" , "clock-AF_LLC" ,
185 "clock-27" , "clock-28" , "clock-29" ,
186 "clock-AF_TIPC" , "clock-AF_BLUETOOTH", "clock-AF_IUCV" ,
187 "clock-AF_RXRPC" , "clock-AF_MAX"
188 };
189 #endif
190
191 /*
192 * sk_callback_lock locking rules are per-address-family,
193 * so split the lock classes by using a per-AF key:
194 */
195 static struct lock_class_key af_callback_keys[AF_MAX];
196
197 /* Take into consideration the size of the struct sk_buff overhead in the
198 * determination of these values, since that is non-constant across
199 * platforms. This makes socket queueing behavior and performance
200 * not depend upon such differences.
201 */
202 #define _SK_MEM_PACKETS 256
203 #define _SK_MEM_OVERHEAD (sizeof(struct sk_buff) + 256)
204 #define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
205 #define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
206
207 /* Run time adjustable parameters. */
208 __u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
209 __u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
210 __u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
211 __u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
212
213 /* Maximal space eaten by iovec or ancilliary data plus some space */
214 int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
215
216 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
217 {
218 struct timeval tv;
219
220 if (optlen < sizeof(tv))
221 return -EINVAL;
222 if (copy_from_user(&tv, optval, sizeof(tv)))
223 return -EFAULT;
224 if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
225 return -EDOM;
226
227 if (tv.tv_sec < 0) {
228 static int warned __read_mostly;
229
230 *timeo_p = 0;
231 if (warned < 10 && net_ratelimit())
232 warned++;
233 printk(KERN_INFO "sock_set_timeout: `%s' (pid %d) "
234 "tries to set negative timeout\n",
235 current->comm, current->pid);
236 return 0;
237 }
238 *timeo_p = MAX_SCHEDULE_TIMEOUT;
239 if (tv.tv_sec == 0 && tv.tv_usec == 0)
240 return 0;
241 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
242 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
243 return 0;
244 }
245
246 static void sock_warn_obsolete_bsdism(const char *name)
247 {
248 static int warned;
249 static char warncomm[TASK_COMM_LEN];
250 if (strcmp(warncomm, current->comm) && warned < 5) {
251 strcpy(warncomm, current->comm);
252 printk(KERN_WARNING "process `%s' is using obsolete "
253 "%s SO_BSDCOMPAT\n", warncomm, name);
254 warned++;
255 }
256 }
257
258 static void sock_disable_timestamp(struct sock *sk)
259 {
260 if (sock_flag(sk, SOCK_TIMESTAMP)) {
261 sock_reset_flag(sk, SOCK_TIMESTAMP);
262 net_disable_timestamp();
263 }
264 }
265
266
267 int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
268 {
269 int err = 0;
270 int skb_len;
271
272 /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
273 number of warnings when compiling with -W --ANK
274 */
275 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
276 (unsigned)sk->sk_rcvbuf) {
277 err = -ENOMEM;
278 goto out;
279 }
280
281 err = sk_filter(sk, skb);
282 if (err)
283 goto out;
284
285 skb->dev = NULL;
286 skb_set_owner_r(skb, sk);
287
288 /* Cache the SKB length before we tack it onto the receive
289 * queue. Once it is added it no longer belongs to us and
290 * may be freed by other threads of control pulling packets
291 * from the queue.
292 */
293 skb_len = skb->len;
294
295 skb_queue_tail(&sk->sk_receive_queue, skb);
296
297 if (!sock_flag(sk, SOCK_DEAD))
298 sk->sk_data_ready(sk, skb_len);
299 out:
300 return err;
301 }
302 EXPORT_SYMBOL(sock_queue_rcv_skb);
303
304 int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
305 {
306 int rc = NET_RX_SUCCESS;
307
308 if (sk_filter(sk, skb))
309 goto discard_and_relse;
310
311 skb->dev = NULL;
312
313 if (nested)
314 bh_lock_sock_nested(sk);
315 else
316 bh_lock_sock(sk);
317 if (!sock_owned_by_user(sk)) {
318 /*
319 * trylock + unlock semantics:
320 */
321 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
322
323 rc = sk->sk_backlog_rcv(sk, skb);
324
325 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
326 } else
327 sk_add_backlog(sk, skb);
328 bh_unlock_sock(sk);
329 out:
330 sock_put(sk);
331 return rc;
332 discard_and_relse:
333 kfree_skb(skb);
334 goto out;
335 }
336 EXPORT_SYMBOL(sk_receive_skb);
337
338 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
339 {
340 struct dst_entry *dst = sk->sk_dst_cache;
341
342 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
343 sk->sk_dst_cache = NULL;
344 dst_release(dst);
345 return NULL;
346 }
347
348 return dst;
349 }
350 EXPORT_SYMBOL(__sk_dst_check);
351
352 struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
353 {
354 struct dst_entry *dst = sk_dst_get(sk);
355
356 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
357 sk_dst_reset(sk);
358 dst_release(dst);
359 return NULL;
360 }
361
362 return dst;
363 }
364 EXPORT_SYMBOL(sk_dst_check);
365
366 static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
367 {
368 int ret = -ENOPROTOOPT;
369 #ifdef CONFIG_NETDEVICES
370 char devname[IFNAMSIZ];
371 int index;
372
373 /* Sorry... */
374 ret = -EPERM;
375 if (!capable(CAP_NET_RAW))
376 goto out;
377
378 ret = -EINVAL;
379 if (optlen < 0)
380 goto out;
381
382 /* Bind this socket to a particular device like "eth0",
383 * as specified in the passed interface name. If the
384 * name is "" or the option length is zero the socket
385 * is not bound.
386 */
387 if (optlen > IFNAMSIZ - 1)
388 optlen = IFNAMSIZ - 1;
389 memset(devname, 0, sizeof(devname));
390
391 ret = -EFAULT;
392 if (copy_from_user(devname, optval, optlen))
393 goto out;
394
395 if (devname[0] == '\0') {
396 index = 0;
397 } else {
398 struct net_device *dev = dev_get_by_name(devname);
399
400 ret = -ENODEV;
401 if (!dev)
402 goto out;
403
404 index = dev->ifindex;
405 dev_put(dev);
406 }
407
408 lock_sock(sk);
409 sk->sk_bound_dev_if = index;
410 sk_dst_reset(sk);
411 release_sock(sk);
412
413 ret = 0;
414
415 out:
416 #endif
417
418 return ret;
419 }
420
421 /*
422 * This is meant for all protocols to use and covers goings on
423 * at the socket level. Everything here is generic.
424 */
425
426 int sock_setsockopt(struct socket *sock, int level, int optname,
427 char __user *optval, int optlen)
428 {
429 struct sock *sk=sock->sk;
430 struct sk_filter *filter;
431 int val;
432 int valbool;
433 struct linger ling;
434 int ret = 0;
435
436 /*
437 * Options without arguments
438 */
439
440 #ifdef SO_DONTLINGER /* Compatibility item... */
441 if (optname == SO_DONTLINGER) {
442 lock_sock(sk);
443 sock_reset_flag(sk, SOCK_LINGER);
444 release_sock(sk);
445 return 0;
446 }
447 #endif
448
449 if (optname == SO_BINDTODEVICE)
450 return sock_bindtodevice(sk, optval, optlen);
451
452 if (optlen < sizeof(int))
453 return -EINVAL;
454
455 if (get_user(val, (int __user *)optval))
456 return -EFAULT;
457
458 valbool = val?1:0;
459
460 lock_sock(sk);
461
462 switch(optname) {
463 case SO_DEBUG:
464 if (val && !capable(CAP_NET_ADMIN)) {
465 ret = -EACCES;
466 }
467 else if (valbool)
468 sock_set_flag(sk, SOCK_DBG);
469 else
470 sock_reset_flag(sk, SOCK_DBG);
471 break;
472 case SO_REUSEADDR:
473 sk->sk_reuse = valbool;
474 break;
475 case SO_TYPE:
476 case SO_ERROR:
477 ret = -ENOPROTOOPT;
478 break;
479 case SO_DONTROUTE:
480 if (valbool)
481 sock_set_flag(sk, SOCK_LOCALROUTE);
482 else
483 sock_reset_flag(sk, SOCK_LOCALROUTE);
484 break;
485 case SO_BROADCAST:
486 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
487 break;
488 case SO_SNDBUF:
489 /* Don't error on this BSD doesn't and if you think
490 about it this is right. Otherwise apps have to
491 play 'guess the biggest size' games. RCVBUF/SNDBUF
492 are treated in BSD as hints */
493
494 if (val > sysctl_wmem_max)
495 val = sysctl_wmem_max;
496 set_sndbuf:
497 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
498 if ((val * 2) < SOCK_MIN_SNDBUF)
499 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
500 else
501 sk->sk_sndbuf = val * 2;
502
503 /*
504 * Wake up sending tasks if we
505 * upped the value.
506 */
507 sk->sk_write_space(sk);
508 break;
509
510 case SO_SNDBUFFORCE:
511 if (!capable(CAP_NET_ADMIN)) {
512 ret = -EPERM;
513 break;
514 }
515 goto set_sndbuf;
516
517 case SO_RCVBUF:
518 /* Don't error on this BSD doesn't and if you think
519 about it this is right. Otherwise apps have to
520 play 'guess the biggest size' games. RCVBUF/SNDBUF
521 are treated in BSD as hints */
522
523 if (val > sysctl_rmem_max)
524 val = sysctl_rmem_max;
525 set_rcvbuf:
526 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
527 /*
528 * We double it on the way in to account for
529 * "struct sk_buff" etc. overhead. Applications
530 * assume that the SO_RCVBUF setting they make will
531 * allow that much actual data to be received on that
532 * socket.
533 *
534 * Applications are unaware that "struct sk_buff" and
535 * other overheads allocate from the receive buffer
536 * during socket buffer allocation.
537 *
538 * And after considering the possible alternatives,
539 * returning the value we actually used in getsockopt
540 * is the most desirable behavior.
541 */
542 if ((val * 2) < SOCK_MIN_RCVBUF)
543 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
544 else
545 sk->sk_rcvbuf = val * 2;
546 break;
547
548 case SO_RCVBUFFORCE:
549 if (!capable(CAP_NET_ADMIN)) {
550 ret = -EPERM;
551 break;
552 }
553 goto set_rcvbuf;
554
555 case SO_KEEPALIVE:
556 #ifdef CONFIG_INET
557 if (sk->sk_protocol == IPPROTO_TCP)
558 tcp_set_keepalive(sk, valbool);
559 #endif
560 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
561 break;
562
563 case SO_OOBINLINE:
564 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
565 break;
566
567 case SO_NO_CHECK:
568 sk->sk_no_check = valbool;
569 break;
570
571 case SO_PRIORITY:
572 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
573 sk->sk_priority = val;
574 else
575 ret = -EPERM;
576 break;
577
578 case SO_LINGER:
579 if (optlen < sizeof(ling)) {
580 ret = -EINVAL; /* 1003.1g */
581 break;
582 }
583 if (copy_from_user(&ling,optval,sizeof(ling))) {
584 ret = -EFAULT;
585 break;
586 }
587 if (!ling.l_onoff)
588 sock_reset_flag(sk, SOCK_LINGER);
589 else {
590 #if (BITS_PER_LONG == 32)
591 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
592 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
593 else
594 #endif
595 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
596 sock_set_flag(sk, SOCK_LINGER);
597 }
598 break;
599
600 case SO_BSDCOMPAT:
601 sock_warn_obsolete_bsdism("setsockopt");
602 break;
603
604 case SO_PASSCRED:
605 if (valbool)
606 set_bit(SOCK_PASSCRED, &sock->flags);
607 else
608 clear_bit(SOCK_PASSCRED, &sock->flags);
609 break;
610
611 case SO_TIMESTAMP:
612 case SO_TIMESTAMPNS:
613 if (valbool) {
614 if (optname == SO_TIMESTAMP)
615 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
616 else
617 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
618 sock_set_flag(sk, SOCK_RCVTSTAMP);
619 sock_enable_timestamp(sk);
620 } else {
621 sock_reset_flag(sk, SOCK_RCVTSTAMP);
622 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
623 }
624 break;
625
626 case SO_RCVLOWAT:
627 if (val < 0)
628 val = INT_MAX;
629 sk->sk_rcvlowat = val ? : 1;
630 break;
631
632 case SO_RCVTIMEO:
633 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
634 break;
635
636 case SO_SNDTIMEO:
637 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
638 break;
639
640 case SO_ATTACH_FILTER:
641 ret = -EINVAL;
642 if (optlen == sizeof(struct sock_fprog)) {
643 struct sock_fprog fprog;
644
645 ret = -EFAULT;
646 if (copy_from_user(&fprog, optval, sizeof(fprog)))
647 break;
648
649 ret = sk_attach_filter(&fprog, sk);
650 }
651 break;
652
653 case SO_DETACH_FILTER:
654 rcu_read_lock_bh();
655 filter = rcu_dereference(sk->sk_filter);
656 if (filter) {
657 rcu_assign_pointer(sk->sk_filter, NULL);
658 sk_filter_release(sk, filter);
659 rcu_read_unlock_bh();
660 break;
661 }
662 rcu_read_unlock_bh();
663 ret = -ENONET;
664 break;
665
666 case SO_PASSSEC:
667 if (valbool)
668 set_bit(SOCK_PASSSEC, &sock->flags);
669 else
670 clear_bit(SOCK_PASSSEC, &sock->flags);
671 break;
672
673 /* We implement the SO_SNDLOWAT etc to
674 not be settable (1003.1g 5.3) */
675 default:
676 ret = -ENOPROTOOPT;
677 break;
678 }
679 release_sock(sk);
680 return ret;
681 }
682
683
684 int sock_getsockopt(struct socket *sock, int level, int optname,
685 char __user *optval, int __user *optlen)
686 {
687 struct sock *sk = sock->sk;
688
689 union {
690 int val;
691 struct linger ling;
692 struct timeval tm;
693 } v;
694
695 unsigned int lv = sizeof(int);
696 int len;
697
698 if (get_user(len, optlen))
699 return -EFAULT;
700 if (len < 0)
701 return -EINVAL;
702
703 switch(optname) {
704 case SO_DEBUG:
705 v.val = sock_flag(sk, SOCK_DBG);
706 break;
707
708 case SO_DONTROUTE:
709 v.val = sock_flag(sk, SOCK_LOCALROUTE);
710 break;
711
712 case SO_BROADCAST:
713 v.val = !!sock_flag(sk, SOCK_BROADCAST);
714 break;
715
716 case SO_SNDBUF:
717 v.val = sk->sk_sndbuf;
718 break;
719
720 case SO_RCVBUF:
721 v.val = sk->sk_rcvbuf;
722 break;
723
724 case SO_REUSEADDR:
725 v.val = sk->sk_reuse;
726 break;
727
728 case SO_KEEPALIVE:
729 v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
730 break;
731
732 case SO_TYPE:
733 v.val = sk->sk_type;
734 break;
735
736 case SO_ERROR:
737 v.val = -sock_error(sk);
738 if (v.val==0)
739 v.val = xchg(&sk->sk_err_soft, 0);
740 break;
741
742 case SO_OOBINLINE:
743 v.val = !!sock_flag(sk, SOCK_URGINLINE);
744 break;
745
746 case SO_NO_CHECK:
747 v.val = sk->sk_no_check;
748 break;
749
750 case SO_PRIORITY:
751 v.val = sk->sk_priority;
752 break;
753
754 case SO_LINGER:
755 lv = sizeof(v.ling);
756 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER);
757 v.ling.l_linger = sk->sk_lingertime / HZ;
758 break;
759
760 case SO_BSDCOMPAT:
761 sock_warn_obsolete_bsdism("getsockopt");
762 break;
763
764 case SO_TIMESTAMP:
765 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
766 !sock_flag(sk, SOCK_RCVTSTAMPNS);
767 break;
768
769 case SO_TIMESTAMPNS:
770 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
771 break;
772
773 case SO_RCVTIMEO:
774 lv=sizeof(struct timeval);
775 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
776 v.tm.tv_sec = 0;
777 v.tm.tv_usec = 0;
778 } else {
779 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
780 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
781 }
782 break;
783
784 case SO_SNDTIMEO:
785 lv=sizeof(struct timeval);
786 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
787 v.tm.tv_sec = 0;
788 v.tm.tv_usec = 0;
789 } else {
790 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
791 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
792 }
793 break;
794
795 case SO_RCVLOWAT:
796 v.val = sk->sk_rcvlowat;
797 break;
798
799 case SO_SNDLOWAT:
800 v.val=1;
801 break;
802
803 case SO_PASSCRED:
804 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
805 break;
806
807 case SO_PEERCRED:
808 if (len > sizeof(sk->sk_peercred))
809 len = sizeof(sk->sk_peercred);
810 if (copy_to_user(optval, &sk->sk_peercred, len))
811 return -EFAULT;
812 goto lenout;
813
814 case SO_PEERNAME:
815 {
816 char address[128];
817
818 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
819 return -ENOTCONN;
820 if (lv < len)
821 return -EINVAL;
822 if (copy_to_user(optval, address, len))
823 return -EFAULT;
824 goto lenout;
825 }
826
827 /* Dubious BSD thing... Probably nobody even uses it, but
828 * the UNIX standard wants it for whatever reason... -DaveM
829 */
830 case SO_ACCEPTCONN:
831 v.val = sk->sk_state == TCP_LISTEN;
832 break;
833
834 case SO_PASSSEC:
835 v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0;
836 break;
837
838 case SO_PEERSEC:
839 return security_socket_getpeersec_stream(sock, optval, optlen, len);
840
841 default:
842 return -ENOPROTOOPT;
843 }
844
845 if (len > lv)
846 len = lv;
847 if (copy_to_user(optval, &v, len))
848 return -EFAULT;
849 lenout:
850 if (put_user(len, optlen))
851 return -EFAULT;
852 return 0;
853 }
854
855 /*
856 * Initialize an sk_lock.
857 *
858 * (We also register the sk_lock with the lock validator.)
859 */
860 static inline void sock_lock_init(struct sock *sk)
861 {
862 sock_lock_init_class_and_name(sk,
863 af_family_slock_key_strings[sk->sk_family],
864 af_family_slock_keys + sk->sk_family,
865 af_family_key_strings[sk->sk_family],
866 af_family_keys + sk->sk_family);
867 }
868
869 /**
870 * sk_alloc - All socket objects are allocated here
871 * @family: protocol family
872 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
873 * @prot: struct proto associated with this new sock instance
874 * @zero_it: if we should zero the newly allocated sock
875 */
876 struct sock *sk_alloc(int family, gfp_t priority,
877 struct proto *prot, int zero_it)
878 {
879 struct sock *sk = NULL;
880 struct kmem_cache *slab = prot->slab;
881
882 if (slab != NULL)
883 sk = kmem_cache_alloc(slab, priority);
884 else
885 sk = kmalloc(prot->obj_size, priority);
886
887 if (sk) {
888 if (zero_it) {
889 memset(sk, 0, prot->obj_size);
890 sk->sk_family = family;
891 /*
892 * See comment in struct sock definition to understand
893 * why we need sk_prot_creator -acme
894 */
895 sk->sk_prot = sk->sk_prot_creator = prot;
896 sock_lock_init(sk);
897 }
898
899 if (security_sk_alloc(sk, family, priority))
900 goto out_free;
901
902 if (!try_module_get(prot->owner))
903 goto out_free;
904 }
905 return sk;
906
907 out_free:
908 if (slab != NULL)
909 kmem_cache_free(slab, sk);
910 else
911 kfree(sk);
912 return NULL;
913 }
914
915 void sk_free(struct sock *sk)
916 {
917 struct sk_filter *filter;
918 struct module *owner = sk->sk_prot_creator->owner;
919
920 if (sk->sk_destruct)
921 sk->sk_destruct(sk);
922
923 filter = rcu_dereference(sk->sk_filter);
924 if (filter) {
925 sk_filter_release(sk, filter);
926 rcu_assign_pointer(sk->sk_filter, NULL);
927 }
928
929 sock_disable_timestamp(sk);
930
931 if (atomic_read(&sk->sk_omem_alloc))
932 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
933 __FUNCTION__, atomic_read(&sk->sk_omem_alloc));
934
935 security_sk_free(sk);
936 if (sk->sk_prot_creator->slab != NULL)
937 kmem_cache_free(sk->sk_prot_creator->slab, sk);
938 else
939 kfree(sk);
940 module_put(owner);
941 }
942
943 struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
944 {
945 struct sock *newsk = sk_alloc(sk->sk_family, priority, sk->sk_prot, 0);
946
947 if (newsk != NULL) {
948 struct sk_filter *filter;
949
950 sock_copy(newsk, sk);
951
952 /* SANITY */
953 sk_node_init(&newsk->sk_node);
954 sock_lock_init(newsk);
955 bh_lock_sock(newsk);
956 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
957
958 atomic_set(&newsk->sk_rmem_alloc, 0);
959 atomic_set(&newsk->sk_wmem_alloc, 0);
960 atomic_set(&newsk->sk_omem_alloc, 0);
961 skb_queue_head_init(&newsk->sk_receive_queue);
962 skb_queue_head_init(&newsk->sk_write_queue);
963 #ifdef CONFIG_NET_DMA
964 skb_queue_head_init(&newsk->sk_async_wait_queue);
965 #endif
966
967 rwlock_init(&newsk->sk_dst_lock);
968 rwlock_init(&newsk->sk_callback_lock);
969 lockdep_set_class_and_name(&newsk->sk_callback_lock,
970 af_callback_keys + newsk->sk_family,
971 af_family_clock_key_strings[newsk->sk_family]);
972
973 newsk->sk_dst_cache = NULL;
974 newsk->sk_wmem_queued = 0;
975 newsk->sk_forward_alloc = 0;
976 newsk->sk_send_head = NULL;
977 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
978
979 sock_reset_flag(newsk, SOCK_DONE);
980 skb_queue_head_init(&newsk->sk_error_queue);
981
982 filter = newsk->sk_filter;
983 if (filter != NULL)
984 sk_filter_charge(newsk, filter);
985
986 if (unlikely(xfrm_sk_clone_policy(newsk))) {
987 /* It is still raw copy of parent, so invalidate
988 * destructor and make plain sk_free() */
989 newsk->sk_destruct = NULL;
990 sk_free(newsk);
991 newsk = NULL;
992 goto out;
993 }
994
995 newsk->sk_err = 0;
996 newsk->sk_priority = 0;
997 atomic_set(&newsk->sk_refcnt, 2);
998
999 /*
1000 * Increment the counter in the same struct proto as the master
1001 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1002 * is the same as sk->sk_prot->socks, as this field was copied
1003 * with memcpy).
1004 *
1005 * This _changes_ the previous behaviour, where
1006 * tcp_create_openreq_child always was incrementing the
1007 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1008 * to be taken into account in all callers. -acme
1009 */
1010 sk_refcnt_debug_inc(newsk);
1011 newsk->sk_socket = NULL;
1012 newsk->sk_sleep = NULL;
1013
1014 if (newsk->sk_prot->sockets_allocated)
1015 atomic_inc(newsk->sk_prot->sockets_allocated);
1016 }
1017 out:
1018 return newsk;
1019 }
1020
1021 EXPORT_SYMBOL_GPL(sk_clone);
1022
1023 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1024 {
1025 __sk_dst_set(sk, dst);
1026 sk->sk_route_caps = dst->dev->features;
1027 if (sk->sk_route_caps & NETIF_F_GSO)
1028 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1029 if (sk_can_gso(sk)) {
1030 if (dst->header_len)
1031 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1032 else
1033 sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1034 }
1035 }
1036 EXPORT_SYMBOL_GPL(sk_setup_caps);
1037
1038 void __init sk_init(void)
1039 {
1040 if (num_physpages <= 4096) {
1041 sysctl_wmem_max = 32767;
1042 sysctl_rmem_max = 32767;
1043 sysctl_wmem_default = 32767;
1044 sysctl_rmem_default = 32767;
1045 } else if (num_physpages >= 131072) {
1046 sysctl_wmem_max = 131071;
1047 sysctl_rmem_max = 131071;
1048 }
1049 }
1050
1051 /*
1052 * Simple resource managers for sockets.
1053 */
1054
1055
1056 /*
1057 * Write buffer destructor automatically called from kfree_skb.
1058 */
1059 void sock_wfree(struct sk_buff *skb)
1060 {
1061 struct sock *sk = skb->sk;
1062
1063 /* In case it might be waiting for more memory. */
1064 atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
1065 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
1066 sk->sk_write_space(sk);
1067 sock_put(sk);
1068 }
1069
1070 /*
1071 * Read buffer destructor automatically called from kfree_skb.
1072 */
1073 void sock_rfree(struct sk_buff *skb)
1074 {
1075 struct sock *sk = skb->sk;
1076
1077 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
1078 }
1079
1080
1081 int sock_i_uid(struct sock *sk)
1082 {
1083 int uid;
1084
1085 read_lock(&sk->sk_callback_lock);
1086 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1087 read_unlock(&sk->sk_callback_lock);
1088 return uid;
1089 }
1090
1091 unsigned long sock_i_ino(struct sock *sk)
1092 {
1093 unsigned long ino;
1094
1095 read_lock(&sk->sk_callback_lock);
1096 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1097 read_unlock(&sk->sk_callback_lock);
1098 return ino;
1099 }
1100
1101 /*
1102 * Allocate a skb from the socket's send buffer.
1103 */
1104 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1105 gfp_t priority)
1106 {
1107 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1108 struct sk_buff * skb = alloc_skb(size, priority);
1109 if (skb) {
1110 skb_set_owner_w(skb, sk);
1111 return skb;
1112 }
1113 }
1114 return NULL;
1115 }
1116
1117 /*
1118 * Allocate a skb from the socket's receive buffer.
1119 */
1120 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
1121 gfp_t priority)
1122 {
1123 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1124 struct sk_buff *skb = alloc_skb(size, priority);
1125 if (skb) {
1126 skb_set_owner_r(skb, sk);
1127 return skb;
1128 }
1129 }
1130 return NULL;
1131 }
1132
1133 /*
1134 * Allocate a memory block from the socket's option memory buffer.
1135 */
1136 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1137 {
1138 if ((unsigned)size <= sysctl_optmem_max &&
1139 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1140 void *mem;
1141 /* First do the add, to avoid the race if kmalloc
1142 * might sleep.
1143 */
1144 atomic_add(size, &sk->sk_omem_alloc);
1145 mem = kmalloc(size, priority);
1146 if (mem)
1147 return mem;
1148 atomic_sub(size, &sk->sk_omem_alloc);
1149 }
1150 return NULL;
1151 }
1152
1153 /*
1154 * Free an option memory block.
1155 */
1156 void sock_kfree_s(struct sock *sk, void *mem, int size)
1157 {
1158 kfree(mem);
1159 atomic_sub(size, &sk->sk_omem_alloc);
1160 }
1161
1162 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1163 I think, these locks should be removed for datagram sockets.
1164 */
1165 static long sock_wait_for_wmem(struct sock * sk, long timeo)
1166 {
1167 DEFINE_WAIT(wait);
1168
1169 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1170 for (;;) {
1171 if (!timeo)
1172 break;
1173 if (signal_pending(current))
1174 break;
1175 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1176 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1177 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1178 break;
1179 if (sk->sk_shutdown & SEND_SHUTDOWN)
1180 break;
1181 if (sk->sk_err)
1182 break;
1183 timeo = schedule_timeout(timeo);
1184 }
1185 finish_wait(sk->sk_sleep, &wait);
1186 return timeo;
1187 }
1188
1189
1190 /*
1191 * Generic send/receive buffer handlers
1192 */
1193
1194 static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
1195 unsigned long header_len,
1196 unsigned long data_len,
1197 int noblock, int *errcode)
1198 {
1199 struct sk_buff *skb;
1200 gfp_t gfp_mask;
1201 long timeo;
1202 int err;
1203
1204 gfp_mask = sk->sk_allocation;
1205 if (gfp_mask & __GFP_WAIT)
1206 gfp_mask |= __GFP_REPEAT;
1207
1208 timeo = sock_sndtimeo(sk, noblock);
1209 while (1) {
1210 err = sock_error(sk);
1211 if (err != 0)
1212 goto failure;
1213
1214 err = -EPIPE;
1215 if (sk->sk_shutdown & SEND_SHUTDOWN)
1216 goto failure;
1217
1218 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1219 skb = alloc_skb(header_len, gfp_mask);
1220 if (skb) {
1221 int npages;
1222 int i;
1223
1224 /* No pages, we're done... */
1225 if (!data_len)
1226 break;
1227
1228 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1229 skb->truesize += data_len;
1230 skb_shinfo(skb)->nr_frags = npages;
1231 for (i = 0; i < npages; i++) {
1232 struct page *page;
1233 skb_frag_t *frag;
1234
1235 page = alloc_pages(sk->sk_allocation, 0);
1236 if (!page) {
1237 err = -ENOBUFS;
1238 skb_shinfo(skb)->nr_frags = i;
1239 kfree_skb(skb);
1240 goto failure;
1241 }
1242
1243 frag = &skb_shinfo(skb)->frags[i];
1244 frag->page = page;
1245 frag->page_offset = 0;
1246 frag->size = (data_len >= PAGE_SIZE ?
1247 PAGE_SIZE :
1248 data_len);
1249 data_len -= PAGE_SIZE;
1250 }
1251
1252 /* Full success... */
1253 break;
1254 }
1255 err = -ENOBUFS;
1256 goto failure;
1257 }
1258 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1259 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1260 err = -EAGAIN;
1261 if (!timeo)
1262 goto failure;
1263 if (signal_pending(current))
1264 goto interrupted;
1265 timeo = sock_wait_for_wmem(sk, timeo);
1266 }
1267
1268 skb_set_owner_w(skb, sk);
1269 return skb;
1270
1271 interrupted:
1272 err = sock_intr_errno(timeo);
1273 failure:
1274 *errcode = err;
1275 return NULL;
1276 }
1277
1278 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1279 int noblock, int *errcode)
1280 {
1281 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1282 }
1283
1284 static void __lock_sock(struct sock *sk)
1285 {
1286 DEFINE_WAIT(wait);
1287
1288 for (;;) {
1289 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1290 TASK_UNINTERRUPTIBLE);
1291 spin_unlock_bh(&sk->sk_lock.slock);
1292 schedule();
1293 spin_lock_bh(&sk->sk_lock.slock);
1294 if (!sock_owned_by_user(sk))
1295 break;
1296 }
1297 finish_wait(&sk->sk_lock.wq, &wait);
1298 }
1299
1300 static void __release_sock(struct sock *sk)
1301 {
1302 struct sk_buff *skb = sk->sk_backlog.head;
1303
1304 do {
1305 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1306 bh_unlock_sock(sk);
1307
1308 do {
1309 struct sk_buff *next = skb->next;
1310
1311 skb->next = NULL;
1312 sk->sk_backlog_rcv(sk, skb);
1313
1314 /*
1315 * We are in process context here with softirqs
1316 * disabled, use cond_resched_softirq() to preempt.
1317 * This is safe to do because we've taken the backlog
1318 * queue private:
1319 */
1320 cond_resched_softirq();
1321
1322 skb = next;
1323 } while (skb != NULL);
1324
1325 bh_lock_sock(sk);
1326 } while ((skb = sk->sk_backlog.head) != NULL);
1327 }
1328
1329 /**
1330 * sk_wait_data - wait for data to arrive at sk_receive_queue
1331 * @sk: sock to wait on
1332 * @timeo: for how long
1333 *
1334 * Now socket state including sk->sk_err is changed only under lock,
1335 * hence we may omit checks after joining wait queue.
1336 * We check receive queue before schedule() only as optimization;
1337 * it is very likely that release_sock() added new data.
1338 */
1339 int sk_wait_data(struct sock *sk, long *timeo)
1340 {
1341 int rc;
1342 DEFINE_WAIT(wait);
1343
1344 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1345 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1346 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1347 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1348 finish_wait(sk->sk_sleep, &wait);
1349 return rc;
1350 }
1351
1352 EXPORT_SYMBOL(sk_wait_data);
1353
1354 /*
1355 * Set of default routines for initialising struct proto_ops when
1356 * the protocol does not support a particular function. In certain
1357 * cases where it makes no sense for a protocol to have a "do nothing"
1358 * function, some default processing is provided.
1359 */
1360
1361 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1362 {
1363 return -EOPNOTSUPP;
1364 }
1365
1366 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1367 int len, int flags)
1368 {
1369 return -EOPNOTSUPP;
1370 }
1371
1372 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1373 {
1374 return -EOPNOTSUPP;
1375 }
1376
1377 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1378 {
1379 return -EOPNOTSUPP;
1380 }
1381
1382 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1383 int *len, int peer)
1384 {
1385 return -EOPNOTSUPP;
1386 }
1387
1388 unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
1389 {
1390 return 0;
1391 }
1392
1393 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1394 {
1395 return -EOPNOTSUPP;
1396 }
1397
1398 int sock_no_listen(struct socket *sock, int backlog)
1399 {
1400 return -EOPNOTSUPP;
1401 }
1402
1403 int sock_no_shutdown(struct socket *sock, int how)
1404 {
1405 return -EOPNOTSUPP;
1406 }
1407
1408 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1409 char __user *optval, int optlen)
1410 {
1411 return -EOPNOTSUPP;
1412 }
1413
1414 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1415 char __user *optval, int __user *optlen)
1416 {
1417 return -EOPNOTSUPP;
1418 }
1419
1420 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1421 size_t len)
1422 {
1423 return -EOPNOTSUPP;
1424 }
1425
1426 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1427 size_t len, int flags)
1428 {
1429 return -EOPNOTSUPP;
1430 }
1431
1432 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1433 {
1434 /* Mirror missing mmap method error code */
1435 return -ENODEV;
1436 }
1437
1438 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1439 {
1440 ssize_t res;
1441 struct msghdr msg = {.msg_flags = flags};
1442 struct kvec iov;
1443 char *kaddr = kmap(page);
1444 iov.iov_base = kaddr + offset;
1445 iov.iov_len = size;
1446 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1447 kunmap(page);
1448 return res;
1449 }
1450
1451 /*
1452 * Default Socket Callbacks
1453 */
1454
1455 static void sock_def_wakeup(struct sock *sk)
1456 {
1457 read_lock(&sk->sk_callback_lock);
1458 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1459 wake_up_interruptible_all(sk->sk_sleep);
1460 read_unlock(&sk->sk_callback_lock);
1461 }
1462
1463 static void sock_def_error_report(struct sock *sk)
1464 {
1465 read_lock(&sk->sk_callback_lock);
1466 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1467 wake_up_interruptible(sk->sk_sleep);
1468 sk_wake_async(sk,0,POLL_ERR);
1469 read_unlock(&sk->sk_callback_lock);
1470 }
1471
1472 static void sock_def_readable(struct sock *sk, int len)
1473 {
1474 read_lock(&sk->sk_callback_lock);
1475 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1476 wake_up_interruptible(sk->sk_sleep);
1477 sk_wake_async(sk,1,POLL_IN);
1478 read_unlock(&sk->sk_callback_lock);
1479 }
1480
1481 static void sock_def_write_space(struct sock *sk)
1482 {
1483 read_lock(&sk->sk_callback_lock);
1484
1485 /* Do not wake up a writer until he can make "significant"
1486 * progress. --DaveM
1487 */
1488 if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1489 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1490 wake_up_interruptible(sk->sk_sleep);
1491
1492 /* Should agree with poll, otherwise some programs break */
1493 if (sock_writeable(sk))
1494 sk_wake_async(sk, 2, POLL_OUT);
1495 }
1496
1497 read_unlock(&sk->sk_callback_lock);
1498 }
1499
1500 static void sock_def_destruct(struct sock *sk)
1501 {
1502 kfree(sk->sk_protinfo);
1503 }
1504
1505 void sk_send_sigurg(struct sock *sk)
1506 {
1507 if (sk->sk_socket && sk->sk_socket->file)
1508 if (send_sigurg(&sk->sk_socket->file->f_owner))
1509 sk_wake_async(sk, 3, POLL_PRI);
1510 }
1511
1512 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1513 unsigned long expires)
1514 {
1515 if (!mod_timer(timer, expires))
1516 sock_hold(sk);
1517 }
1518
1519 EXPORT_SYMBOL(sk_reset_timer);
1520
1521 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1522 {
1523 if (timer_pending(timer) && del_timer(timer))
1524 __sock_put(sk);
1525 }
1526
1527 EXPORT_SYMBOL(sk_stop_timer);
1528
1529 void sock_init_data(struct socket *sock, struct sock *sk)
1530 {
1531 skb_queue_head_init(&sk->sk_receive_queue);
1532 skb_queue_head_init(&sk->sk_write_queue);
1533 skb_queue_head_init(&sk->sk_error_queue);
1534 #ifdef CONFIG_NET_DMA
1535 skb_queue_head_init(&sk->sk_async_wait_queue);
1536 #endif
1537
1538 sk->sk_send_head = NULL;
1539
1540 init_timer(&sk->sk_timer);
1541
1542 sk->sk_allocation = GFP_KERNEL;
1543 sk->sk_rcvbuf = sysctl_rmem_default;
1544 sk->sk_sndbuf = sysctl_wmem_default;
1545 sk->sk_state = TCP_CLOSE;
1546 sk->sk_socket = sock;
1547
1548 sock_set_flag(sk, SOCK_ZAPPED);
1549
1550 if (sock) {
1551 sk->sk_type = sock->type;
1552 sk->sk_sleep = &sock->wait;
1553 sock->sk = sk;
1554 } else
1555 sk->sk_sleep = NULL;
1556
1557 rwlock_init(&sk->sk_dst_lock);
1558 rwlock_init(&sk->sk_callback_lock);
1559 lockdep_set_class_and_name(&sk->sk_callback_lock,
1560 af_callback_keys + sk->sk_family,
1561 af_family_clock_key_strings[sk->sk_family]);
1562
1563 sk->sk_state_change = sock_def_wakeup;
1564 sk->sk_data_ready = sock_def_readable;
1565 sk->sk_write_space = sock_def_write_space;
1566 sk->sk_error_report = sock_def_error_report;
1567 sk->sk_destruct = sock_def_destruct;
1568
1569 sk->sk_sndmsg_page = NULL;
1570 sk->sk_sndmsg_off = 0;
1571
1572 sk->sk_peercred.pid = 0;
1573 sk->sk_peercred.uid = -1;
1574 sk->sk_peercred.gid = -1;
1575 sk->sk_write_pending = 0;
1576 sk->sk_rcvlowat = 1;
1577 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
1578 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
1579
1580 sk->sk_stamp = ktime_set(-1L, -1L);
1581
1582 atomic_set(&sk->sk_refcnt, 1);
1583 }
1584
1585 void fastcall lock_sock_nested(struct sock *sk, int subclass)
1586 {
1587 might_sleep();
1588 spin_lock_bh(&sk->sk_lock.slock);
1589 if (sk->sk_lock.owned)
1590 __lock_sock(sk);
1591 sk->sk_lock.owned = 1;
1592 spin_unlock(&sk->sk_lock.slock);
1593 /*
1594 * The sk_lock has mutex_lock() semantics here:
1595 */
1596 mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
1597 local_bh_enable();
1598 }
1599
1600 EXPORT_SYMBOL(lock_sock_nested);
1601
1602 void fastcall release_sock(struct sock *sk)
1603 {
1604 /*
1605 * The sk_lock has mutex_unlock() semantics:
1606 */
1607 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
1608
1609 spin_lock_bh(&sk->sk_lock.slock);
1610 if (sk->sk_backlog.tail)
1611 __release_sock(sk);
1612 sk->sk_lock.owned = 0;
1613 if (waitqueue_active(&sk->sk_lock.wq))
1614 wake_up(&sk->sk_lock.wq);
1615 spin_unlock_bh(&sk->sk_lock.slock);
1616 }
1617 EXPORT_SYMBOL(release_sock);
1618
1619 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
1620 {
1621 struct timeval tv;
1622 if (!sock_flag(sk, SOCK_TIMESTAMP))
1623 sock_enable_timestamp(sk);
1624 tv = ktime_to_timeval(sk->sk_stamp);
1625 if (tv.tv_sec == -1)
1626 return -ENOENT;
1627 if (tv.tv_sec == 0) {
1628 sk->sk_stamp = ktime_get_real();
1629 tv = ktime_to_timeval(sk->sk_stamp);
1630 }
1631 return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
1632 }
1633 EXPORT_SYMBOL(sock_get_timestamp);
1634
1635 int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
1636 {
1637 struct timespec ts;
1638 if (!sock_flag(sk, SOCK_TIMESTAMP))
1639 sock_enable_timestamp(sk);
1640 ts = ktime_to_timespec(sk->sk_stamp);
1641 if (ts.tv_sec == -1)
1642 return -ENOENT;
1643 if (ts.tv_sec == 0) {
1644 sk->sk_stamp = ktime_get_real();
1645 ts = ktime_to_timespec(sk->sk_stamp);
1646 }
1647 return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
1648 }
1649 EXPORT_SYMBOL(sock_get_timestampns);
1650
1651 void sock_enable_timestamp(struct sock *sk)
1652 {
1653 if (!sock_flag(sk, SOCK_TIMESTAMP)) {
1654 sock_set_flag(sk, SOCK_TIMESTAMP);
1655 net_enable_timestamp();
1656 }
1657 }
1658 EXPORT_SYMBOL(sock_enable_timestamp);
1659
1660 /*
1661 * Get a socket option on an socket.
1662 *
1663 * FIX: POSIX 1003.1g is very ambiguous here. It states that
1664 * asynchronous errors should be reported by getsockopt. We assume
1665 * this means if you specify SO_ERROR (otherwise whats the point of it).
1666 */
1667 int sock_common_getsockopt(struct socket *sock, int level, int optname,
1668 char __user *optval, int __user *optlen)
1669 {
1670 struct sock *sk = sock->sk;
1671
1672 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1673 }
1674
1675 EXPORT_SYMBOL(sock_common_getsockopt);
1676
1677 #ifdef CONFIG_COMPAT
1678 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
1679 char __user *optval, int __user *optlen)
1680 {
1681 struct sock *sk = sock->sk;
1682
1683 if (sk->sk_prot->compat_getsockopt != NULL)
1684 return sk->sk_prot->compat_getsockopt(sk, level, optname,
1685 optval, optlen);
1686 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1687 }
1688 EXPORT_SYMBOL(compat_sock_common_getsockopt);
1689 #endif
1690
1691 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1692 struct msghdr *msg, size_t size, int flags)
1693 {
1694 struct sock *sk = sock->sk;
1695 int addr_len = 0;
1696 int err;
1697
1698 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
1699 flags & ~MSG_DONTWAIT, &addr_len);
1700 if (err >= 0)
1701 msg->msg_namelen = addr_len;
1702 return err;
1703 }
1704
1705 EXPORT_SYMBOL(sock_common_recvmsg);
1706
1707 /*
1708 * Set socket options on an inet socket.
1709 */
1710 int sock_common_setsockopt(struct socket *sock, int level, int optname,
1711 char __user *optval, int optlen)
1712 {
1713 struct sock *sk = sock->sk;
1714
1715 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1716 }
1717
1718 EXPORT_SYMBOL(sock_common_setsockopt);
1719
1720 #ifdef CONFIG_COMPAT
1721 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
1722 char __user *optval, int optlen)
1723 {
1724 struct sock *sk = sock->sk;
1725
1726 if (sk->sk_prot->compat_setsockopt != NULL)
1727 return sk->sk_prot->compat_setsockopt(sk, level, optname,
1728 optval, optlen);
1729 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1730 }
1731 EXPORT_SYMBOL(compat_sock_common_setsockopt);
1732 #endif
1733
1734 void sk_common_release(struct sock *sk)
1735 {
1736 if (sk->sk_prot->destroy)
1737 sk->sk_prot->destroy(sk);
1738
1739 /*
1740 * Observation: when sock_common_release is called, processes have
1741 * no access to socket. But net still has.
1742 * Step one, detach it from networking:
1743 *
1744 * A. Remove from hash tables.
1745 */
1746
1747 sk->sk_prot->unhash(sk);
1748
1749 /*
1750 * In this point socket cannot receive new packets, but it is possible
1751 * that some packets are in flight because some CPU runs receiver and
1752 * did hash table lookup before we unhashed socket. They will achieve
1753 * receive queue and will be purged by socket destructor.
1754 *
1755 * Also we still have packets pending on receive queue and probably,
1756 * our own packets waiting in device queues. sock_destroy will drain
1757 * receive queue, but transmitted packets will delay socket destruction
1758 * until the last reference will be released.
1759 */
1760
1761 sock_orphan(sk);
1762
1763 xfrm_sk_free_policy(sk);
1764
1765 sk_refcnt_debug_release(sk);
1766 sock_put(sk);
1767 }
1768
1769 EXPORT_SYMBOL(sk_common_release);
1770
1771 static DEFINE_RWLOCK(proto_list_lock);
1772 static LIST_HEAD(proto_list);
1773
1774 int proto_register(struct proto *prot, int alloc_slab)
1775 {
1776 char *request_sock_slab_name = NULL;
1777 char *timewait_sock_slab_name;
1778 int rc = -ENOBUFS;
1779
1780 if (alloc_slab) {
1781 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
1782 SLAB_HWCACHE_ALIGN, NULL);
1783
1784 if (prot->slab == NULL) {
1785 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
1786 prot->name);
1787 goto out;
1788 }
1789
1790 if (prot->rsk_prot != NULL) {
1791 static const char mask[] = "request_sock_%s";
1792
1793 request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1794 if (request_sock_slab_name == NULL)
1795 goto out_free_sock_slab;
1796
1797 sprintf(request_sock_slab_name, mask, prot->name);
1798 prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name,
1799 prot->rsk_prot->obj_size, 0,
1800 SLAB_HWCACHE_ALIGN, NULL);
1801
1802 if (prot->rsk_prot->slab == NULL) {
1803 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
1804 prot->name);
1805 goto out_free_request_sock_slab_name;
1806 }
1807 }
1808
1809 if (prot->twsk_prot != NULL) {
1810 static const char mask[] = "tw_sock_%s";
1811
1812 timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1813
1814 if (timewait_sock_slab_name == NULL)
1815 goto out_free_request_sock_slab;
1816
1817 sprintf(timewait_sock_slab_name, mask, prot->name);
1818 prot->twsk_prot->twsk_slab =
1819 kmem_cache_create(timewait_sock_slab_name,
1820 prot->twsk_prot->twsk_obj_size,
1821 0, SLAB_HWCACHE_ALIGN,
1822 NULL);
1823 if (prot->twsk_prot->twsk_slab == NULL)
1824 goto out_free_timewait_sock_slab_name;
1825 }
1826 }
1827
1828 write_lock(&proto_list_lock);
1829 list_add(&prot->node, &proto_list);
1830 write_unlock(&proto_list_lock);
1831 rc = 0;
1832 out:
1833 return rc;
1834 out_free_timewait_sock_slab_name:
1835 kfree(timewait_sock_slab_name);
1836 out_free_request_sock_slab:
1837 if (prot->rsk_prot && prot->rsk_prot->slab) {
1838 kmem_cache_destroy(prot->rsk_prot->slab);
1839 prot->rsk_prot->slab = NULL;
1840 }
1841 out_free_request_sock_slab_name:
1842 kfree(request_sock_slab_name);
1843 out_free_sock_slab:
1844 kmem_cache_destroy(prot->slab);
1845 prot->slab = NULL;
1846 goto out;
1847 }
1848
1849 EXPORT_SYMBOL(proto_register);
1850
1851 void proto_unregister(struct proto *prot)
1852 {
1853 write_lock(&proto_list_lock);
1854 list_del(&prot->node);
1855 write_unlock(&proto_list_lock);
1856
1857 if (prot->slab != NULL) {
1858 kmem_cache_destroy(prot->slab);
1859 prot->slab = NULL;
1860 }
1861
1862 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
1863 const char *name = kmem_cache_name(prot->rsk_prot->slab);
1864
1865 kmem_cache_destroy(prot->rsk_prot->slab);
1866 kfree(name);
1867 prot->rsk_prot->slab = NULL;
1868 }
1869
1870 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
1871 const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab);
1872
1873 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
1874 kfree(name);
1875 prot->twsk_prot->twsk_slab = NULL;
1876 }
1877 }
1878
1879 EXPORT_SYMBOL(proto_unregister);
1880
1881 #ifdef CONFIG_PROC_FS
1882 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
1883 {
1884 read_lock(&proto_list_lock);
1885 return seq_list_start_head(&proto_list, *pos);
1886 }
1887
1888 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1889 {
1890 return seq_list_next(v, &proto_list, pos);
1891 }
1892
1893 static void proto_seq_stop(struct seq_file *seq, void *v)
1894 {
1895 read_unlock(&proto_list_lock);
1896 }
1897
1898 static char proto_method_implemented(const void *method)
1899 {
1900 return method == NULL ? 'n' : 'y';
1901 }
1902
1903 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
1904 {
1905 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s "
1906 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
1907 proto->name,
1908 proto->obj_size,
1909 proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
1910 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
1911 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
1912 proto->max_header,
1913 proto->slab == NULL ? "no" : "yes",
1914 module_name(proto->owner),
1915 proto_method_implemented(proto->close),
1916 proto_method_implemented(proto->connect),
1917 proto_method_implemented(proto->disconnect),
1918 proto_method_implemented(proto->accept),
1919 proto_method_implemented(proto->ioctl),
1920 proto_method_implemented(proto->init),
1921 proto_method_implemented(proto->destroy),
1922 proto_method_implemented(proto->shutdown),
1923 proto_method_implemented(proto->setsockopt),
1924 proto_method_implemented(proto->getsockopt),
1925 proto_method_implemented(proto->sendmsg),
1926 proto_method_implemented(proto->recvmsg),
1927 proto_method_implemented(proto->sendpage),
1928 proto_method_implemented(proto->bind),
1929 proto_method_implemented(proto->backlog_rcv),
1930 proto_method_implemented(proto->hash),
1931 proto_method_implemented(proto->unhash),
1932 proto_method_implemented(proto->get_port),
1933 proto_method_implemented(proto->enter_memory_pressure));
1934 }
1935
1936 static int proto_seq_show(struct seq_file *seq, void *v)
1937 {
1938 if (v == &proto_list)
1939 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
1940 "protocol",
1941 "size",
1942 "sockets",
1943 "memory",
1944 "press",
1945 "maxhdr",
1946 "slab",
1947 "module",
1948 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
1949 else
1950 proto_seq_printf(seq, list_entry(v, struct proto, node));
1951 return 0;
1952 }
1953
1954 static const struct seq_operations proto_seq_ops = {
1955 .start = proto_seq_start,
1956 .next = proto_seq_next,
1957 .stop = proto_seq_stop,
1958 .show = proto_seq_show,
1959 };
1960
1961 static int proto_seq_open(struct inode *inode, struct file *file)
1962 {
1963 return seq_open(file, &proto_seq_ops);
1964 }
1965
1966 static const struct file_operations proto_seq_fops = {
1967 .owner = THIS_MODULE,
1968 .open = proto_seq_open,
1969 .read = seq_read,
1970 .llseek = seq_lseek,
1971 .release = seq_release,
1972 };
1973
1974 static int __init proto_init(void)
1975 {
1976 /* register /proc/net/protocols */
1977 return proc_net_fops_create(&init_net, "protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
1978 }
1979
1980 subsys_initcall(proto_init);
1981
1982 #endif /* PROC_FS */
1983
1984 EXPORT_SYMBOL(sk_alloc);
1985 EXPORT_SYMBOL(sk_free);
1986 EXPORT_SYMBOL(sk_send_sigurg);
1987 EXPORT_SYMBOL(sock_alloc_send_skb);
1988 EXPORT_SYMBOL(sock_init_data);
1989 EXPORT_SYMBOL(sock_kfree_s);
1990 EXPORT_SYMBOL(sock_kmalloc);
1991 EXPORT_SYMBOL(sock_no_accept);
1992 EXPORT_SYMBOL(sock_no_bind);
1993 EXPORT_SYMBOL(sock_no_connect);
1994 EXPORT_SYMBOL(sock_no_getname);
1995 EXPORT_SYMBOL(sock_no_getsockopt);
1996 EXPORT_SYMBOL(sock_no_ioctl);
1997 EXPORT_SYMBOL(sock_no_listen);
1998 EXPORT_SYMBOL(sock_no_mmap);
1999 EXPORT_SYMBOL(sock_no_poll);
2000 EXPORT_SYMBOL(sock_no_recvmsg);
2001 EXPORT_SYMBOL(sock_no_sendmsg);
2002 EXPORT_SYMBOL(sock_no_sendpage);
2003 EXPORT_SYMBOL(sock_no_setsockopt);
2004 EXPORT_SYMBOL(sock_no_shutdown);
2005 EXPORT_SYMBOL(sock_no_socketpair);
2006 EXPORT_SYMBOL(sock_rfree);
2007 EXPORT_SYMBOL(sock_setsockopt);
2008 EXPORT_SYMBOL(sock_wfree);
2009 EXPORT_SYMBOL(sock_wmalloc);
2010 EXPORT_SYMBOL(sock_i_uid);
2011 EXPORT_SYMBOL(sock_i_ino);
2012 EXPORT_SYMBOL(sysctl_optmem_max);
2013 #ifdef CONFIG_SYSCTL
2014 EXPORT_SYMBOL(sysctl_rmem_max);
2015 EXPORT_SYMBOL(sysctl_wmem_max);
2016 #endif
Mirror https://git.kernel.org/pub/scm/linux/kernel/git/stable/linux.git