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