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