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