]> 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 socket creation namespace safe.
[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 */
1b8d7ae4 876struct sock *sk_alloc(struct net *net, 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 896 sock_lock_init(sk);
1b8d7ae4 897 sk->sk_net = get_net(net);
1da177e4 898 }
4ec93edb 899
a79af59e
FF		 900 if (security_sk_alloc(sk, family, priority))
901 goto out_free;
902
903 if (!try_module_get(prot->owner))
904 goto out_free;
1da177e4
LT		 905 }
906 return sk;
a79af59e
FF		 907
908out_free:
909 if (slab != NULL)
910 kmem_cache_free(slab, sk);
911 else
912 kfree(sk);
913 return NULL;
1da177e4
LT		 914}
915
916void sk_free(struct sock *sk)
917{
918 struct sk_filter *filter;
476e19cf 919 struct module *owner = sk->sk_prot_creator->owner;
1da177e4
LT		 920
921 if (sk->sk_destruct)
922 sk->sk_destruct(sk);
923
fda9ef5d 924 filter = rcu_dereference(sk->sk_filter);
1da177e4
LT		 925 if (filter) {
926 sk_filter_release(sk, filter);
fda9ef5d 927 rcu_assign_pointer(sk->sk_filter, NULL);
1da177e4
LT		 928 }
929
930 sock_disable_timestamp(sk);
931
932 if (atomic_read(&sk->sk_omem_alloc))
933 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
934 __FUNCTION__, atomic_read(&sk->sk_omem_alloc));
935
936 security_sk_free(sk);
1b8d7ae4 937 put_net(sk->sk_net);
476e19cf
ACM		 938 if (sk->sk_prot_creator->slab != NULL)
939 kmem_cache_free(sk->sk_prot_creator->slab, sk);
1da177e4
LT		 940 else
941 kfree(sk);
942 module_put(owner);
943}
944
dd0fc66f 945struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
87d11ceb 946{
1b8d7ae4 947 struct sock *newsk = sk_alloc(sk->sk_net, sk->sk_family, priority, sk->sk_prot, 0);
87d11ceb
ACM		 948
949 if (newsk != NULL) {
950 struct sk_filter *filter;
951
892c141e 952 sock_copy(newsk, sk);
87d11ceb
ACM		 953
954 /* SANITY */
955 sk_node_init(&newsk->sk_node);
956 sock_lock_init(newsk);
957 bh_lock_sock(newsk);
fa438ccf 958 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
87d11ceb
ACM		 959
960 atomic_set(&newsk->sk_rmem_alloc, 0);
961 atomic_set(&newsk->sk_wmem_alloc, 0);
962 atomic_set(&newsk->sk_omem_alloc, 0);
963 skb_queue_head_init(&newsk->sk_receive_queue);
964 skb_queue_head_init(&newsk->sk_write_queue);
97fc2f08
CL		 965#ifdef CONFIG_NET_DMA
966 skb_queue_head_init(&newsk->sk_async_wait_queue);
967#endif
87d11ceb
ACM		 968
969 rwlock_init(&newsk->sk_dst_lock);
970 rwlock_init(&newsk->sk_callback_lock);
443aef0e
PZ		 971 lockdep_set_class_and_name(&newsk->sk_callback_lock,
972 af_callback_keys + newsk->sk_family,
973 af_family_clock_key_strings[newsk->sk_family]);
87d11ceb
ACM		 974
975 newsk->sk_dst_cache = NULL;
976 newsk->sk_wmem_queued = 0;
977 newsk->sk_forward_alloc = 0;
978 newsk->sk_send_head = NULL;
87d11ceb
ACM		 979 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
980
981 sock_reset_flag(newsk, SOCK_DONE);
982 skb_queue_head_init(&newsk->sk_error_queue);
983
984 filter = newsk->sk_filter;
985 if (filter != NULL)
986 sk_filter_charge(newsk, filter);
987
988 if (unlikely(xfrm_sk_clone_policy(newsk))) {
989 /* It is still raw copy of parent, so invalidate
990 * destructor and make plain sk_free() */
991 newsk->sk_destruct = NULL;
992 sk_free(newsk);
993 newsk = NULL;
994 goto out;
995 }
996
997 newsk->sk_err = 0;
998 newsk->sk_priority = 0;
999 atomic_set(&newsk->sk_refcnt, 2);
1000
1001 /*
1002 * Increment the counter in the same struct proto as the master
1003 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1004 * is the same as sk->sk_prot->socks, as this field was copied
1005 * with memcpy).
1006 *
1007 * This _changes_ the previous behaviour, where
1008 * tcp_create_openreq_child always was incrementing the
1009 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1010 * to be taken into account in all callers. -acme
1011 */
1012 sk_refcnt_debug_inc(newsk);
1013 newsk->sk_socket = NULL;
1014 newsk->sk_sleep = NULL;
1015
1016 if (newsk->sk_prot->sockets_allocated)
1017 atomic_inc(newsk->sk_prot->sockets_allocated);
1018 }
1019out:
1020 return newsk;
1021}
1022
1023EXPORT_SYMBOL_GPL(sk_clone);
1024
9958089a
AK		 1025void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1026{
1027 __sk_dst_set(sk, dst);
1028 sk->sk_route_caps = dst->dev->features;
1029 if (sk->sk_route_caps & NETIF_F_GSO)
4fcd6b99 1030 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
9958089a
AK		 1031 if (sk_can_gso(sk)) {
1032 if (dst->header_len)
1033 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1034 else
1035 sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1036 }
1037}
1038EXPORT_SYMBOL_GPL(sk_setup_caps);
1039
1da177e4
LT		 1040void __init sk_init(void)
1041{
1042 if (num_physpages <= 4096) {
1043 sysctl_wmem_max = 32767;
1044 sysctl_rmem_max = 32767;
1045 sysctl_wmem_default = 32767;
1046 sysctl_rmem_default = 32767;
1047 } else if (num_physpages >= 131072) {
1048 sysctl_wmem_max = 131071;
1049 sysctl_rmem_max = 131071;
1050 }
1051}
1052
1053/*
1054 * Simple resource managers for sockets.
1055 */
1056
1057
4ec93edb
YH		 1058/*
1059 * Write buffer destructor automatically called from kfree_skb.
1da177e4
LT		 1060 */
1061void sock_wfree(struct sk_buff *skb)
1062{
1063 struct sock *sk = skb->sk;
1064
1065 /* In case it might be waiting for more memory. */
1066 atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
1067 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
1068 sk->sk_write_space(sk);
1069 sock_put(sk);
1070}
1071
4ec93edb
YH		 1072/*
1073 * Read buffer destructor automatically called from kfree_skb.
1da177e4
LT		 1074 */
1075void sock_rfree(struct sk_buff *skb)
1076{
1077 struct sock *sk = skb->sk;
1078
1079 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
1080}
1081
1082
1083int sock_i_uid(struct sock *sk)
1084{
1085 int uid;
1086
1087 read_lock(&sk->sk_callback_lock);
1088 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1089 read_unlock(&sk->sk_callback_lock);
1090 return uid;
1091}
1092
1093unsigned long sock_i_ino(struct sock *sk)
1094{
1095 unsigned long ino;
1096
1097 read_lock(&sk->sk_callback_lock);
1098 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1099 read_unlock(&sk->sk_callback_lock);
1100 return ino;
1101}
1102
1103/*
1104 * Allocate a skb from the socket's send buffer.
1105 */
86a76caf 1106struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
dd0fc66f 1107 gfp_t priority)
1da177e4
LT		 1108{
1109 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1110 struct sk_buff * skb = alloc_skb(size, priority);
1111 if (skb) {
1112 skb_set_owner_w(skb, sk);
1113 return skb;
1114 }
1115 }
1116 return NULL;
1117}
1118
1119/*
1120 * Allocate a skb from the socket's receive buffer.
4ec93edb 1121 */
86a76caf 1122struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
dd0fc66f 1123 gfp_t priority)
1da177e4
LT		 1124{
1125 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1126 struct sk_buff *skb = alloc_skb(size, priority);
1127 if (skb) {
1128 skb_set_owner_r(skb, sk);
1129 return skb;
1130 }
1131 }
1132 return NULL;
1133}
1134
4ec93edb 1135/*
1da177e4 1136 * Allocate a memory block from the socket's option memory buffer.
4ec93edb 1137 */
dd0fc66f 1138void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1da177e4
LT		 1139{
1140 if ((unsigned)size <= sysctl_optmem_max &&
1141 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1142 void *mem;
1143 /* First do the add, to avoid the race if kmalloc
4ec93edb 1144 * might sleep.
1da177e4
LT		 1145 */
1146 atomic_add(size, &sk->sk_omem_alloc);
1147 mem = kmalloc(size, priority);
1148 if (mem)
1149 return mem;
1150 atomic_sub(size, &sk->sk_omem_alloc);
1151 }
1152 return NULL;
1153}
1154
1155/*
1156 * Free an option memory block.
1157 */
1158void sock_kfree_s(struct sock *sk, void *mem, int size)
1159{
1160 kfree(mem);
1161 atomic_sub(size, &sk->sk_omem_alloc);
1162}
1163
1164/* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1165 I think, these locks should be removed for datagram sockets.
1166 */
1167static long sock_wait_for_wmem(struct sock * sk, long timeo)
1168{
1169 DEFINE_WAIT(wait);
1170
1171 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1172 for (;;) {
1173 if (!timeo)
1174 break;
1175 if (signal_pending(current))
1176 break;
1177 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1178 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1179 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1180 break;
1181 if (sk->sk_shutdown & SEND_SHUTDOWN)
1182 break;
1183 if (sk->sk_err)
1184 break;
1185 timeo = schedule_timeout(timeo);
1186 }
1187 finish_wait(sk->sk_sleep, &wait);
1188 return timeo;
1189}
1190
1191
1192/*
1193 * Generic send/receive buffer handlers
1194 */
1195
1196static struct sk_buff *sock_alloc_send_pskb(struct sock *sk,
1197 unsigned long header_len,
1198 unsigned long data_len,
1199 int noblock, int *errcode)
1200{
1201 struct sk_buff *skb;
7d877f3b 1202 gfp_t gfp_mask;
1da177e4
LT		 1203 long timeo;
1204 int err;
1205
1206 gfp_mask = sk->sk_allocation;
1207 if (gfp_mask & __GFP_WAIT)
1208 gfp_mask |= __GFP_REPEAT;
1209
1210 timeo = sock_sndtimeo(sk, noblock);
1211 while (1) {
1212 err = sock_error(sk);
1213 if (err != 0)
1214 goto failure;
1215
1216 err = -EPIPE;
1217 if (sk->sk_shutdown & SEND_SHUTDOWN)
1218 goto failure;
1219
1220 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
db38c179 1221 skb = alloc_skb(header_len, gfp_mask);
1da177e4
LT		 1222 if (skb) {
1223 int npages;
1224 int i;
1225
1226 /* No pages, we're done... */
1227 if (!data_len)
1228 break;
1229
1230 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1231 skb->truesize += data_len;
1232 skb_shinfo(skb)->nr_frags = npages;
1233 for (i = 0; i < npages; i++) {
1234 struct page *page;
1235 skb_frag_t *frag;
1236
1237 page = alloc_pages(sk->sk_allocation, 0);
1238 if (!page) {
1239 err = -ENOBUFS;
1240 skb_shinfo(skb)->nr_frags = i;
1241 kfree_skb(skb);
1242 goto failure;
1243 }
1244
1245 frag = &skb_shinfo(skb)->frags[i];
1246 frag->page = page;
1247 frag->page_offset = 0;
1248 frag->size = (data_len >= PAGE_SIZE ?
1249 PAGE_SIZE :
1250 data_len);
1251 data_len -= PAGE_SIZE;
1252 }
1253
1254 /* Full success... */
1255 break;
1256 }
1257 err = -ENOBUFS;
1258 goto failure;
1259 }
1260 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1261 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1262 err = -EAGAIN;
1263 if (!timeo)
1264 goto failure;
1265 if (signal_pending(current))
1266 goto interrupted;
1267 timeo = sock_wait_for_wmem(sk, timeo);
1268 }
1269
1270 skb_set_owner_w(skb, sk);
1271 return skb;
1272
1273interrupted:
1274 err = sock_intr_errno(timeo);
1275failure:
1276 *errcode = err;
1277 return NULL;
1278}
1279
4ec93edb 1280struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1da177e4
LT		 1281 int noblock, int *errcode)
1282{
1283 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1284}
1285
1286static void __lock_sock(struct sock *sk)
1287{
1288 DEFINE_WAIT(wait);
1289
e71a4783 1290 for (;;) {
1da177e4
LT		 1291 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1292 TASK_UNINTERRUPTIBLE);
1293 spin_unlock_bh(&sk->sk_lock.slock);
1294 schedule();
1295 spin_lock_bh(&sk->sk_lock.slock);
e71a4783 1296 if (!sock_owned_by_user(sk))
1da177e4
LT		 1297 break;
1298 }
1299 finish_wait(&sk->sk_lock.wq, &wait);
1300}
1301
1302static void __release_sock(struct sock *sk)
1303{
1304 struct sk_buff *skb = sk->sk_backlog.head;
1305
1306 do {
1307 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1308 bh_unlock_sock(sk);
1309
1310 do {
1311 struct sk_buff *next = skb->next;
1312
1313 skb->next = NULL;
1314 sk->sk_backlog_rcv(sk, skb);
1315
1316 /*
1317 * We are in process context here with softirqs
1318 * disabled, use cond_resched_softirq() to preempt.
1319 * This is safe to do because we've taken the backlog
1320 * queue private:
1321 */
1322 cond_resched_softirq();
1323
1324 skb = next;
1325 } while (skb != NULL);
1326
1327 bh_lock_sock(sk);
e71a4783 1328 } while ((skb = sk->sk_backlog.head) != NULL);
1da177e4
LT		 1329}
1330
1331/**
1332 * sk_wait_data - wait for data to arrive at sk_receive_queue
4dc3b16b
PP		 1333 * @sk: sock to wait on
1334 * @timeo: for how long
1da177e4
LT		 1335 *
1336 * Now socket state including sk->sk_err is changed only under lock,
1337 * hence we may omit checks after joining wait queue.
1338 * We check receive queue before schedule() only as optimization;
1339 * it is very likely that release_sock() added new data.
1340 */
1341int sk_wait_data(struct sock *sk, long *timeo)
1342{
1343 int rc;
1344 DEFINE_WAIT(wait);
1345
1346 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1347 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1348 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1349 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1350 finish_wait(sk->sk_sleep, &wait);
1351 return rc;
1352}
1353
1354EXPORT_SYMBOL(sk_wait_data);
1355
1356/*
1357 * Set of default routines for initialising struct proto_ops when
1358 * the protocol does not support a particular function. In certain
1359 * cases where it makes no sense for a protocol to have a "do nothing"
1360 * function, some default processing is provided.
1361 */
1362
1363int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1364{
1365 return -EOPNOTSUPP;
1366}
1367
4ec93edb 1368int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1da177e4
LT		 1369 int len, int flags)
1370{
1371 return -EOPNOTSUPP;
1372}
1373
1374int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1375{
1376 return -EOPNOTSUPP;
1377}
1378
1379int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1380{
1381 return -EOPNOTSUPP;
1382}
1383
4ec93edb 1384int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1da177e4
LT		 1385 int *len, int peer)
1386{
1387 return -EOPNOTSUPP;
1388}
1389
1390unsigned int sock_no_poll(struct file * file, struct socket *sock, poll_table *pt)
1391{
1392 return 0;
1393}
1394
1395int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1396{
1397 return -EOPNOTSUPP;
1398}
1399
1400int sock_no_listen(struct socket *sock, int backlog)
1401{
1402 return -EOPNOTSUPP;
1403}
1404
1405int sock_no_shutdown(struct socket *sock, int how)
1406{
1407 return -EOPNOTSUPP;
1408}
1409
1410int sock_no_setsockopt(struct socket *sock, int level, int optname,
1411 char __user *optval, int optlen)
1412{
1413 return -EOPNOTSUPP;
1414}
1415
1416int sock_no_getsockopt(struct socket *sock, int level, int optname,
1417 char __user *optval, int __user *optlen)
1418{
1419 return -EOPNOTSUPP;
1420}
1421
1422int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1423 size_t len)
1424{
1425 return -EOPNOTSUPP;
1426}
1427
1428int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1429 size_t len, int flags)
1430{
1431 return -EOPNOTSUPP;
1432}
1433
1434int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1435{
1436 /* Mirror missing mmap method error code */
1437 return -ENODEV;
1438}
1439
1440ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1441{
1442 ssize_t res;
1443 struct msghdr msg = {.msg_flags = flags};
1444 struct kvec iov;
1445 char *kaddr = kmap(page);
1446 iov.iov_base = kaddr + offset;
1447 iov.iov_len = size;
1448 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1449 kunmap(page);
1450 return res;
1451}
1452
1453/*
1454 * Default Socket Callbacks
1455 */
1456
1457static void sock_def_wakeup(struct sock *sk)
1458{
1459 read_lock(&sk->sk_callback_lock);
1460 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1461 wake_up_interruptible_all(sk->sk_sleep);
1462 read_unlock(&sk->sk_callback_lock);
1463}
1464
1465static void sock_def_error_report(struct sock *sk)
1466{
1467 read_lock(&sk->sk_callback_lock);
1468 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1469 wake_up_interruptible(sk->sk_sleep);
4ec93edb 1470 sk_wake_async(sk,0,POLL_ERR);
1da177e4
LT		 1471 read_unlock(&sk->sk_callback_lock);
1472}
1473
1474static void sock_def_readable(struct sock *sk, int len)
1475{
1476 read_lock(&sk->sk_callback_lock);
1477 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1478 wake_up_interruptible(sk->sk_sleep);
1479 sk_wake_async(sk,1,POLL_IN);
1480 read_unlock(&sk->sk_callback_lock);
1481}
1482
1483static void sock_def_write_space(struct sock *sk)
1484{
1485 read_lock(&sk->sk_callback_lock);
1486
1487 /* Do not wake up a writer until he can make "significant"
1488 * progress. --DaveM
1489 */
e71a4783 1490 if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
1da177e4
LT		 1491 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1492 wake_up_interruptible(sk->sk_sleep);
1493
1494 /* Should agree with poll, otherwise some programs break */
1495 if (sock_writeable(sk))
1496 sk_wake_async(sk, 2, POLL_OUT);
1497 }
1498
1499 read_unlock(&sk->sk_callback_lock);
1500}
1501
1502static void sock_def_destruct(struct sock *sk)
1503{
a51482bd 1504 kfree(sk->sk_protinfo);
1da177e4
LT		 1505}
1506
1507void sk_send_sigurg(struct sock *sk)
1508{
1509 if (sk->sk_socket && sk->sk_socket->file)
1510 if (send_sigurg(&sk->sk_socket->file->f_owner))
1511 sk_wake_async(sk, 3, POLL_PRI);
1512}
1513
1514void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1515 unsigned long expires)
1516{
1517 if (!mod_timer(timer, expires))
1518 sock_hold(sk);
1519}
1520
1521EXPORT_SYMBOL(sk_reset_timer);
1522
1523void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1524{
1525 if (timer_pending(timer) && del_timer(timer))
1526 __sock_put(sk);
1527}
1528
1529EXPORT_SYMBOL(sk_stop_timer);
1530
1531void sock_init_data(struct socket *sock, struct sock *sk)
1532{
1533 skb_queue_head_init(&sk->sk_receive_queue);
1534 skb_queue_head_init(&sk->sk_write_queue);
1535 skb_queue_head_init(&sk->sk_error_queue);
97fc2f08
CL		 1536#ifdef CONFIG_NET_DMA
1537 skb_queue_head_init(&sk->sk_async_wait_queue);
1538#endif
1da177e4
LT		 1539
1540 sk->sk_send_head = NULL;
1541
1542 init_timer(&sk->sk_timer);
4ec93edb 1543
1da177e4
LT		 1544 sk->sk_allocation = GFP_KERNEL;
1545 sk->sk_rcvbuf = sysctl_rmem_default;
1546 sk->sk_sndbuf = sysctl_wmem_default;
1547 sk->sk_state = TCP_CLOSE;
1548 sk->sk_socket = sock;
1549
1550 sock_set_flag(sk, SOCK_ZAPPED);
1551
e71a4783 1552 if (sock) {
1da177e4
LT		 1553 sk->sk_type = sock->type;
1554 sk->sk_sleep = &sock->wait;
1555 sock->sk = sk;
1556 } else
1557 sk->sk_sleep = NULL;
1558
1559 rwlock_init(&sk->sk_dst_lock);
1560 rwlock_init(&sk->sk_callback_lock);
443aef0e
PZ		 1561 lockdep_set_class_and_name(&sk->sk_callback_lock,
1562 af_callback_keys + sk->sk_family,
1563 af_family_clock_key_strings[sk->sk_family]);
1da177e4
LT		 1564
1565 sk->sk_state_change = sock_def_wakeup;
1566 sk->sk_data_ready = sock_def_readable;
1567 sk->sk_write_space = sock_def_write_space;
1568 sk->sk_error_report = sock_def_error_report;
1569 sk->sk_destruct = sock_def_destruct;
1570
1571 sk->sk_sndmsg_page = NULL;
1572 sk->sk_sndmsg_off = 0;
1573
1574 sk->sk_peercred.pid = 0;
1575 sk->sk_peercred.uid = -1;
1576 sk->sk_peercred.gid = -1;
1577 sk->sk_write_pending = 0;
1578 sk->sk_rcvlowat = 1;
1579 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
1580 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
1581
b7aa0bf7 1582 sk->sk_stamp = ktime_set(-1L, -1L);
1da177e4
LT		 1583
1584 atomic_set(&sk->sk_refcnt, 1);
1585}
1586
fcc70d5f 1587void fastcall lock_sock_nested(struct sock *sk, int subclass)
1da177e4
LT		 1588{
1589 might_sleep();
a5b5bb9a 1590 spin_lock_bh(&sk->sk_lock.slock);
d2e9117c 1591 if (sk->sk_lock.owned)
1da177e4 1592 __lock_sock(sk);
d2e9117c 1593 sk->sk_lock.owned = 1;
a5b5bb9a
IM		 1594 spin_unlock(&sk->sk_lock.slock);
1595 /*
1596 * The sk_lock has mutex_lock() semantics here:
1597 */
fcc70d5f 1598 mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
a5b5bb9a 1599 local_bh_enable();
1da177e4
LT		 1600}
1601
fcc70d5f 1602EXPORT_SYMBOL(lock_sock_nested);
1da177e4
LT		 1603
1604void fastcall release_sock(struct sock *sk)
1605{
a5b5bb9a
IM		 1606 /*
1607 * The sk_lock has mutex_unlock() semantics:
1608 */
1609 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
1610
1611 spin_lock_bh(&sk->sk_lock.slock);
1da177e4
LT		 1612 if (sk->sk_backlog.tail)
1613 __release_sock(sk);
d2e9117c 1614 sk->sk_lock.owned = 0;
a5b5bb9a
IM		 1615 if (waitqueue_active(&sk->sk_lock.wq))
1616 wake_up(&sk->sk_lock.wq);
1617 spin_unlock_bh(&sk->sk_lock.slock);
1da177e4
LT		 1618}
1619EXPORT_SYMBOL(release_sock);
1620
1621int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
4ec93edb 1622{
b7aa0bf7 1623 struct timeval tv;
1da177e4
LT		 1624 if (!sock_flag(sk, SOCK_TIMESTAMP))
1625 sock_enable_timestamp(sk);
b7aa0bf7
ED		 1626 tv = ktime_to_timeval(sk->sk_stamp);
1627 if (tv.tv_sec == -1)
1da177e4 1628 return -ENOENT;
b7aa0bf7
ED		 1629 if (tv.tv_sec == 0) {
1630 sk->sk_stamp = ktime_get_real();
1631 tv = ktime_to_timeval(sk->sk_stamp);
1632 }
1633 return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
4ec93edb 1634}
1da177e4
LT		 1635EXPORT_SYMBOL(sock_get_timestamp);
1636
ae40eb1e
ED		 1637int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
1638{
1639 struct timespec ts;
1640 if (!sock_flag(sk, SOCK_TIMESTAMP))
1641 sock_enable_timestamp(sk);
1642 ts = ktime_to_timespec(sk->sk_stamp);
1643 if (ts.tv_sec == -1)
1644 return -ENOENT;
1645 if (ts.tv_sec == 0) {
1646 sk->sk_stamp = ktime_get_real();
1647 ts = ktime_to_timespec(sk->sk_stamp);
1648 }
1649 return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
1650}
1651EXPORT_SYMBOL(sock_get_timestampns);
1652
1da177e4 1653void sock_enable_timestamp(struct sock *sk)
4ec93edb
YH		 1654{
1655 if (!sock_flag(sk, SOCK_TIMESTAMP)) {
1da177e4
LT		 1656 sock_set_flag(sk, SOCK_TIMESTAMP);
1657 net_enable_timestamp();
1658 }
1659}
4ec93edb 1660EXPORT_SYMBOL(sock_enable_timestamp);
1da177e4
LT		 1661
1662/*
1663 * Get a socket option on an socket.
1664 *
1665 * FIX: POSIX 1003.1g is very ambiguous here. It states that
1666 * asynchronous errors should be reported by getsockopt. We assume
1667 * this means if you specify SO_ERROR (otherwise whats the point of it).
1668 */
1669int sock_common_getsockopt(struct socket *sock, int level, int optname,
1670 char __user *optval, int __user *optlen)
1671{
1672 struct sock *sk = sock->sk;
1673
1674 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1675}
1676
1677EXPORT_SYMBOL(sock_common_getsockopt);
1678
3fdadf7d 1679#ifdef CONFIG_COMPAT
543d9cfe
ACM		 1680int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
1681 char __user *optval, int __user *optlen)
3fdadf7d
DM		 1682{
1683 struct sock *sk = sock->sk;
1684
1e51f951 1685 if (sk->sk_prot->compat_getsockopt != NULL)
543d9cfe
ACM		 1686 return sk->sk_prot->compat_getsockopt(sk, level, optname,
1687 optval, optlen);
3fdadf7d
DM		 1688 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1689}
1690EXPORT_SYMBOL(compat_sock_common_getsockopt);
1691#endif
1692
1da177e4
LT		 1693int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1694 struct msghdr *msg, size_t size, int flags)
1695{
1696 struct sock *sk = sock->sk;
1697 int addr_len = 0;
1698 int err;
1699
1700 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
1701 flags & ~MSG_DONTWAIT, &addr_len);
1702 if (err >= 0)
1703 msg->msg_namelen = addr_len;
1704 return err;
1705}
1706
1707EXPORT_SYMBOL(sock_common_recvmsg);
1708
1709/*
1710 * Set socket options on an inet socket.
1711 */
1712int sock_common_setsockopt(struct socket *sock, int level, int optname,
1713 char __user *optval, int optlen)
1714{
1715 struct sock *sk = sock->sk;
1716
1717 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1718}
1719
1720EXPORT_SYMBOL(sock_common_setsockopt);
1721
3fdadf7d 1722#ifdef CONFIG_COMPAT
543d9cfe
ACM		 1723int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
1724 char __user *optval, int optlen)
3fdadf7d
DM		 1725{
1726 struct sock *sk = sock->sk;
1727
543d9cfe
ACM		 1728 if (sk->sk_prot->compat_setsockopt != NULL)
1729 return sk->sk_prot->compat_setsockopt(sk, level, optname,
1730 optval, optlen);
3fdadf7d
DM		 1731 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1732}
1733EXPORT_SYMBOL(compat_sock_common_setsockopt);
1734#endif
1735
1da177e4
LT		 1736void sk_common_release(struct sock *sk)
1737{
1738 if (sk->sk_prot->destroy)
1739 sk->sk_prot->destroy(sk);
1740
1741 /*
1742 * Observation: when sock_common_release is called, processes have
1743 * no access to socket. But net still has.
1744 * Step one, detach it from networking:
1745 *
1746 * A. Remove from hash tables.
1747 */
1748
1749 sk->sk_prot->unhash(sk);
1750
1751 /*
1752 * In this point socket cannot receive new packets, but it is possible
1753 * that some packets are in flight because some CPU runs receiver and
1754 * did hash table lookup before we unhashed socket. They will achieve
1755 * receive queue and will be purged by socket destructor.
1756 *
1757 * Also we still have packets pending on receive queue and probably,
1758 * our own packets waiting in device queues. sock_destroy will drain
1759 * receive queue, but transmitted packets will delay socket destruction
1760 * until the last reference will be released.
1761 */
1762
1763 sock_orphan(sk);
1764
1765 xfrm_sk_free_policy(sk);
1766
e6848976 1767 sk_refcnt_debug_release(sk);
1da177e4
LT		 1768 sock_put(sk);
1769}
1770
1771EXPORT_SYMBOL(sk_common_release);
1772
1773static DEFINE_RWLOCK(proto_list_lock);
1774static LIST_HEAD(proto_list);
1775
1776int proto_register(struct proto *prot, int alloc_slab)
1777{
8feaf0c0
ACM		 1778 char *request_sock_slab_name = NULL;
1779 char *timewait_sock_slab_name;
1da177e4
LT		 1780 int rc = -ENOBUFS;
1781
1da177e4
LT		 1782 if (alloc_slab) {
1783 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
20c2df83 1784 SLAB_HWCACHE_ALIGN, NULL);
1da177e4
LT		 1785
1786 if (prot->slab == NULL) {
1787 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
1788 prot->name);
2a278051 1789 goto out;
1da177e4 1790 }
2e6599cb
ACM		 1791
1792 if (prot->rsk_prot != NULL) {
1793 static const char mask[] = "request_sock_%s";
1794
1795 request_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1796 if (request_sock_slab_name == NULL)
1797 goto out_free_sock_slab;
1798
1799 sprintf(request_sock_slab_name, mask, prot->name);
1800 prot->rsk_prot->slab = kmem_cache_create(request_sock_slab_name,
1801 prot->rsk_prot->obj_size, 0,
20c2df83 1802 SLAB_HWCACHE_ALIGN, NULL);
2e6599cb
ACM		 1803
1804 if (prot->rsk_prot->slab == NULL) {
1805 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
1806 prot->name);
1807 goto out_free_request_sock_slab_name;
1808 }
1809 }
8feaf0c0 1810
6d6ee43e 1811 if (prot->twsk_prot != NULL) {
8feaf0c0
ACM		 1812 static const char mask[] = "tw_sock_%s";
1813
1814 timewait_sock_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
1815
1816 if (timewait_sock_slab_name == NULL)
1817 goto out_free_request_sock_slab;
1818
1819 sprintf(timewait_sock_slab_name, mask, prot->name);
6d6ee43e
ACM		 1820 prot->twsk_prot->twsk_slab =
1821 kmem_cache_create(timewait_sock_slab_name,
1822 prot->twsk_prot->twsk_obj_size,
1823 0, SLAB_HWCACHE_ALIGN,
20c2df83 1824 NULL);
6d6ee43e 1825 if (prot->twsk_prot->twsk_slab == NULL)
8feaf0c0
ACM		 1826 goto out_free_timewait_sock_slab_name;
1827 }
1da177e4
LT		 1828 }
1829
2a278051 1830 write_lock(&proto_list_lock);
1da177e4 1831 list_add(&prot->node, &proto_list);
1da177e4 1832 write_unlock(&proto_list_lock);
2a278051
ACM		 1833 rc = 0;
1834out:
1da177e4 1835 return rc;
8feaf0c0
ACM		 1836out_free_timewait_sock_slab_name:
1837 kfree(timewait_sock_slab_name);
1838out_free_request_sock_slab:
1839 if (prot->rsk_prot && prot->rsk_prot->slab) {
1840 kmem_cache_destroy(prot->rsk_prot->slab);
1841 prot->rsk_prot->slab = NULL;
1842 }
2e6599cb
ACM		 1843out_free_request_sock_slab_name:
1844 kfree(request_sock_slab_name);
1845out_free_sock_slab:
1846 kmem_cache_destroy(prot->slab);
1847 prot->slab = NULL;
1848 goto out;
1da177e4
LT		 1849}
1850
1851EXPORT_SYMBOL(proto_register);
1852
1853void proto_unregister(struct proto *prot)
1854{
1855 write_lock(&proto_list_lock);
0a3f4358
PM		 1856 list_del(&prot->node);
1857 write_unlock(&proto_list_lock);
1da177e4
LT		 1858
1859 if (prot->slab != NULL) {
1860 kmem_cache_destroy(prot->slab);
1861 prot->slab = NULL;
1862 }
1863
2e6599cb
ACM		 1864 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
1865 const char *name = kmem_cache_name(prot->rsk_prot->slab);
1866
1867 kmem_cache_destroy(prot->rsk_prot->slab);
1868 kfree(name);
1869 prot->rsk_prot->slab = NULL;
1870 }
1871
6d6ee43e
ACM		 1872 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
1873 const char *name = kmem_cache_name(prot->twsk_prot->twsk_slab);
8feaf0c0 1874
6d6ee43e 1875 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
8feaf0c0 1876 kfree(name);
6d6ee43e 1877 prot->twsk_prot->twsk_slab = NULL;
8feaf0c0 1878 }
1da177e4
LT		 1879}
1880
1881EXPORT_SYMBOL(proto_unregister);
1882
1883#ifdef CONFIG_PROC_FS
1da177e4
LT		 1884static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
1885{
1886 read_lock(&proto_list_lock);
60f0438a 1887 return seq_list_start_head(&proto_list, *pos);
1da177e4
LT		 1888}
1889
1890static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
1891{
60f0438a 1892 return seq_list_next(v, &proto_list, pos);
1da177e4
LT		 1893}
1894
1895static void proto_seq_stop(struct seq_file *seq, void *v)
1896{
1897 read_unlock(&proto_list_lock);
1898}
1899
1900static char proto_method_implemented(const void *method)
1901{
1902 return method == NULL ? 'n' : 'y';
1903}
1904
1905static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
1906{
1907 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s "
1908 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
1909 proto->name,
1910 proto->obj_size,
1911 proto->sockets_allocated != NULL ? atomic_read(proto->sockets_allocated) : -1,
1912 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
1913 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
1914 proto->max_header,
1915 proto->slab == NULL ? "no" : "yes",
1916 module_name(proto->owner),
1917 proto_method_implemented(proto->close),
1918 proto_method_implemented(proto->connect),
1919 proto_method_implemented(proto->disconnect),
1920 proto_method_implemented(proto->accept),
1921 proto_method_implemented(proto->ioctl),
1922 proto_method_implemented(proto->init),
1923 proto_method_implemented(proto->destroy),
1924 proto_method_implemented(proto->shutdown),
1925 proto_method_implemented(proto->setsockopt),
1926 proto_method_implemented(proto->getsockopt),
1927 proto_method_implemented(proto->sendmsg),
1928 proto_method_implemented(proto->recvmsg),
1929 proto_method_implemented(proto->sendpage),
1930 proto_method_implemented(proto->bind),
1931 proto_method_implemented(proto->backlog_rcv),
1932 proto_method_implemented(proto->hash),
1933 proto_method_implemented(proto->unhash),
1934 proto_method_implemented(proto->get_port),
1935 proto_method_implemented(proto->enter_memory_pressure));
1936}
1937
1938static int proto_seq_show(struct seq_file *seq, void *v)
1939{
60f0438a 1940 if (v == &proto_list)
1da177e4
LT		 1941 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
1942 "protocol",
1943 "size",
1944 "sockets",
1945 "memory",
1946 "press",
1947 "maxhdr",
1948 "slab",
1949 "module",
1950 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
1951 else
60f0438a 1952 proto_seq_printf(seq, list_entry(v, struct proto, node));
1da177e4
LT		 1953 return 0;
1954}
1955
f690808e 1956static const struct seq_operations proto_seq_ops = {
1da177e4
LT		 1957 .start = proto_seq_start,
1958 .next = proto_seq_next,
1959 .stop = proto_seq_stop,
1960 .show = proto_seq_show,
1961};
1962
1963static int proto_seq_open(struct inode *inode, struct file *file)
1964{
1965 return seq_open(file, &proto_seq_ops);
1966}
1967
9a32144e 1968static const struct file_operations proto_seq_fops = {
1da177e4
LT		 1969 .owner = THIS_MODULE,
1970 .open = proto_seq_open,
1971 .read = seq_read,
1972 .llseek = seq_lseek,
1973 .release = seq_release,
1974};
1975
1976static int __init proto_init(void)
1977{
1978 /* register /proc/net/protocols */
457c4cbc 1979 return proc_net_fops_create(&init_net, "protocols", S_IRUGO, &proto_seq_fops) == NULL ? -ENOBUFS : 0;
1da177e4
LT		 1980}
1981
1982subsys_initcall(proto_init);
1983
1984#endif /* PROC_FS */
1985
1986EXPORT_SYMBOL(sk_alloc);
1987EXPORT_SYMBOL(sk_free);
1988EXPORT_SYMBOL(sk_send_sigurg);
1989EXPORT_SYMBOL(sock_alloc_send_skb);
1990EXPORT_SYMBOL(sock_init_data);
1991EXPORT_SYMBOL(sock_kfree_s);
1992EXPORT_SYMBOL(sock_kmalloc);
1993EXPORT_SYMBOL(sock_no_accept);
1994EXPORT_SYMBOL(sock_no_bind);
1995EXPORT_SYMBOL(sock_no_connect);
1996EXPORT_SYMBOL(sock_no_getname);
1997EXPORT_SYMBOL(sock_no_getsockopt);
1998EXPORT_SYMBOL(sock_no_ioctl);
1999EXPORT_SYMBOL(sock_no_listen);
2000EXPORT_SYMBOL(sock_no_mmap);
2001EXPORT_SYMBOL(sock_no_poll);
2002EXPORT_SYMBOL(sock_no_recvmsg);
2003EXPORT_SYMBOL(sock_no_sendmsg);
2004EXPORT_SYMBOL(sock_no_sendpage);
2005EXPORT_SYMBOL(sock_no_setsockopt);
2006EXPORT_SYMBOL(sock_no_shutdown);
2007EXPORT_SYMBOL(sock_no_socketpair);
2008EXPORT_SYMBOL(sock_rfree);
2009EXPORT_SYMBOL(sock_setsockopt);
2010EXPORT_SYMBOL(sock_wfree);
2011EXPORT_SYMBOL(sock_wmalloc);
2012EXPORT_SYMBOL(sock_i_uid);
2013EXPORT_SYMBOL(sock_i_ino);
1da177e4 2014EXPORT_SYMBOL(sysctl_optmem_max);
6baf1f41 2015#ifdef CONFIG_SYSCTL
1da177e4
LT		 2016EXPORT_SYMBOL(sysctl_rmem_max);
2017EXPORT_SYMBOL(sysctl_wmem_max);
2018#endif
Clone of davem's net-next-2.6 tree