?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
[SOCK]: on failure free the sock from the right place
[linux-2.6/kvm.git] / net / core / sock.c
blob4df4fa3c5de047e3ee099b64b38c4948b2dd406a
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, <bir7@leland.Stanford.Edu>
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/config.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/major.h>
101 #include <linux/module.h>
102 #include <linux/proc_fs.h>
103 #include <linux/seq_file.h>
104 #include <linux/sched.h>
105 #include <linux/timer.h>
106 #include <linux/string.h>
107 #include <linux/sockios.h>
108 #include <linux/net.h>
109 #include <linux/mm.h>
110 #include <linux/slab.h>
111 #include <linux/interrupt.h>
112 #include <linux/poll.h>
113 #include <linux/tcp.h>
114 #include <linux/init.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/sock.h>
123 #include <net/xfrm.h>
124 #include <linux/ipsec.h>
125
126 #include <linux/filter.h>
127
128 #ifdef CONFIG_INET
129 #include <net/tcp.h>
130 #endif
131
132 /* Take into consideration the size of the struct sk_buff overhead in the
133 * determination of these values, since that is non-constant across
134 * platforms. This makes socket queueing behavior and performance
135 * not depend upon such differences.
136 */
137 #define _SK_MEM_PACKETS 256
138 #define _SK_MEM_OVERHEAD (sizeof(struct sk_buff) + 256)
139 #define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
140 #define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
141
142 /* Run time adjustable parameters. */
143 __u32 sysctl_wmem_max = SK_WMEM_MAX;
144 __u32 sysctl_rmem_max = SK_RMEM_MAX;
145 __u32 sysctl_wmem_default = SK_WMEM_MAX;
146 __u32 sysctl_rmem_default = SK_RMEM_MAX;
147
148 /* Maximal space eaten by iovec or ancilliary data plus some space */
149 int sysctl_optmem_max = sizeof(unsigned long)*(2*UIO_MAXIOV + 512);
150
151 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
152 {
153 struct timeval tv;
154
155 if (optlen < sizeof(tv))
156 return -EINVAL;
157 if (copy_from_user(&tv, optval, sizeof(tv)))
158 return -EFAULT;
159
160 *timeo_p = MAX_SCHEDULE_TIMEOUT;
161 if (tv.tv_sec == 0 && tv.tv_usec == 0)
162 return 0;
163 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
164 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
165 return 0;
166 }
167
168 static void sock_warn_obsolete_bsdism(const char *name)
169 {
170 static int warned;
171 static char warncomm[TASK_COMM_LEN];
172 if (strcmp(warncomm, current->comm) && warned < 5) {
173 strcpy(warncomm, current->comm);
174 printk(KERN_WARNING "process `%s' is using obsolete "
175 "%s SO_BSDCOMPAT\n", warncomm, name);
176 warned++;
177 }
178 }
179
180 static void sock_disable_timestamp(struct sock *sk)
181 {
182 if (sock_flag(sk, SOCK_TIMESTAMP)) {
183 sock_reset_flag(sk, SOCK_TIMESTAMP);
184 net_disable_timestamp();
185 }
186 }
187
188
189 /*
190 * This is meant for all protocols to use and covers goings on
191 * at the socket level. Everything here is generic.
192 */
193
194 int sock_setsockopt(struct socket *sock, int level, int optname,
195 char __user *optval, int optlen)
196 {
197 struct sock *sk=sock->sk;
198 struct sk_filter *filter;
199 int val;
200 int valbool;
201 struct linger ling;
202 int ret = 0;
203
204 /*
205 * Options without arguments
206 */
207
208 #ifdef SO_DONTLINGER /* Compatibility item... */
209 switch (optname) {
210 case SO_DONTLINGER:
211 sock_reset_flag(sk, SOCK_LINGER);
212 return 0;
213 }
214 #endif
215
216 if(optlen<sizeof(int))
217 return(-EINVAL);
218
219 if (get_user(val, (int __user *)optval))
220 return -EFAULT;
221
222 valbool = val?1:0;
223
224 lock_sock(sk);
225
226 switch(optname)
227 {
228 case SO_DEBUG:
229 if(val && !capable(CAP_NET_ADMIN))
230 {
231 ret = -EACCES;
232 }
233 else if (valbool)
234 sock_set_flag(sk, SOCK_DBG);
235 else
236 sock_reset_flag(sk, SOCK_DBG);
237 break;
238 case SO_REUSEADDR:
239 sk->sk_reuse = valbool;
240 break;
241 case SO_TYPE:
242 case SO_ERROR:
243 ret = -ENOPROTOOPT;
244 break;
245 case SO_DONTROUTE:
246 if (valbool)
247 sock_set_flag(sk, SOCK_LOCALROUTE);
248 else
249 sock_reset_flag(sk, SOCK_LOCALROUTE);
250 break;
251 case SO_BROADCAST:
252 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
253 break;
254 case SO_SNDBUF:
255 /* Don't error on this BSD doesn't and if you think
256 about it this is right. Otherwise apps have to
257 play 'guess the biggest size' games. RCVBUF/SNDBUF
258 are treated in BSD as hints */
259
260 if (val > sysctl_wmem_max)
261 val = sysctl_wmem_max;
262
263 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
264 if ((val * 2) < SOCK_MIN_SNDBUF)
265 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
266 else
267 sk->sk_sndbuf = val * 2;
268
269 /*
270 * Wake up sending tasks if we
271 * upped the value.
272 */
273 sk->sk_write_space(sk);
274 break;
275
276 case SO_RCVBUF:
277 /* Don't error on this BSD doesn't and if you think
278 about it this is right. Otherwise apps have to
279 play 'guess the biggest size' games. RCVBUF/SNDBUF
280 are treated in BSD as hints */
281
282 if (val > sysctl_rmem_max)
283 val = sysctl_rmem_max;
284
285 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
286 /* FIXME: is this lower bound the right one? */
287 if ((val * 2) < SOCK_MIN_RCVBUF)
288 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
289 else
290 sk->sk_rcvbuf = val * 2;
291 break;
292
293 case SO_KEEPALIVE:
294 #ifdef CONFIG_INET
295 if (sk->sk_protocol == IPPROTO_TCP)
296 tcp_set_keepalive(sk, valbool);
297 #endif
298 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
299 break;
300
301 case SO_OOBINLINE:
302 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
303 break;
304
305 case SO_NO_CHECK:
306 sk->sk_no_check = valbool;
307 break;
308
309 case SO_PRIORITY:
310 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
311 sk->sk_priority = val;
312 else
313 ret = -EPERM;
314 break;
315
316 case SO_LINGER:
317 if(optlen<sizeof(ling)) {
318 ret = -EINVAL; /* 1003.1g */
319 break;
320 }
321 if (copy_from_user(&ling,optval,sizeof(ling))) {
322 ret = -EFAULT;
323 break;
324 }
325 if (!ling.l_onoff)
326 sock_reset_flag(sk, SOCK_LINGER);
327 else {
328 #if (BITS_PER_LONG == 32)
329 if (ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
330 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
331 else
332 #endif
333 sk->sk_lingertime = ling.l_linger * HZ;
334 sock_set_flag(sk, SOCK_LINGER);
335 }
336 break;
337
338 case SO_BSDCOMPAT:
339 sock_warn_obsolete_bsdism("setsockopt");
340 break;
341
342 case SO_PASSCRED:
343 if (valbool)
344 set_bit(SOCK_PASSCRED, &sock->flags);
345 else
346 clear_bit(SOCK_PASSCRED, &sock->flags);
347 break;
348
349 case SO_TIMESTAMP:
350 if (valbool) {
351 sock_set_flag(sk, SOCK_RCVTSTAMP);
352 sock_enable_timestamp(sk);
353 } else
354 sock_reset_flag(sk, SOCK_RCVTSTAMP);
355 break;
356
357 case SO_RCVLOWAT:
358 if (val < 0)
359 val = INT_MAX;
360 sk->sk_rcvlowat = val ? : 1;
361 break;
362
363 case SO_RCVTIMEO:
364 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
365 break;
366
367 case SO_SNDTIMEO:
368 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
369 break;
370
371 #ifdef CONFIG_NETDEVICES
372 case SO_BINDTODEVICE:
373 {
374 char devname[IFNAMSIZ];
375
376 /* Sorry... */
377 if (!capable(CAP_NET_RAW)) {
378 ret = -EPERM;
379 break;
380 }
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
388 if (!valbool) {
389 sk->sk_bound_dev_if = 0;
390 } else {
391 if (optlen > IFNAMSIZ)
392 optlen = IFNAMSIZ;
393 if (copy_from_user(devname, optval, optlen)) {
394 ret = -EFAULT;
395 break;
396 }
397
398 /* Remove any cached route for this socket. */
399 sk_dst_reset(sk);
400
401 if (devname[0] == '\0') {
402 sk->sk_bound_dev_if = 0;
403 } else {
404 struct net_device *dev = dev_get_by_name(devname);
405 if (!dev) {
406 ret = -ENODEV;
407 break;
408 }
409 sk->sk_bound_dev_if = dev->ifindex;
410 dev_put(dev);
411 }
412 }
413 break;
414 }
415 #endif
416
417
418 case SO_ATTACH_FILTER:
419 ret = -EINVAL;
420 if (optlen == sizeof(struct sock_fprog)) {
421 struct sock_fprog fprog;
422
423 ret = -EFAULT;
424 if (copy_from_user(&fprog, optval, sizeof(fprog)))
425 break;
426
427 ret = sk_attach_filter(&fprog, sk);
428 }
429 break;
430
431 case SO_DETACH_FILTER:
432 spin_lock_bh(&sk->sk_lock.slock);
433 filter = sk->sk_filter;
434 if (filter) {
435 sk->sk_filter = NULL;
436 spin_unlock_bh(&sk->sk_lock.slock);
437 sk_filter_release(sk, filter);
438 break;
439 }
440 spin_unlock_bh(&sk->sk_lock.slock);
441 ret = -ENONET;
442 break;
443
444 /* We implement the SO_SNDLOWAT etc to
445 not be settable (1003.1g 5.3) */
446 default:
447 ret = -ENOPROTOOPT;
448 break;
449 }
450 release_sock(sk);
451 return ret;
452 }
453
454
455 int sock_getsockopt(struct socket *sock, int level, int optname,
456 char __user *optval, int __user *optlen)
457 {
458 struct sock *sk = sock->sk;
459
460 union
461 {
462 int val;
463 struct linger ling;
464 struct timeval tm;
465 } v;
466
467 unsigned int lv = sizeof(int);
468 int len;
469
470 if(get_user(len,optlen))
471 return -EFAULT;
472 if(len < 0)
473 return -EINVAL;
474
475 switch(optname)
476 {
477 case SO_DEBUG:
478 v.val = sock_flag(sk, SOCK_DBG);
479 break;
480
481 case SO_DONTROUTE:
482 v.val = sock_flag(sk, SOCK_LOCALROUTE);
483 break;
484
485 case SO_BROADCAST:
486 v.val = !!sock_flag(sk, SOCK_BROADCAST);
487 break;
488
489 case SO_SNDBUF:
490 v.val = sk->sk_sndbuf;
491 break;
492
493 case SO_RCVBUF:
494 v.val = sk->sk_rcvbuf;
495 break;
496
497 case SO_REUSEADDR:
498 v.val = sk->sk_reuse;
499 break;
500
501 case SO_KEEPALIVE:
502 v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
503 break;
504
505 case SO_TYPE:
506 v.val = sk->sk_type;
507 break;
508
509 case SO_ERROR:
510 v.val = -sock_error(sk);
511 if(v.val==0)
512 v.val = xchg(&sk->sk_err_soft, 0);
513 break;
514
515 case SO_OOBINLINE:
516 v.val = !!sock_flag(sk, SOCK_URGINLINE);
517 break;
518
519 case SO_NO_CHECK:
520 v.val = sk->sk_no_check;
521 break;
522
523 case SO_PRIORITY:
524 v.val = sk->sk_priority;
525 break;
526
527 case SO_LINGER:
528 lv = sizeof(v.ling);
529 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER);
530 v.ling.l_linger = sk->sk_lingertime / HZ;
531 break;
532
533 case SO_BSDCOMPAT:
534 sock_warn_obsolete_bsdism("getsockopt");
535 break;
536
537 case SO_TIMESTAMP:
538 v.val = sock_flag(sk, SOCK_RCVTSTAMP);
539 break;
540
541 case SO_RCVTIMEO:
542 lv=sizeof(struct timeval);
543 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
544 v.tm.tv_sec = 0;
545 v.tm.tv_usec = 0;
546 } else {
547 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
548 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
549 }
550 break;
551
552 case SO_SNDTIMEO:
553 lv=sizeof(struct timeval);
554 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
555 v.tm.tv_sec = 0;
556 v.tm.tv_usec = 0;
557 } else {
558 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
559 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
560 }
561 break;
562
563 case SO_RCVLOWAT:
564 v.val = sk->sk_rcvlowat;
565 break;
566
567 case SO_SNDLOWAT:
568 v.val=1;
569 break;
570
571 case SO_PASSCRED:
572 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
573 break;
574
575 case SO_PEERCRED:
576 if (len > sizeof(sk->sk_peercred))
577 len = sizeof(sk->sk_peercred);
578 if (copy_to_user(optval, &sk->sk_peercred, len))
579 return -EFAULT;
580 goto lenout;
581
582 case SO_PEERNAME:
583 {
584 char address[128];
585
586 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
587 return -ENOTCONN;
588 if (lv < len)
589 return -EINVAL;
590 if (copy_to_user(optval, address, len))
591 return -EFAULT;
592 goto lenout;
593 }
594
595 /* Dubious BSD thing... Probably nobody even uses it, but
596 * the UNIX standard wants it for whatever reason... -DaveM
597 */
598 case SO_ACCEPTCONN:
599 v.val = sk->sk_state == TCP_LISTEN;
600 break;
601
602 case SO_PEERSEC:
603 return security_socket_getpeersec(sock, optval, optlen, len);
604
605 default:
606 return(-ENOPROTOOPT);
607 }
608 if (len > lv)
609 len = lv;
610 if (copy_to_user(optval, &v, len))
611 return -EFAULT;
612 lenout:
613 if (put_user(len, optlen))
614 return -EFAULT;
615 return 0;
616 }
617
618 /**
619 * sk_alloc - All socket objects are allocated here
620 * @family - protocol family
621 * @priority - for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
622 * @prot - struct proto associated with this new sock instance
623 * @zero_it - if we should zero the newly allocated sock
624 */
625 struct sock *sk_alloc(int family, int priority, struct proto *prot, int zero_it)
626 {
627 struct sock *sk = NULL;
628 kmem_cache_t *slab = prot->slab;
629
630 if (slab != NULL)
631 sk = kmem_cache_alloc(slab, priority);
632 else
633 sk = kmalloc(prot->obj_size, priority);
634
635 if (sk) {
636 if (zero_it) {
637 memset(sk, 0, prot->obj_size);
638 sk->sk_family = family;
639 sk->sk_prot = prot;
640 sock_lock_init(sk);
641 }
642
643 if (security_sk_alloc(sk, family, priority)) {
644 if (slab != NULL)
645 kmem_cache_free(slab, sk);
646 else
647 kfree(sk);
648 sk = NULL;
649 } else
650 __module_get(prot->owner);
651 }
652 return sk;
653 }
654
655 void sk_free(struct sock *sk)
656 {
657 struct sk_filter *filter;
658 struct module *owner = sk->sk_prot->owner;
659
660 if (sk->sk_destruct)
661 sk->sk_destruct(sk);
662
663 filter = sk->sk_filter;
664 if (filter) {
665 sk_filter_release(sk, filter);
666 sk->sk_filter = NULL;
667 }
668
669 sock_disable_timestamp(sk);
670
671 if (atomic_read(&sk->sk_omem_alloc))
672 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
673 __FUNCTION__, atomic_read(&sk->sk_omem_alloc));
674
675 security_sk_free(sk);
676 if (sk->sk_prot->slab != NULL)
677 kmem_cache_free(sk->sk_prot->slab, sk);
678 else
679 kfree(sk);
680 module_put(owner);
681 }
682
683 void __init sk_init(void)
684 {
685 if (num_physpages <= 4096) {
686 sysctl_wmem_max = 32767;
687 sysctl_rmem_max = 32767;
688 sysctl_wmem_default = 32767;
689 sysctl_rmem_default = 32767;
690 } else if (num_physpages >= 131072) {
691 sysctl_wmem_max = 131071;
692 sysctl_rmem_max = 131071;
693 }
694 }
695
696 /*
697 * Simple resource managers for sockets.
698 */
699
700
701 /*
702 * Write buffer destructor automatically called from kfree_skb.
703 */
704 void sock_wfree(struct sk_buff *skb)
705 {
706 struct sock *sk = skb->sk;
707
708 /* In case it might be waiting for more memory. */
709 atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
710 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
711 sk->sk_write_space(sk);
712 sock_put(sk);
713 }
714
715 /*
716 * Read buffer destructor automatically called from kfree_skb.
717 */
718 void sock_rfree(struct sk_buff *skb)
719 {
720 struct sock *sk = skb->sk;
721
722 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
723 }
724
725
726 int sock_i_uid(struct sock *sk)
727 {
728 int uid;
729
730 read_lock(&sk->sk_callback_lock);
731 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
732 read_unlock(&sk->sk_callback_lock);
733 return uid;
734 }
735
736 unsigned long sock_i_ino(struct sock *sk)
737 {
738 unsigned long ino;
739
740 read_lock(&sk->sk_callback_lock);
741 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
742 read_unlock(&sk->sk_callback_lock);
743 return ino;
744 }
745
746 /*
747 * Allocate a skb from the socket's send buffer.
748 */
749 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force, int priority)
750 {
751 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
752 struct sk_buff * skb = alloc_skb(size, priority);
753 if (skb) {
754 skb_set_owner_w(skb, sk);
755 return skb;
756 }
757 }
758 return NULL;
759 }
760
761 /*
762 * Allocate a skb from the socket's receive buffer.
763 */
764 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force, int priority)
765 {
766 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
767 struct sk_buff *skb = alloc_skb(size, priority);
768 if (skb) {
769 skb_set_owner_r(skb, sk);
770 return skb;
771 }
772 }
773 return NULL;
774 }
775
776 /*
777 * Allocate a memory block from the socket's option memory buffer.
778 */
779 void *sock_kmalloc(struct sock *sk, int size, int priority)
780 {
781 if ((unsigned)size <= sysctl_optmem_max &&
782 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
783 void *mem;
784 /* First do the add, to avoid the race if kmalloc
785 * might sleep.
786 */
787 atomic_add(size, &sk->sk_omem_alloc);
788 mem = kmalloc(size, priority);
789 if (mem)
790 return mem;
791 atomic_sub(size, &sk->sk_omem_alloc);
792 }
793 return NULL;
794 }
795
796 /*
797 * Free an option memory block.
798 */
799 void sock_kfree_s(struct sock *sk, void *mem, int size)
800 {
801 kfree(mem);
802 atomic_sub(size, &sk->sk_omem_alloc);
803 }
804
805 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
806 I think, these locks should be removed for datagram sockets.
807 */
808 static long sock_wait_for_wmem(struct sock * sk, long timeo)
809 {
810 DEFINE_WAIT(wait);
811
812 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
813 for (;;) {
814 if (!timeo)
815 break;
816 if (signal_pending(current))
817 break;
818 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
819 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
820 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
821 break;
822 if (sk->sk_shutdown & SEND_SHUTDOWN)
823 break;
824 if (sk->sk_err)
825 break;
826 timeo = schedule_timeout(timeo);
827 }
828 finish_wait(sk->sk_sleep, &wait);
829 return timeo;
830 }
831
832
833 /*
834 * Generic send/receive buffer handlers
835 */
836
837 static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
838 unsigned long header_len,
839 unsigned long data_len,
840 int noblock, int *errcode)
841 {
842 struct sk_buff *skb;
843 unsigned int gfp_mask;
844 long timeo;
845 int err;
846
847 gfp_mask = sk->sk_allocation;
848 if (gfp_mask & __GFP_WAIT)
849 gfp_mask |= __GFP_REPEAT;
850
851 timeo = sock_sndtimeo(sk, noblock);
852 while (1) {
853 err = sock_error(sk);
854 if (err != 0)
855 goto failure;
856
857 err = -EPIPE;
858 if (sk->sk_shutdown & SEND_SHUTDOWN)
859 goto failure;
860
861 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
862 skb = alloc_skb(header_len, sk->sk_allocation);
863 if (skb) {
864 int npages;
865 int i;
866
867 /* No pages, we're done... */
868 if (!data_len)
869 break;
870
871 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
872 skb->truesize += data_len;
873 skb_shinfo(skb)->nr_frags = npages;
874 for (i = 0; i < npages; i++) {
875 struct page *page;
876 skb_frag_t *frag;
877
878 page = alloc_pages(sk->sk_allocation, 0);
879 if (!page) {
880 err = -ENOBUFS;
881 skb_shinfo(skb)->nr_frags = i;
882 kfree_skb(skb);
883 goto failure;
884 }
885
886 frag = &skb_shinfo(skb)->frags[i];
887 frag->page = page;
888 frag->page_offset = 0;
889 frag->size = (data_len >= PAGE_SIZE ?
890 PAGE_SIZE :
891 data_len);
892 data_len -= PAGE_SIZE;
893 }
894
895 /* Full success... */
896 break;
897 }
898 err = -ENOBUFS;
899 goto failure;
900 }
901 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
902 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
903 err = -EAGAIN;
904 if (!timeo)
905 goto failure;
906 if (signal_pending(current))
907 goto interrupted;
908 timeo = sock_wait_for_wmem(sk, timeo);
909 }
910
911 skb_set_owner_w(skb, sk);
912 return skb;
913
914 interrupted:
915 err = sock_intr_errno(timeo);
916 failure:
917 *errcode = err;
918 return NULL;
919 }
920
921 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
922 int noblock, int *errcode)
923 {
924 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
925 }
926
927 static void __lock_sock(struct sock *sk)
928 {
929 DEFINE_WAIT(wait);
930
931 for(;;) {
932 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
933 TASK_UNINTERRUPTIBLE);
934 spin_unlock_bh(&sk->sk_lock.slock);
935 schedule();
936 spin_lock_bh(&sk->sk_lock.slock);
937 if(!sock_owned_by_user(sk))
938 break;
939 }
940 finish_wait(&sk->sk_lock.wq, &wait);
941 }
942
943 static void __release_sock(struct sock *sk)
944 {
945 struct sk_buff *skb = sk->sk_backlog.head;
946
947 do {
948 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
949 bh_unlock_sock(sk);
950
951 do {
952 struct sk_buff *next = skb->next;
953
954 skb->next = NULL;
955 sk->sk_backlog_rcv(sk, skb);
956
957 /*
958 * We are in process context here with softirqs
959 * disabled, use cond_resched_softirq() to preempt.
960 * This is safe to do because we've taken the backlog
961 * queue private:
962 */
963 cond_resched_softirq();
964
965 skb = next;
966 } while (skb != NULL);
967
968 bh_lock_sock(sk);
969 } while((skb = sk->sk_backlog.head) != NULL);
970 }
971
972 /**
973 * sk_wait_data - wait for data to arrive at sk_receive_queue
974 * sk - sock to wait on
975 * timeo - for how long
976 *
977 * Now socket state including sk->sk_err is changed only under lock,
978 * hence we may omit checks after joining wait queue.
979 * We check receive queue before schedule() only as optimization;
980 * it is very likely that release_sock() added new data.
981 */
982 int sk_wait_data(struct sock *sk, long *timeo)
983 {
984 int rc;
985 DEFINE_WAIT(wait);
986
987 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
988 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
989 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
990 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
991 finish_wait(sk->sk_sleep, &wait);
992 return rc;
993 }
994
995 EXPORT_SYMBOL(sk_wait_data);
996
997 /*
998 * Set of default routines for initialising struct proto_ops when
999 * the protocol does not support a particular function. In certain
1000 * cases where it makes no sense for a protocol to have a "do nothing"
1001 * function, some default processing is provided.
1002 */
1003
1004 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1005 {
1006 return -EOPNOTSUPP;
1007 }
1008
1009 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1010 int len, int flags)
1011 {
1012 return -EOPNOTSUPP;
1013 }
1014
1015 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1016 {
1017 return -EOPNOTSUPP;
1018 }
1019
1020 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1021 {
1022 return -EOPNOTSUPP;
1023 }
1024
1025 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1026 int *len, int peer)
1027 {
1028 return -EOPNOTSUPP;
1029 }
1030
1031 unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
1032 {
1033 return 0;
1034 }
1035
1036 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1037 {
1038 return -EOPNOTSUPP;
1039 }
1040
1041 int sock_no_listen(struct socket *sock, int backlog)
1042 {
1043 return -EOPNOTSUPP;
1044 }
1045
1046 int sock_no_shutdown(struct socket *sock, int how)
1047 {
1048 return -EOPNOTSUPP;
1049 }
1050
1051 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1052 char __user *optval, int optlen)
1053 {
1054 return -EOPNOTSUPP;
1055 }
1056
1057 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1058 char __user *optval, int __user *optlen)
1059 {
1060 return -EOPNOTSUPP;
1061 }
1062
1063 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1064 size_t len)
1065 {
1066 return -EOPNOTSUPP;
1067 }
1068
1069 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1070 size_t len, int flags)
1071 {
1072 return -EOPNOTSUPP;
1073 }
1074
1075 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1076 {
1077 /* Mirror missing mmap method error code */
1078 return -ENODEV;
1079 }
1080
1081 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1082 {
1083 ssize_t res;
1084 struct msghdr msg = {.msg_flags = flags};
1085 struct kvec iov;
1086 char *kaddr = kmap(page);
1087 iov.iov_base = kaddr + offset;
1088 iov.iov_len = size;
1089 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1090 kunmap(page);
1091 return res;
1092 }
1093
1094 /*
1095 * Default Socket Callbacks
1096 */
1097
1098 static void sock_def_wakeup(struct sock *sk)
1099 {
1100 read_lock(&sk->sk_callback_lock);
1101 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1102 wake_up_interruptible_all(sk->sk_sleep);
1103 read_unlock(&sk->sk_callback_lock);
1104 }
1105
1106 static void sock_def_error_report(struct sock *sk)
1107 {
1108 read_lock(&sk->sk_callback_lock);
1109 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1110 wake_up_interruptible(sk->sk_sleep);
1111 sk_wake_async(sk,0,POLL_ERR);
1112 read_unlock(&sk->sk_callback_lock);
1113 }
1114
1115 static void sock_def_readable(struct sock *sk, int len)
1116 {
1117 read_lock(&sk->sk_callback_lock);
1118 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1119 wake_up_interruptible(sk->sk_sleep);
1120 sk_wake_async(sk,1,POLL_IN);
1121 read_unlock(&sk->sk_callback_lock);
1122 }
1123
1124 static void sock_def_write_space(struct sock *sk)
1125 {
1126 read_lock(&sk->sk_callback_lock);
1127
1128 /* Do not wake up a writer until he can make "significant"
1129 * progress. --DaveM
1130 */
1131 if((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1132 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1133 wake_up_interruptible(sk->sk_sleep);
1134
1135 /* Should agree with poll, otherwise some programs break */
1136 if (sock_writeable(sk))
1137 sk_wake_async(sk, 2, POLL_OUT);
1138 }
1139
1140 read_unlock(&sk->sk_callback_lock);
1141 }
1142
1143 static void sock_def_destruct(struct sock *sk)
1144 {
1145 if (sk->sk_protinfo)
1146 kfree(sk->sk_protinfo);
1147 }
1148
1149 void sk_send_sigurg(struct sock *sk)
1150 {
1151 if (sk->sk_socket && sk->sk_socket->file)
1152 if (send_sigurg(&sk->sk_socket->file->f_owner))
1153 sk_wake_async(sk, 3, POLL_PRI);
1154 }
1155
1156 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1157 unsigned long expires)
1158 {
1159 if (!mod_timer(timer, expires))
1160 sock_hold(sk);
1161 }
1162
1163 EXPORT_SYMBOL(sk_reset_timer);
1164
1165 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1166 {
1167 if (timer_pending(timer) && del_timer(timer))
1168 __sock_put(sk);
1169 }
1170
1171 EXPORT_SYMBOL(sk_stop_timer);
1172
1173 void sock_init_data(struct socket *sock, struct sock *sk)
1174 {
1175 skb_queue_head_init(&sk->sk_receive_queue);
1176 skb_queue_head_init(&sk->sk_write_queue);
1177 skb_queue_head_init(&sk->sk_error_queue);
1178
1179 sk->sk_send_head = NULL;
1180
1181 init_timer(&sk->sk_timer);
1182
1183 sk->sk_allocation = GFP_KERNEL;
1184 sk->sk_rcvbuf = sysctl_rmem_default;
1185 sk->sk_sndbuf = sysctl_wmem_default;
1186 sk->sk_state = TCP_CLOSE;
1187 sk->sk_socket = sock;
1188
1189 sock_set_flag(sk, SOCK_ZAPPED);
1190
1191 if(sock)
1192 {
1193 sk->sk_type = sock->type;
1194 sk->sk_sleep = &sock->wait;
1195 sock->sk = sk;
1196 } else
1197 sk->sk_sleep = NULL;
1198
1199 rwlock_init(&sk->sk_dst_lock);
1200 rwlock_init(&sk->sk_callback_lock);
1201
1202 sk->sk_state_change = sock_def_wakeup;
1203 sk->sk_data_ready = sock_def_readable;
1204 sk->sk_write_space = sock_def_write_space;
1205 sk->sk_error_report = sock_def_error_report;
1206 sk->sk_destruct = sock_def_destruct;
1207
1208 sk->sk_sndmsg_page = NULL;
1209 sk->sk_sndmsg_off = 0;
1210
1211 sk->sk_peercred.pid = 0;
1212 sk->sk_peercred.uid = -1;
1213 sk->sk_peercred.gid = -1;
1214 sk->sk_write_pending = 0;
1215 sk->sk_rcvlowat = 1;
1216 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
1217 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
1218
1219 sk->sk_stamp.tv_sec = -1L;
1220 sk->sk_stamp.tv_usec = -1L;
1221
1222 atomic_set(&sk->sk_refcnt, 1);
1223 }
1224
1225 void fastcall lock_sock(struct sock *sk)
1226 {
1227 might_sleep();
1228 spin_lock_bh(&(sk->sk_lock.slock));
1229 if (sk->sk_lock.owner)
1230 __lock_sock(sk);
1231 sk->sk_lock.owner = (void *)1;
1232 spin_unlock_bh(&(sk->sk_lock.slock));
1233 }
1234
1235 EXPORT_SYMBOL(lock_sock);
1236
1237 void fastcall release_sock(struct sock *sk)
1238 {
1239 spin_lock_bh(&(sk->sk_lock.slock));
1240 if (sk->sk_backlog.tail)
1241 __release_sock(sk);
1242 sk->sk_lock.owner = NULL;
1243 if (waitqueue_active(&(sk->sk_lock.wq)))
1244 wake_up(&(sk->sk_lock.wq));
1245 spin_unlock_bh(&(sk->sk_lock.slock));
1246 }
1247 EXPORT_SYMBOL(release_sock);
1248
1249 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
1250 {
1251 if (!sock_flag(sk, SOCK_TIMESTAMP))
1252 sock_enable_timestamp(sk);
1253 if (sk->sk_stamp.tv_sec == -1)
1254 return -ENOENT;
1255 if (sk->sk_stamp.tv_sec == 0)
1256 do_gettimeofday(&sk->sk_stamp);
1257 return copy_to_user(userstamp, &sk->sk_stamp, sizeof(struct timeval)) ?
1258 -EFAULT : 0;
1259 }
1260 EXPORT_SYMBOL(sock_get_timestamp);
1261
1262 void sock_enable_timestamp(struct sock *sk)
1263 {
1264 if (!sock_flag(sk, SOCK_TIMESTAMP)) {
1265 sock_set_flag(sk, SOCK_TIMESTAMP);
1266 net_enable_timestamp();
1267 }
1268 }
1269 EXPORT_SYMBOL(sock_enable_timestamp);
1270
1271 /*
1272 * Get a socket option on an socket.
1273 *
1274 * FIX: POSIX 1003.1g is very ambiguous here. It states that
1275 * asynchronous errors should be reported by getsockopt. We assume
1276 * this means if you specify SO_ERROR (otherwise whats the point of it).
1277 */
1278 int sock_common_getsockopt(struct socket *sock, int level, int optname,
1279 char __user *optval, int __user *optlen)
1280 {
1281 struct sock *sk = sock->sk;
1282
1283 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1284 }
1285
1286 EXPORT_SYMBOL(sock_common_getsockopt);
1287
1288 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1289 struct msghdr *msg, size_t size, int flags)
1290 {
1291 struct sock *sk = sock->sk;
1292 int addr_len = 0;
1293 int err;
1294
1295 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
1296 flags & ~MSG_DONTWAIT, &addr_len);
1297 if (err >= 0)
1298 msg->msg_namelen = addr_len;
1299 return err;
1300 }
1301
1302 EXPORT_SYMBOL(sock_common_recvmsg);
1303
1304 /*
1305 * Set socket options on an inet socket.
1306 */
1307 int sock_common_setsockopt(struct socket *sock, int level, int optname,
1308 char __user *optval, int optlen)
1309 {
1310 struct sock *sk = sock->sk;
1311
1312 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1313 }
1314
1315 EXPORT_SYMBOL(sock_common_setsockopt);
1316
1317 void sk_common_release(struct sock *sk)
1318 {
1319 if (sk->sk_prot->destroy)
1320 sk->sk_prot->destroy(sk);
1321
1322 /*
1323 * Observation: when sock_common_release is called, processes have
1324 * no access to socket. But net still has.
1325 * Step one, detach it from networking:
1326 *
1327 * A. Remove from hash tables.
1328 */
1329
1330 sk->sk_prot->unhash(sk);
1331
1332 /*
1333 * In this point socket cannot receive new packets, but it is possible
1334 * that some packets are in flight because some CPU runs receiver and
1335 * did hash table lookup before we unhashed socket. They will achieve
1336 * receive queue and will be purged by socket destructor.
1337 *
1338 * Also we still have packets pending on receive queue and probably,
1339 * our own packets waiting in device queues. sock_destroy will drain
1340 * receive queue, but transmitted packets will delay socket destruction
1341 * until the last reference will be released.
1342 */
1343
1344 sock_orphan(sk);
1345
1346 xfrm_sk_free_policy(sk);
1347
1348 #ifdef INET_REFCNT_DEBUG
1349 if (atomic_read(&sk->sk_refcnt) != 1)
1350 printk(KERN_DEBUG "Destruction of the socket %p delayed, c=%d\n",
1351 sk, atomic_read(&sk->sk_refcnt));
1352 #endif
1353 sock_put(sk);
1354 }
1355
1356 EXPORT_SYMBOL(sk_common_release);
1357
1358 static DEFINE_RWLOCK(proto_list_lock);
1359 static LIST_HEAD(proto_list);
1360
1361 int proto_register(struct proto *prot, int alloc_slab)
1362 {
1363 int rc = -ENOBUFS;
1364
1365 if (alloc_slab) {
1366 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
1367 SLAB_HWCACHE_ALIGN, NULL, NULL);
1368
1369 if (prot->slab == NULL) {
1370 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
1371 prot->name);
1372 goto out;
1373 }
1374 }
1375
1376 write_lock(&proto_list_lock);
1377 list_add(&prot->node, &proto_list);
1378 write_unlock(&proto_list_lock);
1379 rc = 0;
1380 out:
1381 return rc;
1382 }
1383
1384 EXPORT_SYMBOL(proto_register);
1385
1386 void proto_unregister(struct proto *prot)
1387 {
1388 write_lock(&proto_list_lock);
1389
1390 if (prot->slab != NULL) {
1391 kmem_cache_destroy(prot->slab);
1392 prot->slab = NULL;
1393 }
1394
1395 list_del(&prot->node);
1396 write_unlock(&proto_list_lock);
1397 }
1398
1399 EXPORT_SYMBOL(proto_unregister);
1400
1401 #ifdef CONFIG_PROC_FS
1402 static inline struct proto *__proto_head(void)
1403 {
1404 return list_entry(proto_list.next, struct proto, node);
1405 }
1406
1407 static inline struct proto *proto_head(void)
1408 {
1409 return list_empty(&proto_list) ? NULL : __proto_head();
1410 }
1411
1412 static inline struct proto *proto_next(struct proto *proto)
1413 {
1414 return proto->node.next == &proto_list ? NULL :
1415 list_entry(proto->node.next, struct proto, node);
1416 }
1417
1418 static inline struct proto *proto_get_idx(loff_t pos)
1419 {
1420 struct proto *proto;
1421 loff_t i = 0;
1422
1423 list_for_each_entry(proto, &proto_list, node)
1424 if (i++ == pos)
1425 goto out;
1426
1427 proto = NULL;
1428 out:
1429 return proto;
1430 }
1431
1432 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
1433 {
1434 read_lock(&proto_list_lock);
1435 return *pos ? proto_get_idx(*pos - 1) : SEQ_START_TOKEN;
1436 }
1437
1438 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1439 {
1440 ++*pos;
1441 return v == SEQ_START_TOKEN ? proto_head() : proto_next(v);
1442 }
1443
1444 static void proto_seq_stop(struct seq_file *seq, void *v)
1445 {
1446 read_unlock(&proto_list_lock);
1447 }
1448
1449 static char proto_method_implemented(const void *method)
1450 {
1451 return method == NULL ? 'n' : 'y';
1452 }
1453
1454 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
1455 {
1456 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s "
1457 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
1458 proto->name,
1459 proto->obj_size,
1460 proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
1461 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
1462 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
1463 proto->max_header,
1464 proto->slab == NULL ? "no" : "yes",
1465 module_name(proto->owner),
1466 proto_method_implemented(proto->close),
1467 proto_method_implemented(proto->connect),
1468 proto_method_implemented(proto->disconnect),
1469 proto_method_implemented(proto->accept),
1470 proto_method_implemented(proto->ioctl),
1471 proto_method_implemented(proto->init),
1472 proto_method_implemented(proto->destroy),
1473 proto_method_implemented(proto->shutdown),
1474 proto_method_implemented(proto->setsockopt),
1475 proto_method_implemented(proto->getsockopt),
1476 proto_method_implemented(proto->sendmsg),
1477 proto_method_implemented(proto->recvmsg),
1478 proto_method_implemented(proto->sendpage),
1479 proto_method_implemented(proto->bind),
1480 proto_method_implemented(proto->backlog_rcv),
1481 proto_method_implemented(proto->hash),
1482 proto_method_implemented(proto->unhash),
1483 proto_method_implemented(proto->get_port),
1484 proto_method_implemented(proto->enter_memory_pressure));
1485 }
1486
1487 static int proto_seq_show(struct seq_file *seq, void *v)
1488 {
1489 if (v == SEQ_START_TOKEN)
1490 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
1491 "protocol",
1492 "size",
1493 "sockets",
1494 "memory",
1495 "press",
1496 "maxhdr",
1497 "slab",
1498 "module",
1499 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
1500 else
1501 proto_seq_printf(seq, v);
1502 return 0;
1503 }
1504
1505 static struct seq_operations proto_seq_ops = {
1506 .start = proto_seq_start,
1507 .next = proto_seq_next,
1508 .stop = proto_seq_stop,
1509 .show = proto_seq_show,
1510 };
1511
1512 static int proto_seq_open(struct inode *inode, struct file *file)
1513 {
1514 return seq_open(file, &proto_seq_ops);
1515 }
1516
1517 static struct file_operations proto_seq_fops = {
1518 .owner = THIS_MODULE,
1519 .open = proto_seq_open,
1520 .read = seq_read,
1521 .llseek = seq_lseek,
1522 .release = seq_release,
1523 };
1524
1525 static int __init proto_init(void)
1526 {
1527 /* register /proc/net/protocols */
1528 return proc_net_fops_create("protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
1529 }
1530
1531 subsys_initcall(proto_init);
1532
1533 #endif /* PROC_FS */
1534
1535 EXPORT_SYMBOL(sk_alloc);
1536 EXPORT_SYMBOL(sk_free);
1537 EXPORT_SYMBOL(sk_send_sigurg);
1538 EXPORT_SYMBOL(sock_alloc_send_skb);
1539 EXPORT_SYMBOL(sock_init_data);
1540 EXPORT_SYMBOL(sock_kfree_s);
1541 EXPORT_SYMBOL(sock_kmalloc);
1542 EXPORT_SYMBOL(sock_no_accept);
1543 EXPORT_SYMBOL(sock_no_bind);
1544 EXPORT_SYMBOL(sock_no_connect);
1545 EXPORT_SYMBOL(sock_no_getname);
1546 EXPORT_SYMBOL(sock_no_getsockopt);
1547 EXPORT_SYMBOL(sock_no_ioctl);
1548 EXPORT_SYMBOL(sock_no_listen);
1549 EXPORT_SYMBOL(sock_no_mmap);
1550 EXPORT_SYMBOL(sock_no_poll);
1551 EXPORT_SYMBOL(sock_no_recvmsg);
1552 EXPORT_SYMBOL(sock_no_sendmsg);
1553 EXPORT_SYMBOL(sock_no_sendpage);
1554 EXPORT_SYMBOL(sock_no_setsockopt);
1555 EXPORT_SYMBOL(sock_no_shutdown);
1556 EXPORT_SYMBOL(sock_no_socketpair);
1557 EXPORT_SYMBOL(sock_rfree);
1558 EXPORT_SYMBOL(sock_setsockopt);
1559 EXPORT_SYMBOL(sock_wfree);
1560 EXPORT_SYMBOL(sock_wmalloc);
1561 EXPORT_SYMBOL(sock_i_uid);
1562 EXPORT_SYMBOL(sock_i_ino);
1563 #ifdef CONFIG_SYSCTL
1564 EXPORT_SYMBOL(sysctl_optmem_max);
1565 EXPORT_SYMBOL(sysctl_rmem_max);
1566 EXPORT_SYMBOL(sysctl_wmem_max);
1567 #endif
kernel-based virtual machine