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