blob: 04e35eb2e736144a554dcd02354f38d943ba4e3e [file] [log] [blame]
Linus Torvalds1da177e2005-04-16 15:20:36 -07001/*
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 *
Jesper Juhl02c30a82005-05-05 16:16:16 -070010 * Authors: Ross Biro
Linus Torvalds1da177e2005-04-16 15:20:36 -070011 * Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
12 * Florian La Roche, <flla@stud.uni-sb.de>
13 * Alan Cox, <A.Cox@swansea.ac.uk>
14 *
15 * Fixes:
16 * Alan Cox : Numerous verify_area() problems
17 * Alan Cox : Connecting on a connecting socket
18 * now returns an error for tcp.
19 * Alan Cox : sock->protocol is set correctly.
20 * and is not sometimes left as 0.
21 * Alan Cox : connect handles icmp errors on a
22 * connect properly. Unfortunately there
23 * is a restart syscall nasty there. I
24 * can't match BSD without hacking the C
25 * library. Ideas urgently sought!
26 * Alan Cox : Disallow bind() to addresses that are
27 * not ours - especially broadcast ones!!
28 * Alan Cox : Socket 1024 _IS_ ok for users. (fencepost)
29 * Alan Cox : sock_wfree/sock_rfree don't destroy sockets,
30 * instead they leave that for the DESTROY timer.
31 * Alan Cox : Clean up error flag in accept
32 * Alan Cox : TCP ack handling is buggy, the DESTROY timer
33 * was buggy. Put a remove_sock() in the handler
34 * for memory when we hit 0. Also altered the timer
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +090035 * code. The ACK stuff can wait and needs major
Linus Torvalds1da177e2005-04-16 15:20:36 -070036 * TCP layer surgery.
37 * Alan Cox : Fixed TCP ack bug, removed remove sock
38 * and fixed timer/inet_bh race.
39 * Alan Cox : Added zapped flag for TCP
40 * Alan Cox : Move kfree_skb into skbuff.c and tidied up surplus code
41 * Alan Cox : for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
42 * Alan Cox : kfree_s calls now are kfree_skbmem so we can track skb resources
43 * Alan Cox : Supports socket option broadcast now as does udp. Packet and raw need fixing.
44 * Alan Cox : Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
45 * Rick Sladkey : Relaxed UDP rules for matching packets.
46 * C.E.Hawkins : IFF_PROMISC/SIOCGHWADDR support
47 * Pauline Middelink : identd support
48 * Alan Cox : Fixed connect() taking signals I think.
49 * Alan Cox : SO_LINGER supported
50 * Alan Cox : Error reporting fixes
51 * Anonymous : inet_create tidied up (sk->reuse setting)
52 * Alan Cox : inet sockets don't set sk->type!
53 * Alan Cox : Split socket option code
54 * Alan Cox : Callbacks
55 * Alan Cox : Nagle flag for Charles & Johannes stuff
56 * Alex : Removed restriction on inet fioctl
57 * Alan Cox : Splitting INET from NET core
58 * Alan Cox : Fixed bogus SO_TYPE handling in getsockopt()
59 * Adam Caldwell : Missing return in SO_DONTROUTE/SO_DEBUG code
60 * Alan Cox : Split IP from generic code
61 * Alan Cox : New kfree_skbmem()
62 * Alan Cox : Make SO_DEBUG superuser only.
63 * Alan Cox : Allow anyone to clear SO_DEBUG
64 * (compatibility fix)
65 * Alan Cox : Added optimistic memory grabbing for AF_UNIX throughput.
66 * Alan Cox : Allocator for a socket is settable.
67 * Alan Cox : SO_ERROR includes soft errors.
68 * Alan Cox : Allow NULL arguments on some SO_ opts
69 * Alan Cox : Generic socket allocation to make hooks
70 * easier (suggested by Craig Metz).
71 * Michael Pall : SO_ERROR returns positive errno again
72 * Steve Whitehouse: Added default destructor to free
73 * protocol private data.
74 * Steve Whitehouse: Added various other default routines
75 * common to several socket families.
76 * Chris Evans : Call suser() check last on F_SETOWN
77 * Jay Schulist : Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
78 * Andi Kleen : Add sock_kmalloc()/sock_kfree_s()
79 * Andi Kleen : Fix write_space callback
80 * Chris Evans : Security fixes - signedness again
81 * Arnaldo C. Melo : cleanups, use skb_queue_purge
82 *
83 * To Fix:
84 *
85 *
86 * This program is free software; you can redistribute it and/or
87 * modify it under the terms of the GNU General Public License
88 * as published by the Free Software Foundation; either version
89 * 2 of the License, or (at your option) any later version.
90 */
91
Randy Dunlap4fc268d2006-01-11 12:17:47 -080092#include <linux/capability.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070093#include <linux/errno.h>
94#include <linux/types.h>
95#include <linux/socket.h>
96#include <linux/in.h>
97#include <linux/kernel.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -070098#include <linux/module.h>
99#include <linux/proc_fs.h>
100#include <linux/seq_file.h>
101#include <linux/sched.h>
102#include <linux/timer.h>
103#include <linux/string.h>
104#include <linux/sockios.h>
105#include <linux/net.h>
106#include <linux/mm.h>
107#include <linux/slab.h>
108#include <linux/interrupt.h>
109#include <linux/poll.h>
110#include <linux/tcp.h>
111#include <linux/init.h>
Al Viroa1f8e7f72006-10-19 16:08:53 -0400112#include <linux/highmem.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700113
114#include <asm/uaccess.h>
115#include <asm/system.h>
116
117#include <linux/netdevice.h>
118#include <net/protocol.h>
119#include <linux/skbuff.h>
Eric W. Biederman457c4cb2007-09-12 12:01:34 +0200120#include <net/net_namespace.h>
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -0700121#include <net/request_sock.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700122#include <net/sock.h>
Patrick Ohly20d49472009-02-12 05:03:38 +0000123#include <linux/net_tstamp.h>
Linus Torvalds1da177e2005-04-16 15:20:36 -0700124#include <net/xfrm.h>
125#include <linux/ipsec.h>
126
127#include <linux/filter.h>
128
129#ifdef CONFIG_INET
130#include <net/tcp.h>
131#endif
132
Ingo Molnarda21f242006-07-03 00:25:12 -0700133/*
134 * Each address family might have different locking rules, so we have
135 * one slock key per address family:
136 */
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700137static struct lock_class_key af_family_keys[AF_MAX];
138static struct lock_class_key af_family_slock_keys[AF_MAX];
139
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700140/*
141 * Make lock validator output more readable. (we pre-construct these
142 * strings build-time, so that runtime initialization of socket
143 * locks is fast):
144 */
145static const char *af_family_key_strings[AF_MAX+1] = {
146 "sk_lock-AF_UNSPEC", "sk_lock-AF_UNIX" , "sk_lock-AF_INET" ,
147 "sk_lock-AF_AX25" , "sk_lock-AF_IPX" , "sk_lock-AF_APPLETALK",
148 "sk_lock-AF_NETROM", "sk_lock-AF_BRIDGE" , "sk_lock-AF_ATMPVC" ,
149 "sk_lock-AF_X25" , "sk_lock-AF_INET6" , "sk_lock-AF_ROSE" ,
150 "sk_lock-AF_DECnet", "sk_lock-AF_NETBEUI" , "sk_lock-AF_SECURITY" ,
151 "sk_lock-AF_KEY" , "sk_lock-AF_NETLINK" , "sk_lock-AF_PACKET" ,
152 "sk_lock-AF_ASH" , "sk_lock-AF_ECONET" , "sk_lock-AF_ATMSVC" ,
Andy Grovercbd151b2009-02-26 23:43:19 -0800153 "sk_lock-AF_RDS" , "sk_lock-AF_SNA" , "sk_lock-AF_IRDA" ,
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700154 "sk_lock-AF_PPPOX" , "sk_lock-AF_WANPIPE" , "sk_lock-AF_LLC" ,
Oliver Hartkoppcd05acf2007-12-16 15:59:24 -0800155 "sk_lock-27" , "sk_lock-28" , "sk_lock-AF_CAN" ,
David Howells17926a72007-04-26 15:48:28 -0700156 "sk_lock-AF_TIPC" , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV" ,
Remi Denis-Courmontbce7b152008-09-22 19:51:15 -0700157 "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN" , "sk_lock-AF_PHONET" ,
Sergey Lapinfcb94e42009-06-08 12:18:47 +0000158 "sk_lock-AF_IEEE802154",
Remi Denis-Courmontbce7b152008-09-22 19:51:15 -0700159 "sk_lock-AF_MAX"
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700160};
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" ,
Andy Grovercbd151b2009-02-26 23:43:19 -0800169 "slock-AF_RDS" , "slock-AF_SNA" , "slock-AF_IRDA" ,
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700170 "slock-AF_PPPOX" , "slock-AF_WANPIPE" , "slock-AF_LLC" ,
Oliver Hartkoppcd05acf2007-12-16 15:59:24 -0800171 "slock-27" , "slock-28" , "slock-AF_CAN" ,
David Howells17926a72007-04-26 15:48:28 -0700172 "slock-AF_TIPC" , "slock-AF_BLUETOOTH", "slock-AF_IUCV" ,
Remi Denis-Courmontbce7b152008-09-22 19:51:15 -0700173 "slock-AF_RXRPC" , "slock-AF_ISDN" , "slock-AF_PHONET" ,
Sergey Lapinfcb94e42009-06-08 12:18:47 +0000174 "slock-AF_IEEE802154",
Remi Denis-Courmontbce7b152008-09-22 19:51:15 -0700175 "slock-AF_MAX"
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700176};
Peter Zijlstra443aef02007-07-19 01:49:00 -0700177static const char *af_family_clock_key_strings[AF_MAX+1] = {
178 "clock-AF_UNSPEC", "clock-AF_UNIX" , "clock-AF_INET" ,
179 "clock-AF_AX25" , "clock-AF_IPX" , "clock-AF_APPLETALK",
180 "clock-AF_NETROM", "clock-AF_BRIDGE" , "clock-AF_ATMPVC" ,
181 "clock-AF_X25" , "clock-AF_INET6" , "clock-AF_ROSE" ,
182 "clock-AF_DECnet", "clock-AF_NETBEUI" , "clock-AF_SECURITY" ,
183 "clock-AF_KEY" , "clock-AF_NETLINK" , "clock-AF_PACKET" ,
184 "clock-AF_ASH" , "clock-AF_ECONET" , "clock-AF_ATMSVC" ,
Andy Grovercbd151b2009-02-26 23:43:19 -0800185 "clock-AF_RDS" , "clock-AF_SNA" , "clock-AF_IRDA" ,
Peter Zijlstra443aef02007-07-19 01:49:00 -0700186 "clock-AF_PPPOX" , "clock-AF_WANPIPE" , "clock-AF_LLC" ,
Oliver Hartkoppb4942af2008-07-23 14:06:04 -0700187 "clock-27" , "clock-28" , "clock-AF_CAN" ,
David Howellse51f8022007-07-21 19:30:16 -0700188 "clock-AF_TIPC" , "clock-AF_BLUETOOTH", "clock-AF_IUCV" ,
Remi Denis-Courmontbce7b152008-09-22 19:51:15 -0700189 "clock-AF_RXRPC" , "clock-AF_ISDN" , "clock-AF_PHONET" ,
Sergey Lapinfcb94e42009-06-08 12:18:47 +0000190 "clock-AF_IEEE802154",
Remi Denis-Courmontbce7b152008-09-22 19:51:15 -0700191 "clock-AF_MAX"
Peter Zijlstra443aef02007-07-19 01:49:00 -0700192};
Ingo Molnarda21f242006-07-03 00:25:12 -0700193
194/*
195 * sk_callback_lock locking rules are per-address-family,
196 * so split the lock classes by using a per-AF key:
197 */
198static struct lock_class_key af_callback_keys[AF_MAX];
199
Linus Torvalds1da177e2005-04-16 15:20:36 -0700200/* Take into consideration the size of the struct sk_buff overhead in the
201 * determination of these values, since that is non-constant across
202 * platforms. This makes socket queueing behavior and performance
203 * not depend upon such differences.
204 */
205#define _SK_MEM_PACKETS 256
206#define _SK_MEM_OVERHEAD (sizeof(struct sk_buff) + 256)
207#define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
208#define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
209
210/* Run time adjustable parameters. */
Brian Haleyab32ea52006-09-22 14:15:41 -0700211__u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
212__u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
213__u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
214__u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700215
216/* Maximal space eaten by iovec or ancilliary data plus some space */
Brian Haleyab32ea52006-09-22 14:15:41 -0700217int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
Eric Dumazet2a915252009-05-27 11:30:05 +0000218EXPORT_SYMBOL(sysctl_optmem_max);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700219
220static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
221{
222 struct timeval tv;
223
224 if (optlen < sizeof(tv))
225 return -EINVAL;
226 if (copy_from_user(&tv, optval, sizeof(tv)))
227 return -EFAULT;
Vasily Averinba780732007-05-24 16:58:54 -0700228 if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
229 return -EDOM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700230
Vasily Averinba780732007-05-24 16:58:54 -0700231 if (tv.tv_sec < 0) {
Andrew Morton6f11df82007-07-09 13:16:00 -0700232 static int warned __read_mostly;
233
Vasily Averinba780732007-05-24 16:58:54 -0700234 *timeo_p = 0;
Ilpo Järvinen50aab542008-05-02 16:20:10 -0700235 if (warned < 10 && net_ratelimit()) {
Vasily Averinba780732007-05-24 16:58:54 -0700236 warned++;
237 printk(KERN_INFO "sock_set_timeout: `%s' (pid %d) "
238 "tries to set negative timeout\n",
Pavel Emelyanovba25f9d2007-10-18 23:40:40 -0700239 current->comm, task_pid_nr(current));
Ilpo Järvinen50aab542008-05-02 16:20:10 -0700240 }
Vasily Averinba780732007-05-24 16:58:54 -0700241 return 0;
242 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700243 *timeo_p = MAX_SCHEDULE_TIMEOUT;
244 if (tv.tv_sec == 0 && tv.tv_usec == 0)
245 return 0;
246 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
247 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
248 return 0;
249}
250
251static void sock_warn_obsolete_bsdism(const char *name)
252{
253 static int warned;
254 static char warncomm[TASK_COMM_LEN];
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900255 if (strcmp(warncomm, current->comm) && warned < 5) {
256 strcpy(warncomm, current->comm);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700257 printk(KERN_WARNING "process `%s' is using obsolete "
258 "%s SO_BSDCOMPAT\n", warncomm, name);
259 warned++;
260 }
261}
262
Patrick Ohly20d49472009-02-12 05:03:38 +0000263static void sock_disable_timestamp(struct sock *sk, int flag)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900264{
Patrick Ohly20d49472009-02-12 05:03:38 +0000265 if (sock_flag(sk, flag)) {
266 sock_reset_flag(sk, flag);
267 if (!sock_flag(sk, SOCK_TIMESTAMP) &&
268 !sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE)) {
269 net_disable_timestamp();
270 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700271 }
272}
273
274
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800275int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
276{
277 int err = 0;
278 int skb_len;
279
Rami Rosen9ee6b7f2008-05-14 03:50:03 -0700280 /* Cast sk->rcvbuf to unsigned... It's pointless, but reduces
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800281 number of warnings when compiling with -W --ANK
282 */
283 if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
284 (unsigned)sk->sk_rcvbuf) {
285 err = -ENOMEM;
286 goto out;
287 }
288
Dmitry Mishinfda9ef52006-08-31 15:28:39 -0700289 err = sk_filter(sk, skb);
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800290 if (err)
291 goto out;
292
Hideo Aoki3ab224b2007-12-31 00:11:19 -0800293 if (!sk_rmem_schedule(sk, skb->truesize)) {
294 err = -ENOBUFS;
295 goto out;
296 }
297
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800298 skb->dev = NULL;
299 skb_set_owner_r(skb, sk);
David S. Miller49ad9592008-12-17 22:11:38 -0800300
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800301 /* Cache the SKB length before we tack it onto the receive
302 * queue. Once it is added it no longer belongs to us and
303 * may be freed by other threads of control pulling packets
304 * from the queue.
305 */
306 skb_len = skb->len;
307
308 skb_queue_tail(&sk->sk_receive_queue, skb);
309
310 if (!sock_flag(sk, SOCK_DEAD))
311 sk->sk_data_ready(sk, skb_len);
312out:
313 return err;
314}
315EXPORT_SYMBOL(sock_queue_rcv_skb);
316
Arnaldo Carvalho de Melo58a5a7b2006-11-16 14:06:06 -0200317int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800318{
319 int rc = NET_RX_SUCCESS;
320
Dmitry Mishinfda9ef52006-08-31 15:28:39 -0700321 if (sk_filter(sk, skb))
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800322 goto discard_and_relse;
323
324 skb->dev = NULL;
325
Arnaldo Carvalho de Melo58a5a7b2006-11-16 14:06:06 -0200326 if (nested)
327 bh_lock_sock_nested(sk);
328 else
329 bh_lock_sock(sk);
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700330 if (!sock_owned_by_user(sk)) {
331 /*
332 * trylock + unlock semantics:
333 */
334 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
335
Peter Zijlstrac57943a2008-10-07 14:18:42 -0700336 rc = sk_backlog_rcv(sk, skb);
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700337
338 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
339 } else
Denis Vlasenkof0088a52006-03-28 01:08:21 -0800340 sk_add_backlog(sk, skb);
341 bh_unlock_sock(sk);
342out:
343 sock_put(sk);
344 return rc;
345discard_and_relse:
346 kfree_skb(skb);
347 goto out;
348}
349EXPORT_SYMBOL(sk_receive_skb);
350
351struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
352{
353 struct dst_entry *dst = sk->sk_dst_cache;
354
355 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
356 sk->sk_dst_cache = NULL;
357 dst_release(dst);
358 return NULL;
359 }
360
361 return dst;
362}
363EXPORT_SYMBOL(__sk_dst_check);
364
365struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
366{
367 struct dst_entry *dst = sk_dst_get(sk);
368
369 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
370 sk_dst_reset(sk);
371 dst_release(dst);
372 return NULL;
373 }
374
375 return dst;
376}
377EXPORT_SYMBOL(sk_dst_check);
378
David S. Miller48788092007-09-14 16:41:03 -0700379static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
380{
381 int ret = -ENOPROTOOPT;
382#ifdef CONFIG_NETDEVICES
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +0900383 struct net *net = sock_net(sk);
David S. Miller48788092007-09-14 16:41:03 -0700384 char devname[IFNAMSIZ];
385 int index;
386
387 /* Sorry... */
388 ret = -EPERM;
389 if (!capable(CAP_NET_RAW))
390 goto out;
391
392 ret = -EINVAL;
393 if (optlen < 0)
394 goto out;
395
396 /* Bind this socket to a particular device like "eth0",
397 * as specified in the passed interface name. If the
398 * name is "" or the option length is zero the socket
399 * is not bound.
400 */
401 if (optlen > IFNAMSIZ - 1)
402 optlen = IFNAMSIZ - 1;
403 memset(devname, 0, sizeof(devname));
404
405 ret = -EFAULT;
406 if (copy_from_user(devname, optval, optlen))
407 goto out;
408
409 if (devname[0] == '\0') {
410 index = 0;
411 } else {
Eric W. Biederman881d9662007-09-17 11:56:21 -0700412 struct net_device *dev = dev_get_by_name(net, devname);
David S. Miller48788092007-09-14 16:41:03 -0700413
414 ret = -ENODEV;
415 if (!dev)
416 goto out;
417
418 index = dev->ifindex;
419 dev_put(dev);
420 }
421
422 lock_sock(sk);
423 sk->sk_bound_dev_if = index;
424 sk_dst_reset(sk);
425 release_sock(sk);
426
427 ret = 0;
428
429out:
430#endif
431
432 return ret;
433}
434
Pavel Emelyanovc0ef8772007-11-15 03:03:19 -0800435static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
436{
437 if (valbool)
438 sock_set_flag(sk, bit);
439 else
440 sock_reset_flag(sk, bit);
441}
442
Linus Torvalds1da177e2005-04-16 15:20:36 -0700443/*
444 * This is meant for all protocols to use and covers goings on
445 * at the socket level. Everything here is generic.
446 */
447
448int sock_setsockopt(struct socket *sock, int level, int optname,
449 char __user *optval, int optlen)
450{
Eric Dumazet2a915252009-05-27 11:30:05 +0000451 struct sock *sk = sock->sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700452 int val;
453 int valbool;
454 struct linger ling;
455 int ret = 0;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900456
Linus Torvalds1da177e2005-04-16 15:20:36 -0700457 /*
458 * Options without arguments
459 */
460
David S. Miller48788092007-09-14 16:41:03 -0700461 if (optname == SO_BINDTODEVICE)
462 return sock_bindtodevice(sk, optval, optlen);
463
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700464 if (optlen < sizeof(int))
465 return -EINVAL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900466
Linus Torvalds1da177e2005-04-16 15:20:36 -0700467 if (get_user(val, (int __user *)optval))
468 return -EFAULT;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900469
Eric Dumazet2a915252009-05-27 11:30:05 +0000470 valbool = val ? 1 : 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700471
472 lock_sock(sk);
473
Eric Dumazet2a915252009-05-27 11:30:05 +0000474 switch (optname) {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700475 case SO_DEBUG:
Eric Dumazet2a915252009-05-27 11:30:05 +0000476 if (val && !capable(CAP_NET_ADMIN))
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700477 ret = -EACCES;
Eric Dumazet2a915252009-05-27 11:30:05 +0000478 else
Pavel Emelyanovc0ef8772007-11-15 03:03:19 -0800479 sock_valbool_flag(sk, SOCK_DBG, valbool);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700480 break;
481 case SO_REUSEADDR:
482 sk->sk_reuse = valbool;
483 break;
484 case SO_TYPE:
485 case SO_ERROR:
486 ret = -ENOPROTOOPT;
487 break;
488 case SO_DONTROUTE:
Pavel Emelyanovc0ef8772007-11-15 03:03:19 -0800489 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700490 break;
491 case SO_BROADCAST:
492 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
493 break;
494 case SO_SNDBUF:
495 /* Don't error on this BSD doesn't and if you think
496 about it this is right. Otherwise apps have to
497 play 'guess the biggest size' games. RCVBUF/SNDBUF
498 are treated in BSD as hints */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900499
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700500 if (val > sysctl_wmem_max)
501 val = sysctl_wmem_max;
Patrick McHardyb0573de2005-08-09 19:30:51 -0700502set_sndbuf:
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700503 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
504 if ((val * 2) < SOCK_MIN_SNDBUF)
505 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
506 else
507 sk->sk_sndbuf = val * 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700508
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700509 /*
510 * Wake up sending tasks if we
511 * upped the value.
512 */
513 sk->sk_write_space(sk);
514 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700515
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700516 case SO_SNDBUFFORCE:
517 if (!capable(CAP_NET_ADMIN)) {
518 ret = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700519 break;
520 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700521 goto set_sndbuf;
522
523 case SO_RCVBUF:
524 /* Don't error on this BSD doesn't and if you think
525 about it this is right. Otherwise apps have to
526 play 'guess the biggest size' games. RCVBUF/SNDBUF
527 are treated in BSD as hints */
528
529 if (val > sysctl_rmem_max)
530 val = sysctl_rmem_max;
531set_rcvbuf:
532 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
533 /*
534 * We double it on the way in to account for
535 * "struct sk_buff" etc. overhead. Applications
536 * assume that the SO_RCVBUF setting they make will
537 * allow that much actual data to be received on that
538 * socket.
539 *
540 * Applications are unaware that "struct sk_buff" and
541 * other overheads allocate from the receive buffer
542 * during socket buffer allocation.
543 *
544 * And after considering the possible alternatives,
545 * returning the value we actually used in getsockopt
546 * is the most desirable behavior.
547 */
548 if ((val * 2) < SOCK_MIN_RCVBUF)
549 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
550 else
551 sk->sk_rcvbuf = val * 2;
552 break;
553
554 case SO_RCVBUFFORCE:
555 if (!capable(CAP_NET_ADMIN)) {
556 ret = -EPERM;
557 break;
558 }
559 goto set_rcvbuf;
560
561 case SO_KEEPALIVE:
562#ifdef CONFIG_INET
563 if (sk->sk_protocol == IPPROTO_TCP)
564 tcp_set_keepalive(sk, valbool);
565#endif
566 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
567 break;
568
569 case SO_OOBINLINE:
570 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
571 break;
572
573 case SO_NO_CHECK:
574 sk->sk_no_check = valbool;
575 break;
576
577 case SO_PRIORITY:
578 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
579 sk->sk_priority = val;
580 else
581 ret = -EPERM;
582 break;
583
584 case SO_LINGER:
585 if (optlen < sizeof(ling)) {
586 ret = -EINVAL; /* 1003.1g */
587 break;
588 }
Eric Dumazet2a915252009-05-27 11:30:05 +0000589 if (copy_from_user(&ling, optval, sizeof(ling))) {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700590 ret = -EFAULT;
591 break;
592 }
593 if (!ling.l_onoff)
594 sock_reset_flag(sk, SOCK_LINGER);
595 else {
596#if (BITS_PER_LONG == 32)
597 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
598 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
599 else
600#endif
601 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
602 sock_set_flag(sk, SOCK_LINGER);
603 }
604 break;
605
606 case SO_BSDCOMPAT:
607 sock_warn_obsolete_bsdism("setsockopt");
608 break;
609
610 case SO_PASSCRED:
611 if (valbool)
612 set_bit(SOCK_PASSCRED, &sock->flags);
613 else
614 clear_bit(SOCK_PASSCRED, &sock->flags);
615 break;
616
617 case SO_TIMESTAMP:
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700618 case SO_TIMESTAMPNS:
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700619 if (valbool) {
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700620 if (optname == SO_TIMESTAMP)
621 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
622 else
623 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700624 sock_set_flag(sk, SOCK_RCVTSTAMP);
Patrick Ohly20d49472009-02-12 05:03:38 +0000625 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700626 } else {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700627 sock_reset_flag(sk, SOCK_RCVTSTAMP);
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700628 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
629 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700630 break;
631
Patrick Ohly20d49472009-02-12 05:03:38 +0000632 case SO_TIMESTAMPING:
633 if (val & ~SOF_TIMESTAMPING_MASK) {
634 ret = EINVAL;
635 break;
636 }
637 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE,
638 val & SOF_TIMESTAMPING_TX_HARDWARE);
639 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE,
640 val & SOF_TIMESTAMPING_TX_SOFTWARE);
641 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE,
642 val & SOF_TIMESTAMPING_RX_HARDWARE);
643 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
644 sock_enable_timestamp(sk,
645 SOCK_TIMESTAMPING_RX_SOFTWARE);
646 else
647 sock_disable_timestamp(sk,
648 SOCK_TIMESTAMPING_RX_SOFTWARE);
649 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SOFTWARE,
650 val & SOF_TIMESTAMPING_SOFTWARE);
651 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE,
652 val & SOF_TIMESTAMPING_SYS_HARDWARE);
653 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE,
654 val & SOF_TIMESTAMPING_RAW_HARDWARE);
655 break;
656
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700657 case SO_RCVLOWAT:
658 if (val < 0)
659 val = INT_MAX;
660 sk->sk_rcvlowat = val ? : 1;
661 break;
662
663 case SO_RCVTIMEO:
664 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
665 break;
666
667 case SO_SNDTIMEO:
668 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
669 break;
670
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700671 case SO_ATTACH_FILTER:
672 ret = -EINVAL;
673 if (optlen == sizeof(struct sock_fprog)) {
674 struct sock_fprog fprog;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700675
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700676 ret = -EFAULT;
677 if (copy_from_user(&fprog, optval, sizeof(fprog)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700678 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700679
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700680 ret = sk_attach_filter(&fprog, sk);
681 }
682 break;
683
684 case SO_DETACH_FILTER:
Pavel Emelyanov55b33322007-10-17 21:21:26 -0700685 ret = sk_detach_filter(sk);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700686 break;
687
688 case SO_PASSSEC:
689 if (valbool)
690 set_bit(SOCK_PASSSEC, &sock->flags);
691 else
692 clear_bit(SOCK_PASSSEC, &sock->flags);
693 break;
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800694 case SO_MARK:
695 if (!capable(CAP_NET_ADMIN))
696 ret = -EPERM;
Eric Dumazet2a915252009-05-27 11:30:05 +0000697 else
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800698 sk->sk_mark = val;
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800699 break;
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700700
Linus Torvalds1da177e2005-04-16 15:20:36 -0700701 /* We implement the SO_SNDLOWAT etc to
702 not be settable (1003.1g 5.3) */
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700703 default:
704 ret = -ENOPROTOOPT;
705 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900706 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700707 release_sock(sk);
708 return ret;
709}
Eric Dumazet2a915252009-05-27 11:30:05 +0000710EXPORT_SYMBOL(sock_setsockopt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700711
712
713int sock_getsockopt(struct socket *sock, int level, int optname,
714 char __user *optval, int __user *optlen)
715{
716 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900717
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700718 union {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900719 int val;
720 struct linger ling;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700721 struct timeval tm;
722 } v;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900723
Linus Torvalds1da177e2005-04-16 15:20:36 -0700724 unsigned int lv = sizeof(int);
725 int len;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900726
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700727 if (get_user(len, optlen))
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900728 return -EFAULT;
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700729 if (len < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700730 return -EINVAL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900731
Eugene Teo50fee1d2009-02-23 15:38:41 -0800732 memset(&v, 0, sizeof(v));
Clément Lecignedf0bca02009-02-12 16:59:09 -0800733
Eric Dumazet2a915252009-05-27 11:30:05 +0000734 switch (optname) {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700735 case SO_DEBUG:
736 v.val = sock_flag(sk, SOCK_DBG);
737 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900738
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700739 case SO_DONTROUTE:
740 v.val = sock_flag(sk, SOCK_LOCALROUTE);
741 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900742
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700743 case SO_BROADCAST:
744 v.val = !!sock_flag(sk, SOCK_BROADCAST);
745 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700746
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700747 case SO_SNDBUF:
748 v.val = sk->sk_sndbuf;
749 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900750
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700751 case SO_RCVBUF:
752 v.val = sk->sk_rcvbuf;
753 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700754
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700755 case SO_REUSEADDR:
756 v.val = sk->sk_reuse;
757 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700758
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700759 case SO_KEEPALIVE:
760 v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
761 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700762
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700763 case SO_TYPE:
764 v.val = sk->sk_type;
765 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700766
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700767 case SO_ERROR:
768 v.val = -sock_error(sk);
Eric Dumazet2a915252009-05-27 11:30:05 +0000769 if (v.val == 0)
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700770 v.val = xchg(&sk->sk_err_soft, 0);
771 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700772
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700773 case SO_OOBINLINE:
774 v.val = !!sock_flag(sk, SOCK_URGINLINE);
775 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900776
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700777 case SO_NO_CHECK:
778 v.val = sk->sk_no_check;
779 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700780
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700781 case SO_PRIORITY:
782 v.val = sk->sk_priority;
783 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900784
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700785 case SO_LINGER:
786 lv = sizeof(v.ling);
787 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER);
788 v.ling.l_linger = sk->sk_lingertime / HZ;
789 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900790
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700791 case SO_BSDCOMPAT:
792 sock_warn_obsolete_bsdism("getsockopt");
793 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700794
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700795 case SO_TIMESTAMP:
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700796 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
797 !sock_flag(sk, SOCK_RCVTSTAMPNS);
798 break;
799
800 case SO_TIMESTAMPNS:
801 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700802 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700803
Patrick Ohly20d49472009-02-12 05:03:38 +0000804 case SO_TIMESTAMPING:
805 v.val = 0;
806 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))
807 v.val |= SOF_TIMESTAMPING_TX_HARDWARE;
808 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))
809 v.val |= SOF_TIMESTAMPING_TX_SOFTWARE;
810 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE))
811 v.val |= SOF_TIMESTAMPING_RX_HARDWARE;
812 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE))
813 v.val |= SOF_TIMESTAMPING_RX_SOFTWARE;
814 if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE))
815 v.val |= SOF_TIMESTAMPING_SOFTWARE;
816 if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE))
817 v.val |= SOF_TIMESTAMPING_SYS_HARDWARE;
818 if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE))
819 v.val |= SOF_TIMESTAMPING_RAW_HARDWARE;
820 break;
821
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700822 case SO_RCVTIMEO:
Eric Dumazet2a915252009-05-27 11:30:05 +0000823 lv = sizeof(struct timeval);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700824 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
825 v.tm.tv_sec = 0;
826 v.tm.tv_usec = 0;
827 } else {
828 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
829 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700830 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700831 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700832
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700833 case SO_SNDTIMEO:
Eric Dumazet2a915252009-05-27 11:30:05 +0000834 lv = sizeof(struct timeval);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700835 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
836 v.tm.tv_sec = 0;
837 v.tm.tv_usec = 0;
838 } else {
839 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
840 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
841 }
842 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700843
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700844 case SO_RCVLOWAT:
845 v.val = sk->sk_rcvlowat;
846 break;
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700847
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700848 case SO_SNDLOWAT:
Eric Dumazet2a915252009-05-27 11:30:05 +0000849 v.val = 1;
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700850 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700851
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700852 case SO_PASSCRED:
853 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
854 break;
855
856 case SO_PEERCRED:
857 if (len > sizeof(sk->sk_peercred))
858 len = sizeof(sk->sk_peercred);
859 if (copy_to_user(optval, &sk->sk_peercred, len))
860 return -EFAULT;
861 goto lenout;
862
863 case SO_PEERNAME:
864 {
865 char address[128];
866
867 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
868 return -ENOTCONN;
869 if (lv < len)
870 return -EINVAL;
871 if (copy_to_user(optval, address, len))
872 return -EFAULT;
873 goto lenout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700874 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700875
876 /* Dubious BSD thing... Probably nobody even uses it, but
877 * the UNIX standard wants it for whatever reason... -DaveM
878 */
879 case SO_ACCEPTCONN:
880 v.val = sk->sk_state == TCP_LISTEN;
881 break;
882
883 case SO_PASSSEC:
884 v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0;
885 break;
886
887 case SO_PEERSEC:
888 return security_socket_getpeersec_stream(sock, optval, optlen, len);
889
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800890 case SO_MARK:
891 v.val = sk->sk_mark;
892 break;
893
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700894 default:
895 return -ENOPROTOOPT;
896 }
897
Linus Torvalds1da177e2005-04-16 15:20:36 -0700898 if (len > lv)
899 len = lv;
900 if (copy_to_user(optval, &v, len))
901 return -EFAULT;
902lenout:
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900903 if (put_user(len, optlen))
904 return -EFAULT;
905 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700906}
907
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700908/*
909 * Initialize an sk_lock.
910 *
911 * (We also register the sk_lock with the lock validator.)
912 */
Dave Jonesb6f99a22007-03-22 12:27:49 -0700913static inline void sock_lock_init(struct sock *sk)
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700914{
Peter Zijlstraed075362006-12-06 20:35:24 -0800915 sock_lock_init_class_and_name(sk,
916 af_family_slock_key_strings[sk->sk_family],
917 af_family_slock_keys + sk->sk_family,
918 af_family_key_strings[sk->sk_family],
919 af_family_keys + sk->sk_family);
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700920}
921
Pavel Emelyanovf1a6c4d2007-11-01 00:29:45 -0700922static void sock_copy(struct sock *nsk, const struct sock *osk)
923{
924#ifdef CONFIG_SECURITY_NETWORK
925 void *sptr = nsk->sk_security;
926#endif
927
928 memcpy(nsk, osk, osk->sk_prot->obj_size);
Pavel Emelyanovf1a6c4d2007-11-01 00:29:45 -0700929#ifdef CONFIG_SECURITY_NETWORK
930 nsk->sk_security = sptr;
931 security_sk_clone(osk, nsk);
932#endif
933}
934
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700935static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
936 int family)
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700937{
938 struct sock *sk;
939 struct kmem_cache *slab;
940
941 slab = prot->slab;
942 if (slab != NULL)
943 sk = kmem_cache_alloc(slab, priority);
944 else
945 sk = kmalloc(prot->obj_size, priority);
946
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700947 if (sk != NULL) {
948 if (security_sk_alloc(sk, family, priority))
949 goto out_free;
950
951 if (!try_module_get(prot->owner))
952 goto out_free_sec;
953 }
954
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700955 return sk;
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700956
957out_free_sec:
958 security_sk_free(sk);
959out_free:
960 if (slab != NULL)
961 kmem_cache_free(slab, sk);
962 else
963 kfree(sk);
964 return NULL;
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700965}
966
967static void sk_prot_free(struct proto *prot, struct sock *sk)
968{
969 struct kmem_cache *slab;
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700970 struct module *owner;
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700971
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700972 owner = prot->owner;
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700973 slab = prot->slab;
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700974
975 security_sk_free(sk);
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700976 if (slab != NULL)
977 kmem_cache_free(slab, sk);
978 else
979 kfree(sk);
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700980 module_put(owner);
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700981}
982
Linus Torvalds1da177e2005-04-16 15:20:36 -0700983/**
984 * sk_alloc - All socket objects are allocated here
Randy Dunlapc4ea43c2007-10-12 21:17:49 -0700985 * @net: the applicable net namespace
Pavel Pisa4dc3b162005-05-01 08:59:25 -0700986 * @family: protocol family
987 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
988 * @prot: struct proto associated with this new sock instance
Linus Torvalds1da177e2005-04-16 15:20:36 -0700989 */
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -0700990struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
Pavel Emelyanov6257ff22007-11-01 00:39:31 -0700991 struct proto *prot)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700992{
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700993 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700994
Pavel Emelyanov154adbc2007-11-01 00:38:43 -0700995 sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700996 if (sk) {
Pavel Emelyanov154adbc2007-11-01 00:38:43 -0700997 sk->sk_family = family;
998 /*
999 * See comment in struct sock definition to understand
1000 * why we need sk_prot_creator -acme
1001 */
1002 sk->sk_prot = sk->sk_prot_creator = prot;
1003 sock_lock_init(sk);
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001004 sock_net_set(sk, get_net(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001005 }
Frank Filza79af592005-09-27 15:23:38 -07001006
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -07001007 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001008}
Eric Dumazet2a915252009-05-27 11:30:05 +00001009EXPORT_SYMBOL(sk_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001010
1011void sk_free(struct sock *sk)
1012{
1013 struct sk_filter *filter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001014
1015 if (sk->sk_destruct)
1016 sk->sk_destruct(sk);
1017
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001018 filter = rcu_dereference(sk->sk_filter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001019 if (filter) {
Pavel Emelyanov309dd5f2007-10-17 21:21:51 -07001020 sk_filter_uncharge(sk, filter);
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001021 rcu_assign_pointer(sk->sk_filter, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 }
1023
Patrick Ohly20d49472009-02-12 05:03:38 +00001024 sock_disable_timestamp(sk, SOCK_TIMESTAMP);
1025 sock_disable_timestamp(sk, SOCK_TIMESTAMPING_RX_SOFTWARE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001026
1027 if (atomic_read(&sk->sk_omem_alloc))
1028 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001029 __func__, atomic_read(&sk->sk_omem_alloc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001030
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001031 put_net(sock_net(sk));
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -07001032 sk_prot_free(sk->sk_prot_creator, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001033}
Eric Dumazet2a915252009-05-27 11:30:05 +00001034EXPORT_SYMBOL(sk_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001035
Denis V. Lunevedf02082008-02-29 11:18:32 -08001036/*
1037 * Last sock_put should drop referrence to sk->sk_net. It has already
1038 * been dropped in sk_change_net. Taking referrence to stopping namespace
1039 * is not an option.
1040 * Take referrence to a socket to remove it from hash _alive_ and after that
1041 * destroy it in the context of init_net.
1042 */
1043void sk_release_kernel(struct sock *sk)
1044{
1045 if (sk == NULL || sk->sk_socket == NULL)
1046 return;
1047
1048 sock_hold(sk);
1049 sock_release(sk->sk_socket);
Denis V. Lunev65a18ec2008-04-16 01:59:46 -07001050 release_net(sock_net(sk));
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001051 sock_net_set(sk, get_net(&init_net));
Denis V. Lunevedf02082008-02-29 11:18:32 -08001052 sock_put(sk);
1053}
David S. Miller45af1752008-02-29 11:33:19 -08001054EXPORT_SYMBOL(sk_release_kernel);
Denis V. Lunevedf02082008-02-29 11:18:32 -08001055
Al Virodd0fc662005-10-07 07:46:04 +01001056struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001057{
Pavel Emelyanov8fd1d172007-11-01 00:37:32 -07001058 struct sock *newsk;
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001059
Pavel Emelyanov8fd1d172007-11-01 00:37:32 -07001060 newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001061 if (newsk != NULL) {
1062 struct sk_filter *filter;
1063
Venkat Yekkirala892c1412006-08-04 23:08:56 -07001064 sock_copy(newsk, sk);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001065
1066 /* SANITY */
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001067 get_net(sock_net(newsk));
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001068 sk_node_init(&newsk->sk_node);
1069 sock_lock_init(newsk);
1070 bh_lock_sock(newsk);
Eric Dumazetfa438cc2007-03-04 16:05:44 -08001071 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001072
1073 atomic_set(&newsk->sk_rmem_alloc, 0);
1074 atomic_set(&newsk->sk_wmem_alloc, 0);
1075 atomic_set(&newsk->sk_omem_alloc, 0);
1076 skb_queue_head_init(&newsk->sk_receive_queue);
1077 skb_queue_head_init(&newsk->sk_write_queue);
Chris Leech97fc2f02006-05-23 17:55:33 -07001078#ifdef CONFIG_NET_DMA
1079 skb_queue_head_init(&newsk->sk_async_wait_queue);
1080#endif
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001081
1082 rwlock_init(&newsk->sk_dst_lock);
1083 rwlock_init(&newsk->sk_callback_lock);
Peter Zijlstra443aef02007-07-19 01:49:00 -07001084 lockdep_set_class_and_name(&newsk->sk_callback_lock,
1085 af_callback_keys + newsk->sk_family,
1086 af_family_clock_key_strings[newsk->sk_family]);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001087
1088 newsk->sk_dst_cache = NULL;
1089 newsk->sk_wmem_queued = 0;
1090 newsk->sk_forward_alloc = 0;
1091 newsk->sk_send_head = NULL;
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001092 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1093
1094 sock_reset_flag(newsk, SOCK_DONE);
1095 skb_queue_head_init(&newsk->sk_error_queue);
1096
1097 filter = newsk->sk_filter;
1098 if (filter != NULL)
1099 sk_filter_charge(newsk, filter);
1100
1101 if (unlikely(xfrm_sk_clone_policy(newsk))) {
1102 /* It is still raw copy of parent, so invalidate
1103 * destructor and make plain sk_free() */
1104 newsk->sk_destruct = NULL;
1105 sk_free(newsk);
1106 newsk = NULL;
1107 goto out;
1108 }
1109
1110 newsk->sk_err = 0;
1111 newsk->sk_priority = 0;
1112 atomic_set(&newsk->sk_refcnt, 2);
1113
1114 /*
1115 * Increment the counter in the same struct proto as the master
1116 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1117 * is the same as sk->sk_prot->socks, as this field was copied
1118 * with memcpy).
1119 *
1120 * This _changes_ the previous behaviour, where
1121 * tcp_create_openreq_child always was incrementing the
1122 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1123 * to be taken into account in all callers. -acme
1124 */
1125 sk_refcnt_debug_inc(newsk);
David S. Miller972692e2008-06-17 22:41:38 -07001126 sk_set_socket(newsk, NULL);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001127 newsk->sk_sleep = NULL;
1128
1129 if (newsk->sk_prot->sockets_allocated)
Eric Dumazet17483762008-11-25 21:16:35 -08001130 percpu_counter_inc(newsk->sk_prot->sockets_allocated);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001131 }
1132out:
1133 return newsk;
1134}
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001135EXPORT_SYMBOL_GPL(sk_clone);
1136
Andi Kleen99580892007-04-20 17:12:43 -07001137void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1138{
1139 __sk_dst_set(sk, dst);
1140 sk->sk_route_caps = dst->dev->features;
1141 if (sk->sk_route_caps & NETIF_F_GSO)
Herbert Xu4fcd6b92007-05-31 22:15:50 -07001142 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
Andi Kleen99580892007-04-20 17:12:43 -07001143 if (sk_can_gso(sk)) {
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001144 if (dst->header_len) {
Andi Kleen99580892007-04-20 17:12:43 -07001145 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001146 } else {
Andi Kleen99580892007-04-20 17:12:43 -07001147 sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001148 sk->sk_gso_max_size = dst->dev->gso_max_size;
1149 }
Andi Kleen99580892007-04-20 17:12:43 -07001150 }
1151}
1152EXPORT_SYMBOL_GPL(sk_setup_caps);
1153
Linus Torvalds1da177e2005-04-16 15:20:36 -07001154void __init sk_init(void)
1155{
1156 if (num_physpages <= 4096) {
1157 sysctl_wmem_max = 32767;
1158 sysctl_rmem_max = 32767;
1159 sysctl_wmem_default = 32767;
1160 sysctl_rmem_default = 32767;
1161 } else if (num_physpages >= 131072) {
1162 sysctl_wmem_max = 131071;
1163 sysctl_rmem_max = 131071;
1164 }
1165}
1166
1167/*
1168 * Simple resource managers for sockets.
1169 */
1170
1171
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001172/*
1173 * Write buffer destructor automatically called from kfree_skb.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001174 */
1175void sock_wfree(struct sk_buff *skb)
1176{
1177 struct sock *sk = skb->sk;
1178
1179 /* In case it might be waiting for more memory. */
1180 atomic_sub(skb->truesize, &sk->sk_wmem_alloc);
1181 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
1182 sk->sk_write_space(sk);
1183 sock_put(sk);
1184}
Eric Dumazet2a915252009-05-27 11:30:05 +00001185EXPORT_SYMBOL(sock_wfree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001186
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001187/*
1188 * Read buffer destructor automatically called from kfree_skb.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001189 */
1190void sock_rfree(struct sk_buff *skb)
1191{
1192 struct sock *sk = skb->sk;
1193
1194 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001195 sk_mem_uncharge(skb->sk, skb->truesize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001196}
Eric Dumazet2a915252009-05-27 11:30:05 +00001197EXPORT_SYMBOL(sock_rfree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001198
1199
1200int sock_i_uid(struct sock *sk)
1201{
1202 int uid;
1203
1204 read_lock(&sk->sk_callback_lock);
1205 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1206 read_unlock(&sk->sk_callback_lock);
1207 return uid;
1208}
Eric Dumazet2a915252009-05-27 11:30:05 +00001209EXPORT_SYMBOL(sock_i_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001210
1211unsigned long sock_i_ino(struct sock *sk)
1212{
1213 unsigned long ino;
1214
1215 read_lock(&sk->sk_callback_lock);
1216 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1217 read_unlock(&sk->sk_callback_lock);
1218 return ino;
1219}
Eric Dumazet2a915252009-05-27 11:30:05 +00001220EXPORT_SYMBOL(sock_i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001221
1222/*
1223 * Allocate a skb from the socket's send buffer.
1224 */
Victor Fusco86a76ca2005-07-08 14:57:47 -07001225struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
Al Virodd0fc662005-10-07 07:46:04 +01001226 gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001227{
1228 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
Eric Dumazet2a915252009-05-27 11:30:05 +00001229 struct sk_buff *skb = alloc_skb(size, priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001230 if (skb) {
1231 skb_set_owner_w(skb, sk);
1232 return skb;
1233 }
1234 }
1235 return NULL;
1236}
Eric Dumazet2a915252009-05-27 11:30:05 +00001237EXPORT_SYMBOL(sock_wmalloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001238
1239/*
1240 * Allocate a skb from the socket's receive buffer.
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001241 */
Victor Fusco86a76ca2005-07-08 14:57:47 -07001242struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
Al Virodd0fc662005-10-07 07:46:04 +01001243 gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244{
1245 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1246 struct sk_buff *skb = alloc_skb(size, priority);
1247 if (skb) {
1248 skb_set_owner_r(skb, sk);
1249 return skb;
1250 }
1251 }
1252 return NULL;
1253}
1254
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001255/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256 * Allocate a memory block from the socket's option memory buffer.
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001257 */
Al Virodd0fc662005-10-07 07:46:04 +01001258void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001259{
1260 if ((unsigned)size <= sysctl_optmem_max &&
1261 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1262 void *mem;
1263 /* First do the add, to avoid the race if kmalloc
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001264 * might sleep.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001265 */
1266 atomic_add(size, &sk->sk_omem_alloc);
1267 mem = kmalloc(size, priority);
1268 if (mem)
1269 return mem;
1270 atomic_sub(size, &sk->sk_omem_alloc);
1271 }
1272 return NULL;
1273}
Eric Dumazet2a915252009-05-27 11:30:05 +00001274EXPORT_SYMBOL(sock_kmalloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001275
1276/*
1277 * Free an option memory block.
1278 */
1279void sock_kfree_s(struct sock *sk, void *mem, int size)
1280{
1281 kfree(mem);
1282 atomic_sub(size, &sk->sk_omem_alloc);
1283}
Eric Dumazet2a915252009-05-27 11:30:05 +00001284EXPORT_SYMBOL(sock_kfree_s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285
1286/* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1287 I think, these locks should be removed for datagram sockets.
1288 */
Eric Dumazet2a915252009-05-27 11:30:05 +00001289static long sock_wait_for_wmem(struct sock *sk, long timeo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001290{
1291 DEFINE_WAIT(wait);
1292
1293 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1294 for (;;) {
1295 if (!timeo)
1296 break;
1297 if (signal_pending(current))
1298 break;
1299 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1300 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1301 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1302 break;
1303 if (sk->sk_shutdown & SEND_SHUTDOWN)
1304 break;
1305 if (sk->sk_err)
1306 break;
1307 timeo = schedule_timeout(timeo);
1308 }
1309 finish_wait(sk->sk_sleep, &wait);
1310 return timeo;
1311}
1312
1313
1314/*
1315 * Generic send/receive buffer handlers
1316 */
1317
Herbert Xu4cc7f682009-02-04 16:55:54 -08001318struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1319 unsigned long data_len, int noblock,
1320 int *errcode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001321{
1322 struct sk_buff *skb;
Al Viro7d877f32005-10-21 03:20:43 -04001323 gfp_t gfp_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001324 long timeo;
1325 int err;
1326
1327 gfp_mask = sk->sk_allocation;
1328 if (gfp_mask & __GFP_WAIT)
1329 gfp_mask |= __GFP_REPEAT;
1330
1331 timeo = sock_sndtimeo(sk, noblock);
1332 while (1) {
1333 err = sock_error(sk);
1334 if (err != 0)
1335 goto failure;
1336
1337 err = -EPIPE;
1338 if (sk->sk_shutdown & SEND_SHUTDOWN)
1339 goto failure;
1340
1341 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
Larry Woodmandb38c1792006-11-03 16:05:45 -08001342 skb = alloc_skb(header_len, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343 if (skb) {
1344 int npages;
1345 int i;
1346
1347 /* No pages, we're done... */
1348 if (!data_len)
1349 break;
1350
1351 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1352 skb->truesize += data_len;
1353 skb_shinfo(skb)->nr_frags = npages;
1354 for (i = 0; i < npages; i++) {
1355 struct page *page;
1356 skb_frag_t *frag;
1357
1358 page = alloc_pages(sk->sk_allocation, 0);
1359 if (!page) {
1360 err = -ENOBUFS;
1361 skb_shinfo(skb)->nr_frags = i;
1362 kfree_skb(skb);
1363 goto failure;
1364 }
1365
1366 frag = &skb_shinfo(skb)->frags[i];
1367 frag->page = page;
1368 frag->page_offset = 0;
1369 frag->size = (data_len >= PAGE_SIZE ?
1370 PAGE_SIZE :
1371 data_len);
1372 data_len -= PAGE_SIZE;
1373 }
1374
1375 /* Full success... */
1376 break;
1377 }
1378 err = -ENOBUFS;
1379 goto failure;
1380 }
1381 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1382 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1383 err = -EAGAIN;
1384 if (!timeo)
1385 goto failure;
1386 if (signal_pending(current))
1387 goto interrupted;
1388 timeo = sock_wait_for_wmem(sk, timeo);
1389 }
1390
1391 skb_set_owner_w(skb, sk);
1392 return skb;
1393
1394interrupted:
1395 err = sock_intr_errno(timeo);
1396failure:
1397 *errcode = err;
1398 return NULL;
1399}
Herbert Xu4cc7f682009-02-04 16:55:54 -08001400EXPORT_SYMBOL(sock_alloc_send_pskb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001402struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001403 int noblock, int *errcode)
1404{
1405 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1406}
Eric Dumazet2a915252009-05-27 11:30:05 +00001407EXPORT_SYMBOL(sock_alloc_send_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001408
1409static void __lock_sock(struct sock *sk)
1410{
1411 DEFINE_WAIT(wait);
1412
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001413 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001414 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1415 TASK_UNINTERRUPTIBLE);
1416 spin_unlock_bh(&sk->sk_lock.slock);
1417 schedule();
1418 spin_lock_bh(&sk->sk_lock.slock);
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001419 if (!sock_owned_by_user(sk))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001420 break;
1421 }
1422 finish_wait(&sk->sk_lock.wq, &wait);
1423}
1424
1425static void __release_sock(struct sock *sk)
1426{
1427 struct sk_buff *skb = sk->sk_backlog.head;
1428
1429 do {
1430 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1431 bh_unlock_sock(sk);
1432
1433 do {
1434 struct sk_buff *next = skb->next;
1435
1436 skb->next = NULL;
Peter Zijlstrac57943a2008-10-07 14:18:42 -07001437 sk_backlog_rcv(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001438
1439 /*
1440 * We are in process context here with softirqs
1441 * disabled, use cond_resched_softirq() to preempt.
1442 * This is safe to do because we've taken the backlog
1443 * queue private:
1444 */
1445 cond_resched_softirq();
1446
1447 skb = next;
1448 } while (skb != NULL);
1449
1450 bh_lock_sock(sk);
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001451 } while ((skb = sk->sk_backlog.head) != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001452}
1453
1454/**
1455 * sk_wait_data - wait for data to arrive at sk_receive_queue
Pavel Pisa4dc3b162005-05-01 08:59:25 -07001456 * @sk: sock to wait on
1457 * @timeo: for how long
Linus Torvalds1da177e2005-04-16 15:20:36 -07001458 *
1459 * Now socket state including sk->sk_err is changed only under lock,
1460 * hence we may omit checks after joining wait queue.
1461 * We check receive queue before schedule() only as optimization;
1462 * it is very likely that release_sock() added new data.
1463 */
1464int sk_wait_data(struct sock *sk, long *timeo)
1465{
1466 int rc;
1467 DEFINE_WAIT(wait);
1468
1469 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1470 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1471 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1472 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1473 finish_wait(sk->sk_sleep, &wait);
1474 return rc;
1475}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001476EXPORT_SYMBOL(sk_wait_data);
1477
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001478/**
1479 * __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
1480 * @sk: socket
1481 * @size: memory size to allocate
1482 * @kind: allocation type
1483 *
1484 * If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
1485 * rmem allocation. This function assumes that protocols which have
1486 * memory_pressure use sk_wmem_queued as write buffer accounting.
1487 */
1488int __sk_mem_schedule(struct sock *sk, int size, int kind)
1489{
1490 struct proto *prot = sk->sk_prot;
1491 int amt = sk_mem_pages(size);
1492 int allocated;
1493
1494 sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
1495 allocated = atomic_add_return(amt, prot->memory_allocated);
1496
1497 /* Under limit. */
1498 if (allocated <= prot->sysctl_mem[0]) {
1499 if (prot->memory_pressure && *prot->memory_pressure)
1500 *prot->memory_pressure = 0;
1501 return 1;
1502 }
1503
1504 /* Under pressure. */
1505 if (allocated > prot->sysctl_mem[1])
1506 if (prot->enter_memory_pressure)
Pavel Emelyanov5c52ba12008-07-16 20:28:10 -07001507 prot->enter_memory_pressure(sk);
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001508
1509 /* Over hard limit. */
1510 if (allocated > prot->sysctl_mem[2])
1511 goto suppress_allocation;
1512
1513 /* guarantee minimum buffer size under pressure */
1514 if (kind == SK_MEM_RECV) {
1515 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
1516 return 1;
1517 } else { /* SK_MEM_SEND */
1518 if (sk->sk_type == SOCK_STREAM) {
1519 if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
1520 return 1;
1521 } else if (atomic_read(&sk->sk_wmem_alloc) <
1522 prot->sysctl_wmem[0])
1523 return 1;
1524 }
1525
1526 if (prot->memory_pressure) {
Eric Dumazet17483762008-11-25 21:16:35 -08001527 int alloc;
1528
1529 if (!*prot->memory_pressure)
1530 return 1;
1531 alloc = percpu_counter_read_positive(prot->sockets_allocated);
1532 if (prot->sysctl_mem[2] > alloc *
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001533 sk_mem_pages(sk->sk_wmem_queued +
1534 atomic_read(&sk->sk_rmem_alloc) +
1535 sk->sk_forward_alloc))
1536 return 1;
1537 }
1538
1539suppress_allocation:
1540
1541 if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
1542 sk_stream_moderate_sndbuf(sk);
1543
1544 /* Fail only if socket is _under_ its sndbuf.
1545 * In this case we cannot block, so that we have to fail.
1546 */
1547 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
1548 return 1;
1549 }
1550
1551 /* Alas. Undo changes. */
1552 sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
1553 atomic_sub(amt, prot->memory_allocated);
1554 return 0;
1555}
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001556EXPORT_SYMBOL(__sk_mem_schedule);
1557
1558/**
1559 * __sk_reclaim - reclaim memory_allocated
1560 * @sk: socket
1561 */
1562void __sk_mem_reclaim(struct sock *sk)
1563{
1564 struct proto *prot = sk->sk_prot;
1565
Eric Dumazet680a5a52007-12-31 15:00:50 -08001566 atomic_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001567 prot->memory_allocated);
1568 sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
1569
1570 if (prot->memory_pressure && *prot->memory_pressure &&
1571 (atomic_read(prot->memory_allocated) < prot->sysctl_mem[0]))
1572 *prot->memory_pressure = 0;
1573}
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001574EXPORT_SYMBOL(__sk_mem_reclaim);
1575
1576
Linus Torvalds1da177e2005-04-16 15:20:36 -07001577/*
1578 * Set of default routines for initialising struct proto_ops when
1579 * the protocol does not support a particular function. In certain
1580 * cases where it makes no sense for a protocol to have a "do nothing"
1581 * function, some default processing is provided.
1582 */
1583
1584int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1585{
1586 return -EOPNOTSUPP;
1587}
Eric Dumazet2a915252009-05-27 11:30:05 +00001588EXPORT_SYMBOL(sock_no_bind);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001589
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001590int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001591 int len, int flags)
1592{
1593 return -EOPNOTSUPP;
1594}
Eric Dumazet2a915252009-05-27 11:30:05 +00001595EXPORT_SYMBOL(sock_no_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001596
1597int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1598{
1599 return -EOPNOTSUPP;
1600}
Eric Dumazet2a915252009-05-27 11:30:05 +00001601EXPORT_SYMBOL(sock_no_socketpair);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001602
1603int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1604{
1605 return -EOPNOTSUPP;
1606}
Eric Dumazet2a915252009-05-27 11:30:05 +00001607EXPORT_SYMBOL(sock_no_accept);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001608
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001609int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001610 int *len, int peer)
1611{
1612 return -EOPNOTSUPP;
1613}
Eric Dumazet2a915252009-05-27 11:30:05 +00001614EXPORT_SYMBOL(sock_no_getname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001615
Eric Dumazet2a915252009-05-27 11:30:05 +00001616unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001617{
1618 return 0;
1619}
Eric Dumazet2a915252009-05-27 11:30:05 +00001620EXPORT_SYMBOL(sock_no_poll);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001621
1622int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1623{
1624 return -EOPNOTSUPP;
1625}
Eric Dumazet2a915252009-05-27 11:30:05 +00001626EXPORT_SYMBOL(sock_no_ioctl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001627
1628int sock_no_listen(struct socket *sock, int backlog)
1629{
1630 return -EOPNOTSUPP;
1631}
Eric Dumazet2a915252009-05-27 11:30:05 +00001632EXPORT_SYMBOL(sock_no_listen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001633
1634int sock_no_shutdown(struct socket *sock, int how)
1635{
1636 return -EOPNOTSUPP;
1637}
Eric Dumazet2a915252009-05-27 11:30:05 +00001638EXPORT_SYMBOL(sock_no_shutdown);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001639
1640int sock_no_setsockopt(struct socket *sock, int level, int optname,
1641 char __user *optval, int optlen)
1642{
1643 return -EOPNOTSUPP;
1644}
Eric Dumazet2a915252009-05-27 11:30:05 +00001645EXPORT_SYMBOL(sock_no_setsockopt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001646
1647int sock_no_getsockopt(struct socket *sock, int level, int optname,
1648 char __user *optval, int __user *optlen)
1649{
1650 return -EOPNOTSUPP;
1651}
Eric Dumazet2a915252009-05-27 11:30:05 +00001652EXPORT_SYMBOL(sock_no_getsockopt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001653
1654int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1655 size_t len)
1656{
1657 return -EOPNOTSUPP;
1658}
Eric Dumazet2a915252009-05-27 11:30:05 +00001659EXPORT_SYMBOL(sock_no_sendmsg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1662 size_t len, int flags)
1663{
1664 return -EOPNOTSUPP;
1665}
Eric Dumazet2a915252009-05-27 11:30:05 +00001666EXPORT_SYMBOL(sock_no_recvmsg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001667
1668int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1669{
1670 /* Mirror missing mmap method error code */
1671 return -ENODEV;
1672}
Eric Dumazet2a915252009-05-27 11:30:05 +00001673EXPORT_SYMBOL(sock_no_mmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001674
1675ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1676{
1677 ssize_t res;
1678 struct msghdr msg = {.msg_flags = flags};
1679 struct kvec iov;
1680 char *kaddr = kmap(page);
1681 iov.iov_base = kaddr + offset;
1682 iov.iov_len = size;
1683 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1684 kunmap(page);
1685 return res;
1686}
Eric Dumazet2a915252009-05-27 11:30:05 +00001687EXPORT_SYMBOL(sock_no_sendpage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001688
1689/*
1690 * Default Socket Callbacks
1691 */
1692
1693static void sock_def_wakeup(struct sock *sk)
1694{
1695 read_lock(&sk->sk_callback_lock);
1696 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
1697 wake_up_interruptible_all(sk->sk_sleep);
1698 read_unlock(&sk->sk_callback_lock);
1699}
1700
1701static void sock_def_error_report(struct sock *sk)
1702{
1703 read_lock(&sk->sk_callback_lock);
1704 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
Davide Libenzi37e55402009-03-31 15:24:21 -07001705 wake_up_interruptible_poll(sk->sk_sleep, POLLERR);
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001706 sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001707 read_unlock(&sk->sk_callback_lock);
1708}
1709
1710static void sock_def_readable(struct sock *sk, int len)
1711{
1712 read_lock(&sk->sk_callback_lock);
1713 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
Davide Libenzi37e55402009-03-31 15:24:21 -07001714 wake_up_interruptible_sync_poll(sk->sk_sleep, POLLIN |
1715 POLLRDNORM | POLLRDBAND);
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001716 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001717 read_unlock(&sk->sk_callback_lock);
1718}
1719
1720static void sock_def_write_space(struct sock *sk)
1721{
1722 read_lock(&sk->sk_callback_lock);
1723
1724 /* Do not wake up a writer until he can make "significant"
1725 * progress. --DaveM
1726 */
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001727 if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001728 if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
Davide Libenzi37e55402009-03-31 15:24:21 -07001729 wake_up_interruptible_sync_poll(sk->sk_sleep, POLLOUT |
1730 POLLWRNORM | POLLWRBAND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001731
1732 /* Should agree with poll, otherwise some programs break */
1733 if (sock_writeable(sk))
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001734 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001735 }
1736
1737 read_unlock(&sk->sk_callback_lock);
1738}
1739
1740static void sock_def_destruct(struct sock *sk)
1741{
Jesper Juhla51482b2005-11-08 09:41:34 -08001742 kfree(sk->sk_protinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001743}
1744
1745void sk_send_sigurg(struct sock *sk)
1746{
1747 if (sk->sk_socket && sk->sk_socket->file)
1748 if (send_sigurg(&sk->sk_socket->file->f_owner))
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001749 sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001750}
Eric Dumazet2a915252009-05-27 11:30:05 +00001751EXPORT_SYMBOL(sk_send_sigurg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001752
1753void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1754 unsigned long expires)
1755{
1756 if (!mod_timer(timer, expires))
1757 sock_hold(sk);
1758}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001759EXPORT_SYMBOL(sk_reset_timer);
1760
1761void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1762{
1763 if (timer_pending(timer) && del_timer(timer))
1764 __sock_put(sk);
1765}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001766EXPORT_SYMBOL(sk_stop_timer);
1767
1768void sock_init_data(struct socket *sock, struct sock *sk)
1769{
1770 skb_queue_head_init(&sk->sk_receive_queue);
1771 skb_queue_head_init(&sk->sk_write_queue);
1772 skb_queue_head_init(&sk->sk_error_queue);
Chris Leech97fc2f02006-05-23 17:55:33 -07001773#ifdef CONFIG_NET_DMA
1774 skb_queue_head_init(&sk->sk_async_wait_queue);
1775#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001776
1777 sk->sk_send_head = NULL;
1778
1779 init_timer(&sk->sk_timer);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001780
Linus Torvalds1da177e2005-04-16 15:20:36 -07001781 sk->sk_allocation = GFP_KERNEL;
1782 sk->sk_rcvbuf = sysctl_rmem_default;
1783 sk->sk_sndbuf = sysctl_wmem_default;
1784 sk->sk_state = TCP_CLOSE;
David S. Miller972692e2008-06-17 22:41:38 -07001785 sk_set_socket(sk, sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001786
1787 sock_set_flag(sk, SOCK_ZAPPED);
1788
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001789 if (sock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001790 sk->sk_type = sock->type;
1791 sk->sk_sleep = &sock->wait;
1792 sock->sk = sk;
1793 } else
1794 sk->sk_sleep = NULL;
1795
1796 rwlock_init(&sk->sk_dst_lock);
1797 rwlock_init(&sk->sk_callback_lock);
Peter Zijlstra443aef02007-07-19 01:49:00 -07001798 lockdep_set_class_and_name(&sk->sk_callback_lock,
1799 af_callback_keys + sk->sk_family,
1800 af_family_clock_key_strings[sk->sk_family]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801
1802 sk->sk_state_change = sock_def_wakeup;
1803 sk->sk_data_ready = sock_def_readable;
1804 sk->sk_write_space = sock_def_write_space;
1805 sk->sk_error_report = sock_def_error_report;
1806 sk->sk_destruct = sock_def_destruct;
1807
1808 sk->sk_sndmsg_page = NULL;
1809 sk->sk_sndmsg_off = 0;
1810
1811 sk->sk_peercred.pid = 0;
1812 sk->sk_peercred.uid = -1;
1813 sk->sk_peercred.gid = -1;
1814 sk->sk_write_pending = 0;
1815 sk->sk_rcvlowat = 1;
1816 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
1817 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
1818
Eric Dumazetf37f0af2008-04-13 21:39:26 -07001819 sk->sk_stamp = ktime_set(-1L, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001820
1821 atomic_set(&sk->sk_refcnt, 1);
Wang Chen33c732c2007-11-13 20:30:01 -08001822 atomic_set(&sk->sk_drops, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001823}
Eric Dumazet2a915252009-05-27 11:30:05 +00001824EXPORT_SYMBOL(sock_init_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001825
Harvey Harrisonb5606c22008-02-13 15:03:16 -08001826void lock_sock_nested(struct sock *sk, int subclass)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001827{
1828 might_sleep();
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001829 spin_lock_bh(&sk->sk_lock.slock);
John Heffnerd2e91172007-09-12 10:44:19 +02001830 if (sk->sk_lock.owned)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001831 __lock_sock(sk);
John Heffnerd2e91172007-09-12 10:44:19 +02001832 sk->sk_lock.owned = 1;
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001833 spin_unlock(&sk->sk_lock.slock);
1834 /*
1835 * The sk_lock has mutex_lock() semantics here:
1836 */
Peter Zijlstrafcc70d52006-11-08 22:44:35 -08001837 mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001838 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839}
Peter Zijlstrafcc70d52006-11-08 22:44:35 -08001840EXPORT_SYMBOL(lock_sock_nested);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001841
Harvey Harrisonb5606c22008-02-13 15:03:16 -08001842void release_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001843{
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001844 /*
1845 * The sk_lock has mutex_unlock() semantics:
1846 */
1847 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
1848
1849 spin_lock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001850 if (sk->sk_backlog.tail)
1851 __release_sock(sk);
John Heffnerd2e91172007-09-12 10:44:19 +02001852 sk->sk_lock.owned = 0;
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001853 if (waitqueue_active(&sk->sk_lock.wq))
1854 wake_up(&sk->sk_lock.wq);
1855 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001856}
1857EXPORT_SYMBOL(release_sock);
1858
1859int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001860{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001861 struct timeval tv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001862 if (!sock_flag(sk, SOCK_TIMESTAMP))
Patrick Ohly20d49472009-02-12 05:03:38 +00001863 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001864 tv = ktime_to_timeval(sk->sk_stamp);
1865 if (tv.tv_sec == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001866 return -ENOENT;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001867 if (tv.tv_sec == 0) {
1868 sk->sk_stamp = ktime_get_real();
1869 tv = ktime_to_timeval(sk->sk_stamp);
1870 }
1871 return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001872}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001873EXPORT_SYMBOL(sock_get_timestamp);
1874
Eric Dumazetae40eb12007-03-18 17:33:16 -07001875int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
1876{
1877 struct timespec ts;
1878 if (!sock_flag(sk, SOCK_TIMESTAMP))
Patrick Ohly20d49472009-02-12 05:03:38 +00001879 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
Eric Dumazetae40eb12007-03-18 17:33:16 -07001880 ts = ktime_to_timespec(sk->sk_stamp);
1881 if (ts.tv_sec == -1)
1882 return -ENOENT;
1883 if (ts.tv_sec == 0) {
1884 sk->sk_stamp = ktime_get_real();
1885 ts = ktime_to_timespec(sk->sk_stamp);
1886 }
1887 return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
1888}
1889EXPORT_SYMBOL(sock_get_timestampns);
1890
Patrick Ohly20d49472009-02-12 05:03:38 +00001891void sock_enable_timestamp(struct sock *sk, int flag)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001892{
Patrick Ohly20d49472009-02-12 05:03:38 +00001893 if (!sock_flag(sk, flag)) {
1894 sock_set_flag(sk, flag);
1895 /*
1896 * we just set one of the two flags which require net
1897 * time stamping, but time stamping might have been on
1898 * already because of the other one
1899 */
1900 if (!sock_flag(sk,
1901 flag == SOCK_TIMESTAMP ?
1902 SOCK_TIMESTAMPING_RX_SOFTWARE :
1903 SOCK_TIMESTAMP))
1904 net_enable_timestamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905 }
1906}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907
1908/*
1909 * Get a socket option on an socket.
1910 *
1911 * FIX: POSIX 1003.1g is very ambiguous here. It states that
1912 * asynchronous errors should be reported by getsockopt. We assume
1913 * this means if you specify SO_ERROR (otherwise whats the point of it).
1914 */
1915int sock_common_getsockopt(struct socket *sock, int level, int optname,
1916 char __user *optval, int __user *optlen)
1917{
1918 struct sock *sk = sock->sk;
1919
1920 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1921}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001922EXPORT_SYMBOL(sock_common_getsockopt);
1923
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001924#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001925int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
1926 char __user *optval, int __user *optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001927{
1928 struct sock *sk = sock->sk;
1929
Johannes Berg1e51f952007-03-06 13:44:06 -08001930 if (sk->sk_prot->compat_getsockopt != NULL)
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001931 return sk->sk_prot->compat_getsockopt(sk, level, optname,
1932 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001933 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1934}
1935EXPORT_SYMBOL(compat_sock_common_getsockopt);
1936#endif
1937
Linus Torvalds1da177e2005-04-16 15:20:36 -07001938int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
1939 struct msghdr *msg, size_t size, int flags)
1940{
1941 struct sock *sk = sock->sk;
1942 int addr_len = 0;
1943 int err;
1944
1945 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
1946 flags & ~MSG_DONTWAIT, &addr_len);
1947 if (err >= 0)
1948 msg->msg_namelen = addr_len;
1949 return err;
1950}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001951EXPORT_SYMBOL(sock_common_recvmsg);
1952
1953/*
1954 * Set socket options on an inet socket.
1955 */
1956int sock_common_setsockopt(struct socket *sock, int level, int optname,
1957 char __user *optval, int optlen)
1958{
1959 struct sock *sk = sock->sk;
1960
1961 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1962}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001963EXPORT_SYMBOL(sock_common_setsockopt);
1964
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001965#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001966int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
1967 char __user *optval, int optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001968{
1969 struct sock *sk = sock->sk;
1970
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001971 if (sk->sk_prot->compat_setsockopt != NULL)
1972 return sk->sk_prot->compat_setsockopt(sk, level, optname,
1973 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001974 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
1975}
1976EXPORT_SYMBOL(compat_sock_common_setsockopt);
1977#endif
1978
Linus Torvalds1da177e2005-04-16 15:20:36 -07001979void sk_common_release(struct sock *sk)
1980{
1981 if (sk->sk_prot->destroy)
1982 sk->sk_prot->destroy(sk);
1983
1984 /*
1985 * Observation: when sock_common_release is called, processes have
1986 * no access to socket. But net still has.
1987 * Step one, detach it from networking:
1988 *
1989 * A. Remove from hash tables.
1990 */
1991
1992 sk->sk_prot->unhash(sk);
1993
1994 /*
1995 * In this point socket cannot receive new packets, but it is possible
1996 * that some packets are in flight because some CPU runs receiver and
1997 * did hash table lookup before we unhashed socket. They will achieve
1998 * receive queue and will be purged by socket destructor.
1999 *
2000 * Also we still have packets pending on receive queue and probably,
2001 * our own packets waiting in device queues. sock_destroy will drain
2002 * receive queue, but transmitted packets will delay socket destruction
2003 * until the last reference will be released.
2004 */
2005
2006 sock_orphan(sk);
2007
2008 xfrm_sk_free_policy(sk);
2009
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07002010 sk_refcnt_debug_release(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002011 sock_put(sk);
2012}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002013EXPORT_SYMBOL(sk_common_release);
2014
2015static DEFINE_RWLOCK(proto_list_lock);
2016static LIST_HEAD(proto_list);
2017
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002018#ifdef CONFIG_PROC_FS
2019#define PROTO_INUSE_NR 64 /* should be enough for the first time */
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002020struct prot_inuse {
2021 int val[PROTO_INUSE_NR];
2022};
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002023
2024static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
Pavel Emelyanov70ee1152008-03-31 19:42:16 -07002025
2026#ifdef CONFIG_NET_NS
2027void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2028{
2029 int cpu = smp_processor_id();
2030 per_cpu_ptr(net->core.inuse, cpu)->val[prot->inuse_idx] += val;
2031}
2032EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2033
2034int sock_prot_inuse_get(struct net *net, struct proto *prot)
2035{
2036 int cpu, idx = prot->inuse_idx;
2037 int res = 0;
2038
2039 for_each_possible_cpu(cpu)
2040 res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2041
2042 return res >= 0 ? res : 0;
2043}
2044EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2045
2046static int sock_inuse_init_net(struct net *net)
2047{
2048 net->core.inuse = alloc_percpu(struct prot_inuse);
2049 return net->core.inuse ? 0 : -ENOMEM;
2050}
2051
2052static void sock_inuse_exit_net(struct net *net)
2053{
2054 free_percpu(net->core.inuse);
2055}
2056
2057static struct pernet_operations net_inuse_ops = {
2058 .init = sock_inuse_init_net,
2059 .exit = sock_inuse_exit_net,
2060};
2061
2062static __init int net_inuse_init(void)
2063{
2064 if (register_pernet_subsys(&net_inuse_ops))
2065 panic("Cannot initialize net inuse counters");
2066
2067 return 0;
2068}
2069
2070core_initcall(net_inuse_init);
2071#else
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002072static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2073
Pavel Emelyanovc29a0bc2008-03-31 19:41:46 -07002074void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002075{
2076 __get_cpu_var(prot_inuse).val[prot->inuse_idx] += val;
2077}
2078EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2079
Pavel Emelyanovc29a0bc2008-03-31 19:41:46 -07002080int sock_prot_inuse_get(struct net *net, struct proto *prot)
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002081{
2082 int cpu, idx = prot->inuse_idx;
2083 int res = 0;
2084
2085 for_each_possible_cpu(cpu)
2086 res += per_cpu(prot_inuse, cpu).val[idx];
2087
2088 return res >= 0 ? res : 0;
2089}
2090EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
Pavel Emelyanov70ee1152008-03-31 19:42:16 -07002091#endif
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002092
2093static void assign_proto_idx(struct proto *prot)
2094{
2095 prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2096
2097 if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
2098 printk(KERN_ERR "PROTO_INUSE_NR exhausted\n");
2099 return;
2100 }
2101
2102 set_bit(prot->inuse_idx, proto_inuse_idx);
2103}
2104
2105static void release_proto_idx(struct proto *prot)
2106{
2107 if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2108 clear_bit(prot->inuse_idx, proto_inuse_idx);
2109}
2110#else
2111static inline void assign_proto_idx(struct proto *prot)
2112{
2113}
2114
2115static inline void release_proto_idx(struct proto *prot)
2116{
2117}
2118#endif
2119
Linus Torvalds1da177e2005-04-16 15:20:36 -07002120int proto_register(struct proto *prot, int alloc_slab)
2121{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002122 if (alloc_slab) {
2123 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
Eric Dumazet271b72c2008-10-29 02:11:14 -07002124 SLAB_HWCACHE_ALIGN | prot->slab_flags,
2125 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002126
2127 if (prot->slab == NULL) {
2128 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
2129 prot->name);
Pavel Emelyanov60e76632008-03-28 16:39:10 -07002130 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002131 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002132
2133 if (prot->rsk_prot != NULL) {
2134 static const char mask[] = "request_sock_%s";
2135
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002136 prot->rsk_prot->slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
2137 if (prot->rsk_prot->slab_name == NULL)
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002138 goto out_free_sock_slab;
2139
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002140 sprintf(prot->rsk_prot->slab_name, mask, prot->name);
2141 prot->rsk_prot->slab = kmem_cache_create(prot->rsk_prot->slab_name,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002142 prot->rsk_prot->obj_size, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002143 SLAB_HWCACHE_ALIGN, NULL);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002144
2145 if (prot->rsk_prot->slab == NULL) {
2146 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
2147 prot->name);
2148 goto out_free_request_sock_slab_name;
2149 }
2150 }
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002151
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002152 if (prot->twsk_prot != NULL) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002153 static const char mask[] = "tw_sock_%s";
2154
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002155 prot->twsk_prot->twsk_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002156
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002157 if (prot->twsk_prot->twsk_slab_name == NULL)
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002158 goto out_free_request_sock_slab;
2159
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002160 sprintf(prot->twsk_prot->twsk_slab_name, mask, prot->name);
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002161 prot->twsk_prot->twsk_slab =
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002162 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002163 prot->twsk_prot->twsk_obj_size,
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002164 0,
2165 SLAB_HWCACHE_ALIGN |
2166 prot->slab_flags,
Paul Mundt20c2df82007-07-20 10:11:58 +09002167 NULL);
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002168 if (prot->twsk_prot->twsk_slab == NULL)
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002169 goto out_free_timewait_sock_slab_name;
2170 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002171 }
2172
Arnaldo Carvalho de Melo2a278052005-04-16 15:24:09 -07002173 write_lock(&proto_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002174 list_add(&prot->node, &proto_list);
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002175 assign_proto_idx(prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002176 write_unlock(&proto_list_lock);
Pavel Emelyanovb733c002007-11-07 02:23:38 -08002177 return 0;
2178
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002179out_free_timewait_sock_slab_name:
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002180 kfree(prot->twsk_prot->twsk_slab_name);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002181out_free_request_sock_slab:
2182 if (prot->rsk_prot && prot->rsk_prot->slab) {
2183 kmem_cache_destroy(prot->rsk_prot->slab);
2184 prot->rsk_prot->slab = NULL;
2185 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002186out_free_request_sock_slab_name:
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002187 kfree(prot->rsk_prot->slab_name);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002188out_free_sock_slab:
2189 kmem_cache_destroy(prot->slab);
2190 prot->slab = NULL;
Pavel Emelyanovb733c002007-11-07 02:23:38 -08002191out:
2192 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002193}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002194EXPORT_SYMBOL(proto_register);
2195
2196void proto_unregister(struct proto *prot)
2197{
2198 write_lock(&proto_list_lock);
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002199 release_proto_idx(prot);
Patrick McHardy0a3f4352005-09-06 19:47:50 -07002200 list_del(&prot->node);
2201 write_unlock(&proto_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002202
2203 if (prot->slab != NULL) {
2204 kmem_cache_destroy(prot->slab);
2205 prot->slab = NULL;
2206 }
2207
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002208 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002209 kmem_cache_destroy(prot->rsk_prot->slab);
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002210 kfree(prot->rsk_prot->slab_name);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002211 prot->rsk_prot->slab = NULL;
2212 }
2213
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002214 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002215 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002216 kfree(prot->twsk_prot->twsk_slab_name);
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002217 prot->twsk_prot->twsk_slab = NULL;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002218 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002219}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002220EXPORT_SYMBOL(proto_unregister);
2221
2222#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002223static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002224 __acquires(proto_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002225{
2226 read_lock(&proto_list_lock);
Pavel Emelianov60f04382007-07-09 13:15:14 -07002227 return seq_list_start_head(&proto_list, *pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002228}
2229
2230static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2231{
Pavel Emelianov60f04382007-07-09 13:15:14 -07002232 return seq_list_next(v, &proto_list, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002233}
2234
2235static void proto_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002236 __releases(proto_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002237{
2238 read_unlock(&proto_list_lock);
2239}
2240
2241static char proto_method_implemented(const void *method)
2242{
2243 return method == NULL ? 'n' : 'y';
2244}
2245
2246static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
2247{
2248 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s "
2249 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
2250 proto->name,
2251 proto->obj_size,
Eric Dumazet14e943d2008-11-19 15:14:01 -08002252 sock_prot_inuse_get(seq_file_net(seq), proto),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002253 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
2254 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
2255 proto->max_header,
2256 proto->slab == NULL ? "no" : "yes",
2257 module_name(proto->owner),
2258 proto_method_implemented(proto->close),
2259 proto_method_implemented(proto->connect),
2260 proto_method_implemented(proto->disconnect),
2261 proto_method_implemented(proto->accept),
2262 proto_method_implemented(proto->ioctl),
2263 proto_method_implemented(proto->init),
2264 proto_method_implemented(proto->destroy),
2265 proto_method_implemented(proto->shutdown),
2266 proto_method_implemented(proto->setsockopt),
2267 proto_method_implemented(proto->getsockopt),
2268 proto_method_implemented(proto->sendmsg),
2269 proto_method_implemented(proto->recvmsg),
2270 proto_method_implemented(proto->sendpage),
2271 proto_method_implemented(proto->bind),
2272 proto_method_implemented(proto->backlog_rcv),
2273 proto_method_implemented(proto->hash),
2274 proto_method_implemented(proto->unhash),
2275 proto_method_implemented(proto->get_port),
2276 proto_method_implemented(proto->enter_memory_pressure));
2277}
2278
2279static int proto_seq_show(struct seq_file *seq, void *v)
2280{
Pavel Emelianov60f04382007-07-09 13:15:14 -07002281 if (v == &proto_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002282 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
2283 "protocol",
2284 "size",
2285 "sockets",
2286 "memory",
2287 "press",
2288 "maxhdr",
2289 "slab",
2290 "module",
2291 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
2292 else
Pavel Emelianov60f04382007-07-09 13:15:14 -07002293 proto_seq_printf(seq, list_entry(v, struct proto, node));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002294 return 0;
2295}
2296
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002297static const struct seq_operations proto_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002298 .start = proto_seq_start,
2299 .next = proto_seq_next,
2300 .stop = proto_seq_stop,
2301 .show = proto_seq_show,
2302};
2303
2304static int proto_seq_open(struct inode *inode, struct file *file)
2305{
Eric Dumazet14e943d2008-11-19 15:14:01 -08002306 return seq_open_net(inode, file, &proto_seq_ops,
2307 sizeof(struct seq_net_private));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002308}
2309
Arjan van de Ven9a321442007-02-12 00:55:35 -08002310static const struct file_operations proto_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002311 .owner = THIS_MODULE,
2312 .open = proto_seq_open,
2313 .read = seq_read,
2314 .llseek = seq_lseek,
Eric Dumazet14e943d2008-11-19 15:14:01 -08002315 .release = seq_release_net,
2316};
2317
2318static __net_init int proto_init_net(struct net *net)
2319{
2320 if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
2321 return -ENOMEM;
2322
2323 return 0;
2324}
2325
2326static __net_exit void proto_exit_net(struct net *net)
2327{
2328 proc_net_remove(net, "protocols");
2329}
2330
2331
2332static __net_initdata struct pernet_operations proto_net_ops = {
2333 .init = proto_init_net,
2334 .exit = proto_exit_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002335};
2336
2337static int __init proto_init(void)
2338{
Eric Dumazet14e943d2008-11-19 15:14:01 -08002339 return register_pernet_subsys(&proto_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002340}
2341
2342subsys_initcall(proto_init);
2343
2344#endif /* PROC_FS */