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