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