blob: 3ac34ea6ec058832975a1f8ad1d946337b7cf474 [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 */
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700145static const char *const af_family_key_strings[AF_MAX+1] = {
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700146 "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};
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700161static const char *const af_family_slock_key_strings[AF_MAX+1] = {
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700162 "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};
Jan Engelhardt36cbd3d2009-08-05 10:42:58 -0700177static const char *const af_family_clock_key_strings[AF_MAX+1] = {
Peter Zijlstra443aef02007-07-19 01:49:00 -0700178 "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:
Jan Engelhardt49c794e2009-08-04 07:28:28 +0000485 case SO_PROTOCOL:
Jan Engelhardt0d6038e2009-08-04 07:28:29 +0000486 case SO_DOMAIN:
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700487 case SO_ERROR:
488 ret = -ENOPROTOOPT;
489 break;
490 case SO_DONTROUTE:
Pavel Emelyanovc0ef8772007-11-15 03:03:19 -0800491 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700492 break;
493 case SO_BROADCAST:
494 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
495 break;
496 case SO_SNDBUF:
497 /* Don't error on this BSD doesn't and if you think
498 about it this is right. Otherwise apps have to
499 play 'guess the biggest size' games. RCVBUF/SNDBUF
500 are treated in BSD as hints */
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900501
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700502 if (val > sysctl_wmem_max)
503 val = sysctl_wmem_max;
Patrick McHardyb0573de2005-08-09 19:30:51 -0700504set_sndbuf:
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700505 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
506 if ((val * 2) < SOCK_MIN_SNDBUF)
507 sk->sk_sndbuf = SOCK_MIN_SNDBUF;
508 else
509 sk->sk_sndbuf = val * 2;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700510
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700511 /*
512 * Wake up sending tasks if we
513 * upped the value.
514 */
515 sk->sk_write_space(sk);
516 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700517
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700518 case SO_SNDBUFFORCE:
519 if (!capable(CAP_NET_ADMIN)) {
520 ret = -EPERM;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700521 break;
522 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700523 goto set_sndbuf;
524
525 case SO_RCVBUF:
526 /* Don't error on this BSD doesn't and if you think
527 about it this is right. Otherwise apps have to
528 play 'guess the biggest size' games. RCVBUF/SNDBUF
529 are treated in BSD as hints */
530
531 if (val > sysctl_rmem_max)
532 val = sysctl_rmem_max;
533set_rcvbuf:
534 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
535 /*
536 * We double it on the way in to account for
537 * "struct sk_buff" etc. overhead. Applications
538 * assume that the SO_RCVBUF setting they make will
539 * allow that much actual data to be received on that
540 * socket.
541 *
542 * Applications are unaware that "struct sk_buff" and
543 * other overheads allocate from the receive buffer
544 * during socket buffer allocation.
545 *
546 * And after considering the possible alternatives,
547 * returning the value we actually used in getsockopt
548 * is the most desirable behavior.
549 */
550 if ((val * 2) < SOCK_MIN_RCVBUF)
551 sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
552 else
553 sk->sk_rcvbuf = val * 2;
554 break;
555
556 case SO_RCVBUFFORCE:
557 if (!capable(CAP_NET_ADMIN)) {
558 ret = -EPERM;
559 break;
560 }
561 goto set_rcvbuf;
562
563 case SO_KEEPALIVE:
564#ifdef CONFIG_INET
565 if (sk->sk_protocol == IPPROTO_TCP)
566 tcp_set_keepalive(sk, valbool);
567#endif
568 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
569 break;
570
571 case SO_OOBINLINE:
572 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
573 break;
574
575 case SO_NO_CHECK:
576 sk->sk_no_check = valbool;
577 break;
578
579 case SO_PRIORITY:
580 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
581 sk->sk_priority = val;
582 else
583 ret = -EPERM;
584 break;
585
586 case SO_LINGER:
587 if (optlen < sizeof(ling)) {
588 ret = -EINVAL; /* 1003.1g */
589 break;
590 }
Eric Dumazet2a915252009-05-27 11:30:05 +0000591 if (copy_from_user(&ling, optval, sizeof(ling))) {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700592 ret = -EFAULT;
593 break;
594 }
595 if (!ling.l_onoff)
596 sock_reset_flag(sk, SOCK_LINGER);
597 else {
598#if (BITS_PER_LONG == 32)
599 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
600 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
601 else
602#endif
603 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
604 sock_set_flag(sk, SOCK_LINGER);
605 }
606 break;
607
608 case SO_BSDCOMPAT:
609 sock_warn_obsolete_bsdism("setsockopt");
610 break;
611
612 case SO_PASSCRED:
613 if (valbool)
614 set_bit(SOCK_PASSCRED, &sock->flags);
615 else
616 clear_bit(SOCK_PASSCRED, &sock->flags);
617 break;
618
619 case SO_TIMESTAMP:
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700620 case SO_TIMESTAMPNS:
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700621 if (valbool) {
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700622 if (optname == SO_TIMESTAMP)
623 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
624 else
625 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700626 sock_set_flag(sk, SOCK_RCVTSTAMP);
Patrick Ohly20d49472009-02-12 05:03:38 +0000627 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700628 } else {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700629 sock_reset_flag(sk, SOCK_RCVTSTAMP);
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700630 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
631 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700632 break;
633
Patrick Ohly20d49472009-02-12 05:03:38 +0000634 case SO_TIMESTAMPING:
635 if (val & ~SOF_TIMESTAMPING_MASK) {
Rémi Denis-Courmontf249fb72009-07-20 00:47:04 +0000636 ret = -EINVAL;
Patrick Ohly20d49472009-02-12 05:03:38 +0000637 break;
638 }
639 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE,
640 val & SOF_TIMESTAMPING_TX_HARDWARE);
641 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE,
642 val & SOF_TIMESTAMPING_TX_SOFTWARE);
643 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE,
644 val & SOF_TIMESTAMPING_RX_HARDWARE);
645 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
646 sock_enable_timestamp(sk,
647 SOCK_TIMESTAMPING_RX_SOFTWARE);
648 else
649 sock_disable_timestamp(sk,
650 SOCK_TIMESTAMPING_RX_SOFTWARE);
651 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SOFTWARE,
652 val & SOF_TIMESTAMPING_SOFTWARE);
653 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE,
654 val & SOF_TIMESTAMPING_SYS_HARDWARE);
655 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE,
656 val & SOF_TIMESTAMPING_RAW_HARDWARE);
657 break;
658
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700659 case SO_RCVLOWAT:
660 if (val < 0)
661 val = INT_MAX;
662 sk->sk_rcvlowat = val ? : 1;
663 break;
664
665 case SO_RCVTIMEO:
666 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
667 break;
668
669 case SO_SNDTIMEO:
670 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
671 break;
672
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700673 case SO_ATTACH_FILTER:
674 ret = -EINVAL;
675 if (optlen == sizeof(struct sock_fprog)) {
676 struct sock_fprog fprog;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700677
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700678 ret = -EFAULT;
679 if (copy_from_user(&fprog, optval, sizeof(fprog)))
Linus Torvalds1da177e2005-04-16 15:20:36 -0700680 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700681
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700682 ret = sk_attach_filter(&fprog, sk);
683 }
684 break;
685
686 case SO_DETACH_FILTER:
Pavel Emelyanov55b33322007-10-17 21:21:26 -0700687 ret = sk_detach_filter(sk);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700688 break;
689
690 case SO_PASSSEC:
691 if (valbool)
692 set_bit(SOCK_PASSSEC, &sock->flags);
693 else
694 clear_bit(SOCK_PASSSEC, &sock->flags);
695 break;
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800696 case SO_MARK:
697 if (!capable(CAP_NET_ADMIN))
698 ret = -EPERM;
Eric Dumazet2a915252009-05-27 11:30:05 +0000699 else
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800700 sk->sk_mark = val;
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800701 break;
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700702
Linus Torvalds1da177e2005-04-16 15:20:36 -0700703 /* We implement the SO_SNDLOWAT etc to
704 not be settable (1003.1g 5.3) */
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700705 default:
706 ret = -ENOPROTOOPT;
707 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900708 }
Linus Torvalds1da177e2005-04-16 15:20:36 -0700709 release_sock(sk);
710 return ret;
711}
Eric Dumazet2a915252009-05-27 11:30:05 +0000712EXPORT_SYMBOL(sock_setsockopt);
Linus Torvalds1da177e2005-04-16 15:20:36 -0700713
714
715int sock_getsockopt(struct socket *sock, int level, int optname,
716 char __user *optval, int __user *optlen)
717{
718 struct sock *sk = sock->sk;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900719
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700720 union {
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900721 int val;
722 struct linger ling;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700723 struct timeval tm;
724 } v;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900725
Linus Torvalds1da177e2005-04-16 15:20:36 -0700726 unsigned int lv = sizeof(int);
727 int len;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900728
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700729 if (get_user(len, optlen))
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900730 return -EFAULT;
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700731 if (len < 0)
Linus Torvalds1da177e2005-04-16 15:20:36 -0700732 return -EINVAL;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900733
Eugene Teo50fee1d2009-02-23 15:38:41 -0800734 memset(&v, 0, sizeof(v));
Clément Lecignedf0bca02009-02-12 16:59:09 -0800735
Eric Dumazet2a915252009-05-27 11:30:05 +0000736 switch (optname) {
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700737 case SO_DEBUG:
738 v.val = sock_flag(sk, SOCK_DBG);
739 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900740
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700741 case SO_DONTROUTE:
742 v.val = sock_flag(sk, SOCK_LOCALROUTE);
743 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900744
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700745 case SO_BROADCAST:
746 v.val = !!sock_flag(sk, SOCK_BROADCAST);
747 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700748
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700749 case SO_SNDBUF:
750 v.val = sk->sk_sndbuf;
751 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900752
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700753 case SO_RCVBUF:
754 v.val = sk->sk_rcvbuf;
755 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700756
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700757 case SO_REUSEADDR:
758 v.val = sk->sk_reuse;
759 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700760
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700761 case SO_KEEPALIVE:
762 v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
763 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700764
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700765 case SO_TYPE:
766 v.val = sk->sk_type;
767 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700768
Jan Engelhardt49c794e2009-08-04 07:28:28 +0000769 case SO_PROTOCOL:
770 v.val = sk->sk_protocol;
771 break;
772
Jan Engelhardt0d6038e2009-08-04 07:28:29 +0000773 case SO_DOMAIN:
774 v.val = sk->sk_family;
775 break;
776
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700777 case SO_ERROR:
778 v.val = -sock_error(sk);
Eric Dumazet2a915252009-05-27 11:30:05 +0000779 if (v.val == 0)
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700780 v.val = xchg(&sk->sk_err_soft, 0);
781 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700782
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700783 case SO_OOBINLINE:
784 v.val = !!sock_flag(sk, SOCK_URGINLINE);
785 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900786
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700787 case SO_NO_CHECK:
788 v.val = sk->sk_no_check;
789 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700790
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700791 case SO_PRIORITY:
792 v.val = sk->sk_priority;
793 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900794
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700795 case SO_LINGER:
796 lv = sizeof(v.ling);
797 v.ling.l_onoff = !!sock_flag(sk, SOCK_LINGER);
798 v.ling.l_linger = sk->sk_lingertime / HZ;
799 break;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900800
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700801 case SO_BSDCOMPAT:
802 sock_warn_obsolete_bsdism("getsockopt");
803 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700804
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700805 case SO_TIMESTAMP:
Eric Dumazet92f37fd2007-03-25 22:14:49 -0700806 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
807 !sock_flag(sk, SOCK_RCVTSTAMPNS);
808 break;
809
810 case SO_TIMESTAMPNS:
811 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700812 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700813
Patrick Ohly20d49472009-02-12 05:03:38 +0000814 case SO_TIMESTAMPING:
815 v.val = 0;
816 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))
817 v.val |= SOF_TIMESTAMPING_TX_HARDWARE;
818 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))
819 v.val |= SOF_TIMESTAMPING_TX_SOFTWARE;
820 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE))
821 v.val |= SOF_TIMESTAMPING_RX_HARDWARE;
822 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE))
823 v.val |= SOF_TIMESTAMPING_RX_SOFTWARE;
824 if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE))
825 v.val |= SOF_TIMESTAMPING_SOFTWARE;
826 if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE))
827 v.val |= SOF_TIMESTAMPING_SYS_HARDWARE;
828 if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE))
829 v.val |= SOF_TIMESTAMPING_RAW_HARDWARE;
830 break;
831
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700832 case SO_RCVTIMEO:
Eric Dumazet2a915252009-05-27 11:30:05 +0000833 lv = sizeof(struct timeval);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700834 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
835 v.tm.tv_sec = 0;
836 v.tm.tv_usec = 0;
837 } else {
838 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
839 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700840 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700841 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700842
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700843 case SO_SNDTIMEO:
Eric Dumazet2a915252009-05-27 11:30:05 +0000844 lv = sizeof(struct timeval);
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700845 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
846 v.tm.tv_sec = 0;
847 v.tm.tv_usec = 0;
848 } else {
849 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
850 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
851 }
852 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700853
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700854 case SO_RCVLOWAT:
855 v.val = sk->sk_rcvlowat;
856 break;
Catherine Zhang877ce7c2006-06-29 12:27:47 -0700857
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700858 case SO_SNDLOWAT:
Eric Dumazet2a915252009-05-27 11:30:05 +0000859 v.val = 1;
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700860 break;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700861
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700862 case SO_PASSCRED:
863 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
864 break;
865
866 case SO_PEERCRED:
867 if (len > sizeof(sk->sk_peercred))
868 len = sizeof(sk->sk_peercred);
869 if (copy_to_user(optval, &sk->sk_peercred, len))
870 return -EFAULT;
871 goto lenout;
872
873 case SO_PEERNAME:
874 {
875 char address[128];
876
877 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
878 return -ENOTCONN;
879 if (lv < len)
880 return -EINVAL;
881 if (copy_to_user(optval, address, len))
882 return -EFAULT;
883 goto lenout;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700884 }
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700885
886 /* Dubious BSD thing... Probably nobody even uses it, but
887 * the UNIX standard wants it for whatever reason... -DaveM
888 */
889 case SO_ACCEPTCONN:
890 v.val = sk->sk_state == TCP_LISTEN;
891 break;
892
893 case SO_PASSSEC:
894 v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0;
895 break;
896
897 case SO_PEERSEC:
898 return security_socket_getpeersec_stream(sock, optval, optlen, len);
899
Laszlo Attila Toth4a19ec52008-01-30 19:08:16 -0800900 case SO_MARK:
901 v.val = sk->sk_mark;
902 break;
903
Stephen Hemmingere71a4782007-04-10 20:10:33 -0700904 default:
905 return -ENOPROTOOPT;
906 }
907
Linus Torvalds1da177e2005-04-16 15:20:36 -0700908 if (len > lv)
909 len = lv;
910 if (copy_to_user(optval, &v, len))
911 return -EFAULT;
912lenout:
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +0900913 if (put_user(len, optlen))
914 return -EFAULT;
915 return 0;
Linus Torvalds1da177e2005-04-16 15:20:36 -0700916}
917
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700918/*
919 * Initialize an sk_lock.
920 *
921 * (We also register the sk_lock with the lock validator.)
922 */
Dave Jonesb6f99a22007-03-22 12:27:49 -0700923static inline void sock_lock_init(struct sock *sk)
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700924{
Peter Zijlstraed075362006-12-06 20:35:24 -0800925 sock_lock_init_class_and_name(sk,
926 af_family_slock_key_strings[sk->sk_family],
927 af_family_slock_keys + sk->sk_family,
928 af_family_key_strings[sk->sk_family],
929 af_family_keys + sk->sk_family);
Ingo Molnara5b5bb92006-07-03 00:25:35 -0700930}
931
Eric Dumazet4dc6dc72009-07-15 23:13:10 +0000932/*
933 * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
934 * even temporarly, because of RCU lookups. sk_node should also be left as is.
935 */
Pavel Emelyanovf1a6c4d2007-11-01 00:29:45 -0700936static void sock_copy(struct sock *nsk, const struct sock *osk)
937{
938#ifdef CONFIG_SECURITY_NETWORK
939 void *sptr = nsk->sk_security;
940#endif
Eric Dumazet4dc6dc72009-07-15 23:13:10 +0000941 BUILD_BUG_ON(offsetof(struct sock, sk_copy_start) !=
942 sizeof(osk->sk_node) + sizeof(osk->sk_refcnt));
943 memcpy(&nsk->sk_copy_start, &osk->sk_copy_start,
944 osk->sk_prot->obj_size - offsetof(struct sock, sk_copy_start));
Pavel Emelyanovf1a6c4d2007-11-01 00:29:45 -0700945#ifdef CONFIG_SECURITY_NETWORK
946 nsk->sk_security = sptr;
947 security_sk_clone(osk, nsk);
948#endif
949}
950
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700951static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
952 int family)
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700953{
954 struct sock *sk;
955 struct kmem_cache *slab;
956
957 slab = prot->slab;
Eric Dumazete912b112009-07-08 19:36:05 +0000958 if (slab != NULL) {
959 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
960 if (!sk)
961 return sk;
962 if (priority & __GFP_ZERO) {
963 /*
964 * caches using SLAB_DESTROY_BY_RCU should let
965 * sk_node.next un-modified. Special care is taken
966 * when initializing object to zero.
967 */
968 if (offsetof(struct sock, sk_node.next) != 0)
969 memset(sk, 0, offsetof(struct sock, sk_node.next));
970 memset(&sk->sk_node.pprev, 0,
971 prot->obj_size - offsetof(struct sock,
972 sk_node.pprev));
973 }
974 }
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700975 else
976 sk = kmalloc(prot->obj_size, priority);
977
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700978 if (sk != NULL) {
Vegard Nossuma98b65a2009-02-26 14:46:57 +0100979 kmemcheck_annotate_bitfield(sk, flags);
980
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700981 if (security_sk_alloc(sk, family, priority))
982 goto out_free;
983
984 if (!try_module_get(prot->owner))
985 goto out_free_sec;
986 }
987
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700988 return sk;
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -0700989
990out_free_sec:
991 security_sk_free(sk);
992out_free:
993 if (slab != NULL)
994 kmem_cache_free(slab, sk);
995 else
996 kfree(sk);
997 return NULL;
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -0700998}
999
1000static void sk_prot_free(struct proto *prot, struct sock *sk)
1001{
1002 struct kmem_cache *slab;
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -07001003 struct module *owner;
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -07001004
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -07001005 owner = prot->owner;
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -07001006 slab = prot->slab;
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -07001007
1008 security_sk_free(sk);
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -07001009 if (slab != NULL)
1010 kmem_cache_free(slab, sk);
1011 else
1012 kfree(sk);
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -07001013 module_put(owner);
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -07001014}
1015
Linus Torvalds1da177e2005-04-16 15:20:36 -07001016/**
1017 * sk_alloc - All socket objects are allocated here
Randy Dunlapc4ea43c2007-10-12 21:17:49 -07001018 * @net: the applicable net namespace
Pavel Pisa4dc3b162005-05-01 08:59:25 -07001019 * @family: protocol family
1020 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1021 * @prot: struct proto associated with this new sock instance
Linus Torvalds1da177e2005-04-16 15:20:36 -07001022 */
Eric W. Biederman1b8d7ae2007-10-08 23:24:22 -07001023struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
Pavel Emelyanov6257ff22007-11-01 00:39:31 -07001024 struct proto *prot)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001025{
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -07001026 struct sock *sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001027
Pavel Emelyanov154adbc2007-11-01 00:38:43 -07001028 sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001029 if (sk) {
Pavel Emelyanov154adbc2007-11-01 00:38:43 -07001030 sk->sk_family = family;
1031 /*
1032 * See comment in struct sock definition to understand
1033 * why we need sk_prot_creator -acme
1034 */
1035 sk->sk_prot = sk->sk_prot_creator = prot;
1036 sock_lock_init(sk);
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001037 sock_net_set(sk, get_net(net));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001038 }
Frank Filza79af592005-09-27 15:23:38 -07001039
Pavel Emelyanov2e4afe72007-11-01 00:36:26 -07001040 return sk;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001041}
Eric Dumazet2a915252009-05-27 11:30:05 +00001042EXPORT_SYMBOL(sk_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001043
Eric Dumazet2b85a342009-06-11 02:55:43 -07001044static void __sk_free(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001045{
1046 struct sk_filter *filter;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001047
1048 if (sk->sk_destruct)
1049 sk->sk_destruct(sk);
1050
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001051 filter = rcu_dereference(sk->sk_filter);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001052 if (filter) {
Pavel Emelyanov309dd5f2007-10-17 21:21:51 -07001053 sk_filter_uncharge(sk, filter);
Dmitry Mishinfda9ef52006-08-31 15:28:39 -07001054 rcu_assign_pointer(sk->sk_filter, NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001055 }
1056
Patrick Ohly20d49472009-02-12 05:03:38 +00001057 sock_disable_timestamp(sk, SOCK_TIMESTAMP);
1058 sock_disable_timestamp(sk, SOCK_TIMESTAMPING_RX_SOFTWARE);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001059
1060 if (atomic_read(&sk->sk_omem_alloc))
1061 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
Harvey Harrison0dc47872008-03-05 20:47:47 -08001062 __func__, atomic_read(&sk->sk_omem_alloc));
Linus Torvalds1da177e2005-04-16 15:20:36 -07001063
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001064 put_net(sock_net(sk));
Pavel Emelyanovc308c1b2007-11-01 00:33:50 -07001065 sk_prot_free(sk->sk_prot_creator, sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001066}
Eric Dumazet2b85a342009-06-11 02:55:43 -07001067
1068void sk_free(struct sock *sk)
1069{
1070 /*
1071 * We substract one from sk_wmem_alloc and can know if
1072 * some packets are still in some tx queue.
1073 * If not null, sock_wfree() will call __sk_free(sk) later
1074 */
1075 if (atomic_dec_and_test(&sk->sk_wmem_alloc))
1076 __sk_free(sk);
1077}
Eric Dumazet2a915252009-05-27 11:30:05 +00001078EXPORT_SYMBOL(sk_free);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001079
Denis V. Lunevedf02082008-02-29 11:18:32 -08001080/*
1081 * Last sock_put should drop referrence to sk->sk_net. It has already
1082 * been dropped in sk_change_net. Taking referrence to stopping namespace
1083 * is not an option.
1084 * Take referrence to a socket to remove it from hash _alive_ and after that
1085 * destroy it in the context of init_net.
1086 */
1087void sk_release_kernel(struct sock *sk)
1088{
1089 if (sk == NULL || sk->sk_socket == NULL)
1090 return;
1091
1092 sock_hold(sk);
1093 sock_release(sk->sk_socket);
Denis V. Lunev65a18ec2008-04-16 01:59:46 -07001094 release_net(sock_net(sk));
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001095 sock_net_set(sk, get_net(&init_net));
Denis V. Lunevedf02082008-02-29 11:18:32 -08001096 sock_put(sk);
1097}
David S. Miller45af1752008-02-29 11:33:19 -08001098EXPORT_SYMBOL(sk_release_kernel);
Denis V. Lunevedf02082008-02-29 11:18:32 -08001099
Al Virodd0fc662005-10-07 07:46:04 +01001100struct sock *sk_clone(const struct sock *sk, const gfp_t priority)
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001101{
Pavel Emelyanov8fd1d172007-11-01 00:37:32 -07001102 struct sock *newsk;
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001103
Pavel Emelyanov8fd1d172007-11-01 00:37:32 -07001104 newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001105 if (newsk != NULL) {
1106 struct sk_filter *filter;
1107
Venkat Yekkirala892c1412006-08-04 23:08:56 -07001108 sock_copy(newsk, sk);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001109
1110 /* SANITY */
YOSHIFUJI Hideaki3b1e0a62008-03-26 02:26:21 +09001111 get_net(sock_net(newsk));
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001112 sk_node_init(&newsk->sk_node);
1113 sock_lock_init(newsk);
1114 bh_lock_sock(newsk);
Eric Dumazetfa438cc2007-03-04 16:05:44 -08001115 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001116
1117 atomic_set(&newsk->sk_rmem_alloc, 0);
Eric Dumazet2b85a342009-06-11 02:55:43 -07001118 /*
1119 * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1120 */
1121 atomic_set(&newsk->sk_wmem_alloc, 1);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001122 atomic_set(&newsk->sk_omem_alloc, 0);
1123 skb_queue_head_init(&newsk->sk_receive_queue);
1124 skb_queue_head_init(&newsk->sk_write_queue);
Chris Leech97fc2f02006-05-23 17:55:33 -07001125#ifdef CONFIG_NET_DMA
1126 skb_queue_head_init(&newsk->sk_async_wait_queue);
1127#endif
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001128
1129 rwlock_init(&newsk->sk_dst_lock);
1130 rwlock_init(&newsk->sk_callback_lock);
Peter Zijlstra443aef02007-07-19 01:49:00 -07001131 lockdep_set_class_and_name(&newsk->sk_callback_lock,
1132 af_callback_keys + newsk->sk_family,
1133 af_family_clock_key_strings[newsk->sk_family]);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001134
1135 newsk->sk_dst_cache = NULL;
1136 newsk->sk_wmem_queued = 0;
1137 newsk->sk_forward_alloc = 0;
1138 newsk->sk_send_head = NULL;
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001139 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1140
1141 sock_reset_flag(newsk, SOCK_DONE);
1142 skb_queue_head_init(&newsk->sk_error_queue);
1143
1144 filter = newsk->sk_filter;
1145 if (filter != NULL)
1146 sk_filter_charge(newsk, filter);
1147
1148 if (unlikely(xfrm_sk_clone_policy(newsk))) {
1149 /* It is still raw copy of parent, so invalidate
1150 * destructor and make plain sk_free() */
1151 newsk->sk_destruct = NULL;
1152 sk_free(newsk);
1153 newsk = NULL;
1154 goto out;
1155 }
1156
1157 newsk->sk_err = 0;
1158 newsk->sk_priority = 0;
Eric Dumazet4dc6dc72009-07-15 23:13:10 +00001159 /*
1160 * Before updating sk_refcnt, we must commit prior changes to memory
1161 * (Documentation/RCU/rculist_nulls.txt for details)
1162 */
1163 smp_wmb();
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001164 atomic_set(&newsk->sk_refcnt, 2);
1165
1166 /*
1167 * Increment the counter in the same struct proto as the master
1168 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1169 * is the same as sk->sk_prot->socks, as this field was copied
1170 * with memcpy).
1171 *
1172 * This _changes_ the previous behaviour, where
1173 * tcp_create_openreq_child always was incrementing the
1174 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1175 * to be taken into account in all callers. -acme
1176 */
1177 sk_refcnt_debug_inc(newsk);
David S. Miller972692e2008-06-17 22:41:38 -07001178 sk_set_socket(newsk, NULL);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001179 newsk->sk_sleep = NULL;
1180
1181 if (newsk->sk_prot->sockets_allocated)
Eric Dumazet17483762008-11-25 21:16:35 -08001182 percpu_counter_inc(newsk->sk_prot->sockets_allocated);
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001183 }
1184out:
1185 return newsk;
1186}
Arnaldo Carvalho de Melo87d11ce2005-08-09 20:10:12 -07001187EXPORT_SYMBOL_GPL(sk_clone);
1188
Andi Kleen99580892007-04-20 17:12:43 -07001189void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1190{
1191 __sk_dst_set(sk, dst);
1192 sk->sk_route_caps = dst->dev->features;
1193 if (sk->sk_route_caps & NETIF_F_GSO)
Herbert Xu4fcd6b92007-05-31 22:15:50 -07001194 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
Andi Kleen99580892007-04-20 17:12:43 -07001195 if (sk_can_gso(sk)) {
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001196 if (dst->header_len) {
Andi Kleen99580892007-04-20 17:12:43 -07001197 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001198 } else {
Andi Kleen99580892007-04-20 17:12:43 -07001199 sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
Peter P Waskiewicz Jr82cc1a72008-03-21 03:43:19 -07001200 sk->sk_gso_max_size = dst->dev->gso_max_size;
1201 }
Andi Kleen99580892007-04-20 17:12:43 -07001202 }
1203}
1204EXPORT_SYMBOL_GPL(sk_setup_caps);
1205
Linus Torvalds1da177e2005-04-16 15:20:36 -07001206void __init sk_init(void)
1207{
1208 if (num_physpages <= 4096) {
1209 sysctl_wmem_max = 32767;
1210 sysctl_rmem_max = 32767;
1211 sysctl_wmem_default = 32767;
1212 sysctl_rmem_default = 32767;
1213 } else if (num_physpages >= 131072) {
1214 sysctl_wmem_max = 131071;
1215 sysctl_rmem_max = 131071;
1216 }
1217}
1218
1219/*
1220 * Simple resource managers for sockets.
1221 */
1222
1223
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001224/*
1225 * Write buffer destructor automatically called from kfree_skb.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001226 */
1227void sock_wfree(struct sk_buff *skb)
1228{
1229 struct sock *sk = skb->sk;
Eric Dumazet2b85a342009-06-11 02:55:43 -07001230 int res;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001231
1232 /* In case it might be waiting for more memory. */
Eric Dumazet2b85a342009-06-11 02:55:43 -07001233 res = atomic_sub_return(skb->truesize, &sk->sk_wmem_alloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001234 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE))
1235 sk->sk_write_space(sk);
Eric Dumazet2b85a342009-06-11 02:55:43 -07001236 /*
1237 * if sk_wmem_alloc reached 0, we are last user and should
1238 * free this sock, as sk_free() call could not do it.
1239 */
1240 if (res == 0)
1241 __sk_free(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001242}
Eric Dumazet2a915252009-05-27 11:30:05 +00001243EXPORT_SYMBOL(sock_wfree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001244
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001245/*
1246 * Read buffer destructor automatically called from kfree_skb.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001247 */
1248void sock_rfree(struct sk_buff *skb)
1249{
1250 struct sock *sk = skb->sk;
1251
1252 atomic_sub(skb->truesize, &sk->sk_rmem_alloc);
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001253 sk_mem_uncharge(skb->sk, skb->truesize);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001254}
Eric Dumazet2a915252009-05-27 11:30:05 +00001255EXPORT_SYMBOL(sock_rfree);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001256
1257
1258int sock_i_uid(struct sock *sk)
1259{
1260 int uid;
1261
1262 read_lock(&sk->sk_callback_lock);
1263 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1264 read_unlock(&sk->sk_callback_lock);
1265 return uid;
1266}
Eric Dumazet2a915252009-05-27 11:30:05 +00001267EXPORT_SYMBOL(sock_i_uid);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001268
1269unsigned long sock_i_ino(struct sock *sk)
1270{
1271 unsigned long ino;
1272
1273 read_lock(&sk->sk_callback_lock);
1274 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1275 read_unlock(&sk->sk_callback_lock);
1276 return ino;
1277}
Eric Dumazet2a915252009-05-27 11:30:05 +00001278EXPORT_SYMBOL(sock_i_ino);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001279
1280/*
1281 * Allocate a skb from the socket's send buffer.
1282 */
Victor Fusco86a76ca2005-07-08 14:57:47 -07001283struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
Al Virodd0fc662005-10-07 07:46:04 +01001284 gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001285{
1286 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
Eric Dumazet2a915252009-05-27 11:30:05 +00001287 struct sk_buff *skb = alloc_skb(size, priority);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001288 if (skb) {
1289 skb_set_owner_w(skb, sk);
1290 return skb;
1291 }
1292 }
1293 return NULL;
1294}
Eric Dumazet2a915252009-05-27 11:30:05 +00001295EXPORT_SYMBOL(sock_wmalloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001296
1297/*
1298 * Allocate a skb from the socket's receive buffer.
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001299 */
Victor Fusco86a76ca2005-07-08 14:57:47 -07001300struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
Al Virodd0fc662005-10-07 07:46:04 +01001301 gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001302{
1303 if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1304 struct sk_buff *skb = alloc_skb(size, priority);
1305 if (skb) {
1306 skb_set_owner_r(skb, sk);
1307 return skb;
1308 }
1309 }
1310 return NULL;
1311}
1312
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001313/*
Linus Torvalds1da177e2005-04-16 15:20:36 -07001314 * Allocate a memory block from the socket's option memory buffer.
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001315 */
Al Virodd0fc662005-10-07 07:46:04 +01001316void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001317{
1318 if ((unsigned)size <= sysctl_optmem_max &&
1319 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1320 void *mem;
1321 /* First do the add, to avoid the race if kmalloc
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001322 * might sleep.
Linus Torvalds1da177e2005-04-16 15:20:36 -07001323 */
1324 atomic_add(size, &sk->sk_omem_alloc);
1325 mem = kmalloc(size, priority);
1326 if (mem)
1327 return mem;
1328 atomic_sub(size, &sk->sk_omem_alloc);
1329 }
1330 return NULL;
1331}
Eric Dumazet2a915252009-05-27 11:30:05 +00001332EXPORT_SYMBOL(sock_kmalloc);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001333
1334/*
1335 * Free an option memory block.
1336 */
1337void sock_kfree_s(struct sock *sk, void *mem, int size)
1338{
1339 kfree(mem);
1340 atomic_sub(size, &sk->sk_omem_alloc);
1341}
Eric Dumazet2a915252009-05-27 11:30:05 +00001342EXPORT_SYMBOL(sock_kfree_s);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001343
1344/* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1345 I think, these locks should be removed for datagram sockets.
1346 */
Eric Dumazet2a915252009-05-27 11:30:05 +00001347static long sock_wait_for_wmem(struct sock *sk, long timeo)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001348{
1349 DEFINE_WAIT(wait);
1350
1351 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1352 for (;;) {
1353 if (!timeo)
1354 break;
1355 if (signal_pending(current))
1356 break;
1357 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1358 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1359 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1360 break;
1361 if (sk->sk_shutdown & SEND_SHUTDOWN)
1362 break;
1363 if (sk->sk_err)
1364 break;
1365 timeo = schedule_timeout(timeo);
1366 }
1367 finish_wait(sk->sk_sleep, &wait);
1368 return timeo;
1369}
1370
1371
1372/*
1373 * Generic send/receive buffer handlers
1374 */
1375
Herbert Xu4cc7f682009-02-04 16:55:54 -08001376struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1377 unsigned long data_len, int noblock,
1378 int *errcode)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001379{
1380 struct sk_buff *skb;
Al Viro7d877f32005-10-21 03:20:43 -04001381 gfp_t gfp_mask;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001382 long timeo;
1383 int err;
1384
1385 gfp_mask = sk->sk_allocation;
1386 if (gfp_mask & __GFP_WAIT)
1387 gfp_mask |= __GFP_REPEAT;
1388
1389 timeo = sock_sndtimeo(sk, noblock);
1390 while (1) {
1391 err = sock_error(sk);
1392 if (err != 0)
1393 goto failure;
1394
1395 err = -EPIPE;
1396 if (sk->sk_shutdown & SEND_SHUTDOWN)
1397 goto failure;
1398
1399 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
Larry Woodmandb38c1792006-11-03 16:05:45 -08001400 skb = alloc_skb(header_len, gfp_mask);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001401 if (skb) {
1402 int npages;
1403 int i;
1404
1405 /* No pages, we're done... */
1406 if (!data_len)
1407 break;
1408
1409 npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1410 skb->truesize += data_len;
1411 skb_shinfo(skb)->nr_frags = npages;
1412 for (i = 0; i < npages; i++) {
1413 struct page *page;
1414 skb_frag_t *frag;
1415
1416 page = alloc_pages(sk->sk_allocation, 0);
1417 if (!page) {
1418 err = -ENOBUFS;
1419 skb_shinfo(skb)->nr_frags = i;
1420 kfree_skb(skb);
1421 goto failure;
1422 }
1423
1424 frag = &skb_shinfo(skb)->frags[i];
1425 frag->page = page;
1426 frag->page_offset = 0;
1427 frag->size = (data_len >= PAGE_SIZE ?
1428 PAGE_SIZE :
1429 data_len);
1430 data_len -= PAGE_SIZE;
1431 }
1432
1433 /* Full success... */
1434 break;
1435 }
1436 err = -ENOBUFS;
1437 goto failure;
1438 }
1439 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1440 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1441 err = -EAGAIN;
1442 if (!timeo)
1443 goto failure;
1444 if (signal_pending(current))
1445 goto interrupted;
1446 timeo = sock_wait_for_wmem(sk, timeo);
1447 }
1448
1449 skb_set_owner_w(skb, sk);
1450 return skb;
1451
1452interrupted:
1453 err = sock_intr_errno(timeo);
1454failure:
1455 *errcode = err;
1456 return NULL;
1457}
Herbert Xu4cc7f682009-02-04 16:55:54 -08001458EXPORT_SYMBOL(sock_alloc_send_pskb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001459
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001460struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001461 int noblock, int *errcode)
1462{
1463 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1464}
Eric Dumazet2a915252009-05-27 11:30:05 +00001465EXPORT_SYMBOL(sock_alloc_send_skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001466
1467static void __lock_sock(struct sock *sk)
1468{
1469 DEFINE_WAIT(wait);
1470
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001471 for (;;) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001472 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1473 TASK_UNINTERRUPTIBLE);
1474 spin_unlock_bh(&sk->sk_lock.slock);
1475 schedule();
1476 spin_lock_bh(&sk->sk_lock.slock);
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001477 if (!sock_owned_by_user(sk))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001478 break;
1479 }
1480 finish_wait(&sk->sk_lock.wq, &wait);
1481}
1482
1483static void __release_sock(struct sock *sk)
1484{
1485 struct sk_buff *skb = sk->sk_backlog.head;
1486
1487 do {
1488 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1489 bh_unlock_sock(sk);
1490
1491 do {
1492 struct sk_buff *next = skb->next;
1493
1494 skb->next = NULL;
Peter Zijlstrac57943a2008-10-07 14:18:42 -07001495 sk_backlog_rcv(sk, skb);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001496
1497 /*
1498 * We are in process context here with softirqs
1499 * disabled, use cond_resched_softirq() to preempt.
1500 * This is safe to do because we've taken the backlog
1501 * queue private:
1502 */
1503 cond_resched_softirq();
1504
1505 skb = next;
1506 } while (skb != NULL);
1507
1508 bh_lock_sock(sk);
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001509 } while ((skb = sk->sk_backlog.head) != NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001510}
1511
1512/**
1513 * sk_wait_data - wait for data to arrive at sk_receive_queue
Pavel Pisa4dc3b162005-05-01 08:59:25 -07001514 * @sk: sock to wait on
1515 * @timeo: for how long
Linus Torvalds1da177e2005-04-16 15:20:36 -07001516 *
1517 * Now socket state including sk->sk_err is changed only under lock,
1518 * hence we may omit checks after joining wait queue.
1519 * We check receive queue before schedule() only as optimization;
1520 * it is very likely that release_sock() added new data.
1521 */
1522int sk_wait_data(struct sock *sk, long *timeo)
1523{
1524 int rc;
1525 DEFINE_WAIT(wait);
1526
1527 prepare_to_wait(sk->sk_sleep, &wait, TASK_INTERRUPTIBLE);
1528 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1529 rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1530 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1531 finish_wait(sk->sk_sleep, &wait);
1532 return rc;
1533}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001534EXPORT_SYMBOL(sk_wait_data);
1535
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001536/**
1537 * __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
1538 * @sk: socket
1539 * @size: memory size to allocate
1540 * @kind: allocation type
1541 *
1542 * If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
1543 * rmem allocation. This function assumes that protocols which have
1544 * memory_pressure use sk_wmem_queued as write buffer accounting.
1545 */
1546int __sk_mem_schedule(struct sock *sk, int size, int kind)
1547{
1548 struct proto *prot = sk->sk_prot;
1549 int amt = sk_mem_pages(size);
1550 int allocated;
1551
1552 sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
1553 allocated = atomic_add_return(amt, prot->memory_allocated);
1554
1555 /* Under limit. */
1556 if (allocated <= prot->sysctl_mem[0]) {
1557 if (prot->memory_pressure && *prot->memory_pressure)
1558 *prot->memory_pressure = 0;
1559 return 1;
1560 }
1561
1562 /* Under pressure. */
1563 if (allocated > prot->sysctl_mem[1])
1564 if (prot->enter_memory_pressure)
Pavel Emelyanov5c52ba12008-07-16 20:28:10 -07001565 prot->enter_memory_pressure(sk);
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001566
1567 /* Over hard limit. */
1568 if (allocated > prot->sysctl_mem[2])
1569 goto suppress_allocation;
1570
1571 /* guarantee minimum buffer size under pressure */
1572 if (kind == SK_MEM_RECV) {
1573 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
1574 return 1;
1575 } else { /* SK_MEM_SEND */
1576 if (sk->sk_type == SOCK_STREAM) {
1577 if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
1578 return 1;
1579 } else if (atomic_read(&sk->sk_wmem_alloc) <
1580 prot->sysctl_wmem[0])
1581 return 1;
1582 }
1583
1584 if (prot->memory_pressure) {
Eric Dumazet17483762008-11-25 21:16:35 -08001585 int alloc;
1586
1587 if (!*prot->memory_pressure)
1588 return 1;
1589 alloc = percpu_counter_read_positive(prot->sockets_allocated);
1590 if (prot->sysctl_mem[2] > alloc *
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001591 sk_mem_pages(sk->sk_wmem_queued +
1592 atomic_read(&sk->sk_rmem_alloc) +
1593 sk->sk_forward_alloc))
1594 return 1;
1595 }
1596
1597suppress_allocation:
1598
1599 if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
1600 sk_stream_moderate_sndbuf(sk);
1601
1602 /* Fail only if socket is _under_ its sndbuf.
1603 * In this case we cannot block, so that we have to fail.
1604 */
1605 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
1606 return 1;
1607 }
1608
1609 /* Alas. Undo changes. */
1610 sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
1611 atomic_sub(amt, prot->memory_allocated);
1612 return 0;
1613}
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001614EXPORT_SYMBOL(__sk_mem_schedule);
1615
1616/**
1617 * __sk_reclaim - reclaim memory_allocated
1618 * @sk: socket
1619 */
1620void __sk_mem_reclaim(struct sock *sk)
1621{
1622 struct proto *prot = sk->sk_prot;
1623
Eric Dumazet680a5a52007-12-31 15:00:50 -08001624 atomic_sub(sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT,
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001625 prot->memory_allocated);
1626 sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
1627
1628 if (prot->memory_pressure && *prot->memory_pressure &&
1629 (atomic_read(prot->memory_allocated) < prot->sysctl_mem[0]))
1630 *prot->memory_pressure = 0;
1631}
Hideo Aoki3ab224b2007-12-31 00:11:19 -08001632EXPORT_SYMBOL(__sk_mem_reclaim);
1633
1634
Linus Torvalds1da177e2005-04-16 15:20:36 -07001635/*
1636 * Set of default routines for initialising struct proto_ops when
1637 * the protocol does not support a particular function. In certain
1638 * cases where it makes no sense for a protocol to have a "do nothing"
1639 * function, some default processing is provided.
1640 */
1641
1642int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1643{
1644 return -EOPNOTSUPP;
1645}
Eric Dumazet2a915252009-05-27 11:30:05 +00001646EXPORT_SYMBOL(sock_no_bind);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001647
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001648int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001649 int len, int flags)
1650{
1651 return -EOPNOTSUPP;
1652}
Eric Dumazet2a915252009-05-27 11:30:05 +00001653EXPORT_SYMBOL(sock_no_connect);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001654
1655int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1656{
1657 return -EOPNOTSUPP;
1658}
Eric Dumazet2a915252009-05-27 11:30:05 +00001659EXPORT_SYMBOL(sock_no_socketpair);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001660
1661int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1662{
1663 return -EOPNOTSUPP;
1664}
Eric Dumazet2a915252009-05-27 11:30:05 +00001665EXPORT_SYMBOL(sock_no_accept);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001666
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001667int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
Linus Torvalds1da177e2005-04-16 15:20:36 -07001668 int *len, int peer)
1669{
1670 return -EOPNOTSUPP;
1671}
Eric Dumazet2a915252009-05-27 11:30:05 +00001672EXPORT_SYMBOL(sock_no_getname);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001673
Eric Dumazet2a915252009-05-27 11:30:05 +00001674unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001675{
1676 return 0;
1677}
Eric Dumazet2a915252009-05-27 11:30:05 +00001678EXPORT_SYMBOL(sock_no_poll);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001679
1680int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1681{
1682 return -EOPNOTSUPP;
1683}
Eric Dumazet2a915252009-05-27 11:30:05 +00001684EXPORT_SYMBOL(sock_no_ioctl);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001685
1686int sock_no_listen(struct socket *sock, int backlog)
1687{
1688 return -EOPNOTSUPP;
1689}
Eric Dumazet2a915252009-05-27 11:30:05 +00001690EXPORT_SYMBOL(sock_no_listen);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001691
1692int sock_no_shutdown(struct socket *sock, int how)
1693{
1694 return -EOPNOTSUPP;
1695}
Eric Dumazet2a915252009-05-27 11:30:05 +00001696EXPORT_SYMBOL(sock_no_shutdown);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001697
1698int sock_no_setsockopt(struct socket *sock, int level, int optname,
1699 char __user *optval, int optlen)
1700{
1701 return -EOPNOTSUPP;
1702}
Eric Dumazet2a915252009-05-27 11:30:05 +00001703EXPORT_SYMBOL(sock_no_setsockopt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001704
1705int sock_no_getsockopt(struct socket *sock, int level, int optname,
1706 char __user *optval, int __user *optlen)
1707{
1708 return -EOPNOTSUPP;
1709}
Eric Dumazet2a915252009-05-27 11:30:05 +00001710EXPORT_SYMBOL(sock_no_getsockopt);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001711
1712int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1713 size_t len)
1714{
1715 return -EOPNOTSUPP;
1716}
Eric Dumazet2a915252009-05-27 11:30:05 +00001717EXPORT_SYMBOL(sock_no_sendmsg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001718
1719int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1720 size_t len, int flags)
1721{
1722 return -EOPNOTSUPP;
1723}
Eric Dumazet2a915252009-05-27 11:30:05 +00001724EXPORT_SYMBOL(sock_no_recvmsg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001725
1726int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1727{
1728 /* Mirror missing mmap method error code */
1729 return -ENODEV;
1730}
Eric Dumazet2a915252009-05-27 11:30:05 +00001731EXPORT_SYMBOL(sock_no_mmap);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001732
1733ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1734{
1735 ssize_t res;
1736 struct msghdr msg = {.msg_flags = flags};
1737 struct kvec iov;
1738 char *kaddr = kmap(page);
1739 iov.iov_base = kaddr + offset;
1740 iov.iov_len = size;
1741 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1742 kunmap(page);
1743 return res;
1744}
Eric Dumazet2a915252009-05-27 11:30:05 +00001745EXPORT_SYMBOL(sock_no_sendpage);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001746
1747/*
1748 * Default Socket Callbacks
1749 */
1750
1751static void sock_def_wakeup(struct sock *sk)
1752{
1753 read_lock(&sk->sk_callback_lock);
Jiri Olsaa57de0b2009-07-08 12:09:13 +00001754 if (sk_has_sleeper(sk))
Linus Torvalds1da177e2005-04-16 15:20:36 -07001755 wake_up_interruptible_all(sk->sk_sleep);
1756 read_unlock(&sk->sk_callback_lock);
1757}
1758
1759static void sock_def_error_report(struct sock *sk)
1760{
1761 read_lock(&sk->sk_callback_lock);
Jiri Olsaa57de0b2009-07-08 12:09:13 +00001762 if (sk_has_sleeper(sk))
Davide Libenzi37e55402009-03-31 15:24:21 -07001763 wake_up_interruptible_poll(sk->sk_sleep, POLLERR);
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001764 sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001765 read_unlock(&sk->sk_callback_lock);
1766}
1767
1768static void sock_def_readable(struct sock *sk, int len)
1769{
1770 read_lock(&sk->sk_callback_lock);
Jiri Olsaa57de0b2009-07-08 12:09:13 +00001771 if (sk_has_sleeper(sk))
Davide Libenzi37e55402009-03-31 15:24:21 -07001772 wake_up_interruptible_sync_poll(sk->sk_sleep, POLLIN |
1773 POLLRDNORM | POLLRDBAND);
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001774 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001775 read_unlock(&sk->sk_callback_lock);
1776}
1777
1778static void sock_def_write_space(struct sock *sk)
1779{
1780 read_lock(&sk->sk_callback_lock);
1781
1782 /* Do not wake up a writer until he can make "significant"
1783 * progress. --DaveM
1784 */
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001785 if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
Jiri Olsaa57de0b2009-07-08 12:09:13 +00001786 if (sk_has_sleeper(sk))
Davide Libenzi37e55402009-03-31 15:24:21 -07001787 wake_up_interruptible_sync_poll(sk->sk_sleep, POLLOUT |
1788 POLLWRNORM | POLLWRBAND);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001789
1790 /* Should agree with poll, otherwise some programs break */
1791 if (sock_writeable(sk))
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001792 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001793 }
1794
1795 read_unlock(&sk->sk_callback_lock);
1796}
1797
1798static void sock_def_destruct(struct sock *sk)
1799{
Jesper Juhla51482b2005-11-08 09:41:34 -08001800 kfree(sk->sk_protinfo);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001801}
1802
1803void sk_send_sigurg(struct sock *sk)
1804{
1805 if (sk->sk_socket && sk->sk_socket->file)
1806 if (send_sigurg(&sk->sk_socket->file->f_owner))
Pavel Emelyanov8d8ad9d2007-11-26 20:10:50 +08001807 sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001808}
Eric Dumazet2a915252009-05-27 11:30:05 +00001809EXPORT_SYMBOL(sk_send_sigurg);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001810
1811void sk_reset_timer(struct sock *sk, struct timer_list* timer,
1812 unsigned long expires)
1813{
1814 if (!mod_timer(timer, expires))
1815 sock_hold(sk);
1816}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001817EXPORT_SYMBOL(sk_reset_timer);
1818
1819void sk_stop_timer(struct sock *sk, struct timer_list* timer)
1820{
1821 if (timer_pending(timer) && del_timer(timer))
1822 __sock_put(sk);
1823}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001824EXPORT_SYMBOL(sk_stop_timer);
1825
1826void sock_init_data(struct socket *sock, struct sock *sk)
1827{
1828 skb_queue_head_init(&sk->sk_receive_queue);
1829 skb_queue_head_init(&sk->sk_write_queue);
1830 skb_queue_head_init(&sk->sk_error_queue);
Chris Leech97fc2f02006-05-23 17:55:33 -07001831#ifdef CONFIG_NET_DMA
1832 skb_queue_head_init(&sk->sk_async_wait_queue);
1833#endif
Linus Torvalds1da177e2005-04-16 15:20:36 -07001834
1835 sk->sk_send_head = NULL;
1836
1837 init_timer(&sk->sk_timer);
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001838
Linus Torvalds1da177e2005-04-16 15:20:36 -07001839 sk->sk_allocation = GFP_KERNEL;
1840 sk->sk_rcvbuf = sysctl_rmem_default;
1841 sk->sk_sndbuf = sysctl_wmem_default;
1842 sk->sk_state = TCP_CLOSE;
David S. Miller972692e2008-06-17 22:41:38 -07001843 sk_set_socket(sk, sock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001844
1845 sock_set_flag(sk, SOCK_ZAPPED);
1846
Stephen Hemmingere71a4782007-04-10 20:10:33 -07001847 if (sock) {
Linus Torvalds1da177e2005-04-16 15:20:36 -07001848 sk->sk_type = sock->type;
1849 sk->sk_sleep = &sock->wait;
1850 sock->sk = sk;
1851 } else
1852 sk->sk_sleep = NULL;
1853
1854 rwlock_init(&sk->sk_dst_lock);
1855 rwlock_init(&sk->sk_callback_lock);
Peter Zijlstra443aef02007-07-19 01:49:00 -07001856 lockdep_set_class_and_name(&sk->sk_callback_lock,
1857 af_callback_keys + sk->sk_family,
1858 af_family_clock_key_strings[sk->sk_family]);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001859
1860 sk->sk_state_change = sock_def_wakeup;
1861 sk->sk_data_ready = sock_def_readable;
1862 sk->sk_write_space = sock_def_write_space;
1863 sk->sk_error_report = sock_def_error_report;
1864 sk->sk_destruct = sock_def_destruct;
1865
1866 sk->sk_sndmsg_page = NULL;
1867 sk->sk_sndmsg_off = 0;
1868
1869 sk->sk_peercred.pid = 0;
1870 sk->sk_peercred.uid = -1;
1871 sk->sk_peercred.gid = -1;
1872 sk->sk_write_pending = 0;
1873 sk->sk_rcvlowat = 1;
1874 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
1875 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
1876
Eric Dumazetf37f0af2008-04-13 21:39:26 -07001877 sk->sk_stamp = ktime_set(-1L, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001878
Eric Dumazet4dc6dc72009-07-15 23:13:10 +00001879 /*
1880 * Before updating sk_refcnt, we must commit prior changes to memory
1881 * (Documentation/RCU/rculist_nulls.txt for details)
1882 */
1883 smp_wmb();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001884 atomic_set(&sk->sk_refcnt, 1);
Eric Dumazet2b85a342009-06-11 02:55:43 -07001885 atomic_set(&sk->sk_wmem_alloc, 1);
Wang Chen33c732c2007-11-13 20:30:01 -08001886 atomic_set(&sk->sk_drops, 0);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001887}
Eric Dumazet2a915252009-05-27 11:30:05 +00001888EXPORT_SYMBOL(sock_init_data);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001889
Harvey Harrisonb5606c22008-02-13 15:03:16 -08001890void lock_sock_nested(struct sock *sk, int subclass)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001891{
1892 might_sleep();
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001893 spin_lock_bh(&sk->sk_lock.slock);
John Heffnerd2e91172007-09-12 10:44:19 +02001894 if (sk->sk_lock.owned)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001895 __lock_sock(sk);
John Heffnerd2e91172007-09-12 10:44:19 +02001896 sk->sk_lock.owned = 1;
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001897 spin_unlock(&sk->sk_lock.slock);
1898 /*
1899 * The sk_lock has mutex_lock() semantics here:
1900 */
Peter Zijlstrafcc70d52006-11-08 22:44:35 -08001901 mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001902 local_bh_enable();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001903}
Peter Zijlstrafcc70d52006-11-08 22:44:35 -08001904EXPORT_SYMBOL(lock_sock_nested);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001905
Harvey Harrisonb5606c22008-02-13 15:03:16 -08001906void release_sock(struct sock *sk)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001907{
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001908 /*
1909 * The sk_lock has mutex_unlock() semantics:
1910 */
1911 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
1912
1913 spin_lock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001914 if (sk->sk_backlog.tail)
1915 __release_sock(sk);
John Heffnerd2e91172007-09-12 10:44:19 +02001916 sk->sk_lock.owned = 0;
Ingo Molnara5b5bb92006-07-03 00:25:35 -07001917 if (waitqueue_active(&sk->sk_lock.wq))
1918 wake_up(&sk->sk_lock.wq);
1919 spin_unlock_bh(&sk->sk_lock.slock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07001920}
1921EXPORT_SYMBOL(release_sock);
1922
1923int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001924{
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001925 struct timeval tv;
Linus Torvalds1da177e2005-04-16 15:20:36 -07001926 if (!sock_flag(sk, SOCK_TIMESTAMP))
Patrick Ohly20d49472009-02-12 05:03:38 +00001927 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001928 tv = ktime_to_timeval(sk->sk_stamp);
1929 if (tv.tv_sec == -1)
Linus Torvalds1da177e2005-04-16 15:20:36 -07001930 return -ENOENT;
Eric Dumazetb7aa0bf2007-04-19 16:16:32 -07001931 if (tv.tv_sec == 0) {
1932 sk->sk_stamp = ktime_get_real();
1933 tv = ktime_to_timeval(sk->sk_stamp);
1934 }
1935 return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001936}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001937EXPORT_SYMBOL(sock_get_timestamp);
1938
Eric Dumazetae40eb12007-03-18 17:33:16 -07001939int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
1940{
1941 struct timespec ts;
1942 if (!sock_flag(sk, SOCK_TIMESTAMP))
Patrick Ohly20d49472009-02-12 05:03:38 +00001943 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
Eric Dumazetae40eb12007-03-18 17:33:16 -07001944 ts = ktime_to_timespec(sk->sk_stamp);
1945 if (ts.tv_sec == -1)
1946 return -ENOENT;
1947 if (ts.tv_sec == 0) {
1948 sk->sk_stamp = ktime_get_real();
1949 ts = ktime_to_timespec(sk->sk_stamp);
1950 }
1951 return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
1952}
1953EXPORT_SYMBOL(sock_get_timestampns);
1954
Patrick Ohly20d49472009-02-12 05:03:38 +00001955void sock_enable_timestamp(struct sock *sk, int flag)
YOSHIFUJI Hideaki4ec93ed2007-02-09 23:24:36 +09001956{
Patrick Ohly20d49472009-02-12 05:03:38 +00001957 if (!sock_flag(sk, flag)) {
1958 sock_set_flag(sk, flag);
1959 /*
1960 * we just set one of the two flags which require net
1961 * time stamping, but time stamping might have been on
1962 * already because of the other one
1963 */
1964 if (!sock_flag(sk,
1965 flag == SOCK_TIMESTAMP ?
1966 SOCK_TIMESTAMPING_RX_SOFTWARE :
1967 SOCK_TIMESTAMP))
1968 net_enable_timestamp();
Linus Torvalds1da177e2005-04-16 15:20:36 -07001969 }
1970}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001971
1972/*
1973 * Get a socket option on an socket.
1974 *
1975 * FIX: POSIX 1003.1g is very ambiguous here. It states that
1976 * asynchronous errors should be reported by getsockopt. We assume
1977 * this means if you specify SO_ERROR (otherwise whats the point of it).
1978 */
1979int sock_common_getsockopt(struct socket *sock, int level, int optname,
1980 char __user *optval, int __user *optlen)
1981{
1982 struct sock *sk = sock->sk;
1983
1984 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1985}
Linus Torvalds1da177e2005-04-16 15:20:36 -07001986EXPORT_SYMBOL(sock_common_getsockopt);
1987
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001988#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001989int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
1990 char __user *optval, int __user *optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001991{
1992 struct sock *sk = sock->sk;
1993
Johannes Berg1e51f952007-03-06 13:44:06 -08001994 if (sk->sk_prot->compat_getsockopt != NULL)
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08001995 return sk->sk_prot->compat_getsockopt(sk, level, optname,
1996 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08001997 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
1998}
1999EXPORT_SYMBOL(compat_sock_common_getsockopt);
2000#endif
2001
Linus Torvalds1da177e2005-04-16 15:20:36 -07002002int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
2003 struct msghdr *msg, size_t size, int flags)
2004{
2005 struct sock *sk = sock->sk;
2006 int addr_len = 0;
2007 int err;
2008
2009 err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
2010 flags & ~MSG_DONTWAIT, &addr_len);
2011 if (err >= 0)
2012 msg->msg_namelen = addr_len;
2013 return err;
2014}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002015EXPORT_SYMBOL(sock_common_recvmsg);
2016
2017/*
2018 * Set socket options on an inet socket.
2019 */
2020int sock_common_setsockopt(struct socket *sock, int level, int optname,
2021 char __user *optval, int optlen)
2022{
2023 struct sock *sk = sock->sk;
2024
2025 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2026}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002027EXPORT_SYMBOL(sock_common_setsockopt);
2028
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08002029#ifdef CONFIG_COMPAT
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002030int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
2031 char __user *optval, int optlen)
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08002032{
2033 struct sock *sk = sock->sk;
2034
Arnaldo Carvalho de Melo543d9cf2006-03-20 22:48:35 -08002035 if (sk->sk_prot->compat_setsockopt != NULL)
2036 return sk->sk_prot->compat_setsockopt(sk, level, optname,
2037 optval, optlen);
Dmitry Mishin3fdadf72006-03-20 22:45:21 -08002038 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2039}
2040EXPORT_SYMBOL(compat_sock_common_setsockopt);
2041#endif
2042
Linus Torvalds1da177e2005-04-16 15:20:36 -07002043void sk_common_release(struct sock *sk)
2044{
2045 if (sk->sk_prot->destroy)
2046 sk->sk_prot->destroy(sk);
2047
2048 /*
2049 * Observation: when sock_common_release is called, processes have
2050 * no access to socket. But net still has.
2051 * Step one, detach it from networking:
2052 *
2053 * A. Remove from hash tables.
2054 */
2055
2056 sk->sk_prot->unhash(sk);
2057
2058 /*
2059 * In this point socket cannot receive new packets, but it is possible
2060 * that some packets are in flight because some CPU runs receiver and
2061 * did hash table lookup before we unhashed socket. They will achieve
2062 * receive queue and will be purged by socket destructor.
2063 *
2064 * Also we still have packets pending on receive queue and probably,
2065 * our own packets waiting in device queues. sock_destroy will drain
2066 * receive queue, but transmitted packets will delay socket destruction
2067 * until the last reference will be released.
2068 */
2069
2070 sock_orphan(sk);
2071
2072 xfrm_sk_free_policy(sk);
2073
Arnaldo Carvalho de Meloe6848972005-08-09 19:45:38 -07002074 sk_refcnt_debug_release(sk);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002075 sock_put(sk);
2076}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002077EXPORT_SYMBOL(sk_common_release);
2078
2079static DEFINE_RWLOCK(proto_list_lock);
2080static LIST_HEAD(proto_list);
2081
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002082#ifdef CONFIG_PROC_FS
2083#define PROTO_INUSE_NR 64 /* should be enough for the first time */
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002084struct prot_inuse {
2085 int val[PROTO_INUSE_NR];
2086};
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002087
2088static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
Pavel Emelyanov70ee1152008-03-31 19:42:16 -07002089
2090#ifdef CONFIG_NET_NS
2091void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2092{
2093 int cpu = smp_processor_id();
2094 per_cpu_ptr(net->core.inuse, cpu)->val[prot->inuse_idx] += val;
2095}
2096EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2097
2098int sock_prot_inuse_get(struct net *net, struct proto *prot)
2099{
2100 int cpu, idx = prot->inuse_idx;
2101 int res = 0;
2102
2103 for_each_possible_cpu(cpu)
2104 res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2105
2106 return res >= 0 ? res : 0;
2107}
2108EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2109
2110static int sock_inuse_init_net(struct net *net)
2111{
2112 net->core.inuse = alloc_percpu(struct prot_inuse);
2113 return net->core.inuse ? 0 : -ENOMEM;
2114}
2115
2116static void sock_inuse_exit_net(struct net *net)
2117{
2118 free_percpu(net->core.inuse);
2119}
2120
2121static struct pernet_operations net_inuse_ops = {
2122 .init = sock_inuse_init_net,
2123 .exit = sock_inuse_exit_net,
2124};
2125
2126static __init int net_inuse_init(void)
2127{
2128 if (register_pernet_subsys(&net_inuse_ops))
2129 panic("Cannot initialize net inuse counters");
2130
2131 return 0;
2132}
2133
2134core_initcall(net_inuse_init);
2135#else
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002136static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2137
Pavel Emelyanovc29a0bc2008-03-31 19:41:46 -07002138void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002139{
2140 __get_cpu_var(prot_inuse).val[prot->inuse_idx] += val;
2141}
2142EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2143
Pavel Emelyanovc29a0bc2008-03-31 19:41:46 -07002144int sock_prot_inuse_get(struct net *net, struct proto *prot)
Pavel Emelyanov1338d462008-03-28 16:38:43 -07002145{
2146 int cpu, idx = prot->inuse_idx;
2147 int res = 0;
2148
2149 for_each_possible_cpu(cpu)
2150 res += per_cpu(prot_inuse, cpu).val[idx];
2151
2152 return res >= 0 ? res : 0;
2153}
2154EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
Pavel Emelyanov70ee1152008-03-31 19:42:16 -07002155#endif
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002156
2157static void assign_proto_idx(struct proto *prot)
2158{
2159 prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2160
2161 if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
2162 printk(KERN_ERR "PROTO_INUSE_NR exhausted\n");
2163 return;
2164 }
2165
2166 set_bit(prot->inuse_idx, proto_inuse_idx);
2167}
2168
2169static void release_proto_idx(struct proto *prot)
2170{
2171 if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2172 clear_bit(prot->inuse_idx, proto_inuse_idx);
2173}
2174#else
2175static inline void assign_proto_idx(struct proto *prot)
2176{
2177}
2178
2179static inline void release_proto_idx(struct proto *prot)
2180{
2181}
2182#endif
2183
Linus Torvalds1da177e2005-04-16 15:20:36 -07002184int proto_register(struct proto *prot, int alloc_slab)
2185{
Linus Torvalds1da177e2005-04-16 15:20:36 -07002186 if (alloc_slab) {
2187 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
Eric Dumazet271b72c2008-10-29 02:11:14 -07002188 SLAB_HWCACHE_ALIGN | prot->slab_flags,
2189 NULL);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002190
2191 if (prot->slab == NULL) {
2192 printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
2193 prot->name);
Pavel Emelyanov60e76632008-03-28 16:39:10 -07002194 goto out;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002195 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002196
2197 if (prot->rsk_prot != NULL) {
2198 static const char mask[] = "request_sock_%s";
2199
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002200 prot->rsk_prot->slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
2201 if (prot->rsk_prot->slab_name == NULL)
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002202 goto out_free_sock_slab;
2203
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002204 sprintf(prot->rsk_prot->slab_name, mask, prot->name);
2205 prot->rsk_prot->slab = kmem_cache_create(prot->rsk_prot->slab_name,
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002206 prot->rsk_prot->obj_size, 0,
Paul Mundt20c2df82007-07-20 10:11:58 +09002207 SLAB_HWCACHE_ALIGN, NULL);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002208
2209 if (prot->rsk_prot->slab == NULL) {
2210 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
2211 prot->name);
2212 goto out_free_request_sock_slab_name;
2213 }
2214 }
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002215
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002216 if (prot->twsk_prot != NULL) {
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002217 static const char mask[] = "tw_sock_%s";
2218
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002219 prot->twsk_prot->twsk_slab_name = kmalloc(strlen(prot->name) + sizeof(mask) - 1, GFP_KERNEL);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002220
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002221 if (prot->twsk_prot->twsk_slab_name == NULL)
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002222 goto out_free_request_sock_slab;
2223
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002224 sprintf(prot->twsk_prot->twsk_slab_name, mask, prot->name);
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002225 prot->twsk_prot->twsk_slab =
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002226 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002227 prot->twsk_prot->twsk_obj_size,
Eric Dumazet3ab5aee2008-11-16 19:40:17 -08002228 0,
2229 SLAB_HWCACHE_ALIGN |
2230 prot->slab_flags,
Paul Mundt20c2df82007-07-20 10:11:58 +09002231 NULL);
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002232 if (prot->twsk_prot->twsk_slab == NULL)
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002233 goto out_free_timewait_sock_slab_name;
2234 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002235 }
2236
Arnaldo Carvalho de Melo2a278052005-04-16 15:24:09 -07002237 write_lock(&proto_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002238 list_add(&prot->node, &proto_list);
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002239 assign_proto_idx(prot);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002240 write_unlock(&proto_list_lock);
Pavel Emelyanovb733c002007-11-07 02:23:38 -08002241 return 0;
2242
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002243out_free_timewait_sock_slab_name:
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002244 kfree(prot->twsk_prot->twsk_slab_name);
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002245out_free_request_sock_slab:
2246 if (prot->rsk_prot && prot->rsk_prot->slab) {
2247 kmem_cache_destroy(prot->rsk_prot->slab);
2248 prot->rsk_prot->slab = NULL;
2249 }
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002250out_free_request_sock_slab_name:
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002251 kfree(prot->rsk_prot->slab_name);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002252out_free_sock_slab:
2253 kmem_cache_destroy(prot->slab);
2254 prot->slab = NULL;
Pavel Emelyanovb733c002007-11-07 02:23:38 -08002255out:
2256 return -ENOBUFS;
Linus Torvalds1da177e2005-04-16 15:20:36 -07002257}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002258EXPORT_SYMBOL(proto_register);
2259
2260void proto_unregister(struct proto *prot)
2261{
2262 write_lock(&proto_list_lock);
Pavel Emelyanov13ff3d62008-03-28 16:38:17 -07002263 release_proto_idx(prot);
Patrick McHardy0a3f4352005-09-06 19:47:50 -07002264 list_del(&prot->node);
2265 write_unlock(&proto_list_lock);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002266
2267 if (prot->slab != NULL) {
2268 kmem_cache_destroy(prot->slab);
2269 prot->slab = NULL;
2270 }
2271
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002272 if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002273 kmem_cache_destroy(prot->rsk_prot->slab);
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002274 kfree(prot->rsk_prot->slab_name);
Arnaldo Carvalho de Melo2e6599c2005-06-18 22:46:52 -07002275 prot->rsk_prot->slab = NULL;
2276 }
2277
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002278 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002279 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
Catalin Marinas7e56b5d2008-11-21 16:45:22 -08002280 kfree(prot->twsk_prot->twsk_slab_name);
Arnaldo Carvalho de Melo6d6ee432005-12-13 23:25:19 -08002281 prot->twsk_prot->twsk_slab = NULL;
Arnaldo Carvalho de Melo8feaf0c02005-08-09 20:09:30 -07002282 }
Linus Torvalds1da177e2005-04-16 15:20:36 -07002283}
Linus Torvalds1da177e2005-04-16 15:20:36 -07002284EXPORT_SYMBOL(proto_unregister);
2285
2286#ifdef CONFIG_PROC_FS
Linus Torvalds1da177e2005-04-16 15:20:36 -07002287static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002288 __acquires(proto_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002289{
2290 read_lock(&proto_list_lock);
Pavel Emelianov60f04382007-07-09 13:15:14 -07002291 return seq_list_start_head(&proto_list, *pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002292}
2293
2294static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2295{
Pavel Emelianov60f04382007-07-09 13:15:14 -07002296 return seq_list_next(v, &proto_list, pos);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002297}
2298
2299static void proto_seq_stop(struct seq_file *seq, void *v)
Eric Dumazet9a429c42008-01-01 21:58:02 -08002300 __releases(proto_list_lock)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002301{
2302 read_unlock(&proto_list_lock);
2303}
2304
2305static char proto_method_implemented(const void *method)
2306{
2307 return method == NULL ? 'n' : 'y';
2308}
2309
2310static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
2311{
2312 seq_printf(seq, "%-9s %4u %6d %6d %-3s %6u %-3s %-10s "
2313 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
2314 proto->name,
2315 proto->obj_size,
Eric Dumazet14e943d2008-11-19 15:14:01 -08002316 sock_prot_inuse_get(seq_file_net(seq), proto),
Linus Torvalds1da177e2005-04-16 15:20:36 -07002317 proto->memory_allocated != NULL ? atomic_read(proto->memory_allocated) : -1,
2318 proto->memory_pressure != NULL ? *proto->memory_pressure ? "yes" : "no" : "NI",
2319 proto->max_header,
2320 proto->slab == NULL ? "no" : "yes",
2321 module_name(proto->owner),
2322 proto_method_implemented(proto->close),
2323 proto_method_implemented(proto->connect),
2324 proto_method_implemented(proto->disconnect),
2325 proto_method_implemented(proto->accept),
2326 proto_method_implemented(proto->ioctl),
2327 proto_method_implemented(proto->init),
2328 proto_method_implemented(proto->destroy),
2329 proto_method_implemented(proto->shutdown),
2330 proto_method_implemented(proto->setsockopt),
2331 proto_method_implemented(proto->getsockopt),
2332 proto_method_implemented(proto->sendmsg),
2333 proto_method_implemented(proto->recvmsg),
2334 proto_method_implemented(proto->sendpage),
2335 proto_method_implemented(proto->bind),
2336 proto_method_implemented(proto->backlog_rcv),
2337 proto_method_implemented(proto->hash),
2338 proto_method_implemented(proto->unhash),
2339 proto_method_implemented(proto->get_port),
2340 proto_method_implemented(proto->enter_memory_pressure));
2341}
2342
2343static int proto_seq_show(struct seq_file *seq, void *v)
2344{
Pavel Emelianov60f04382007-07-09 13:15:14 -07002345 if (v == &proto_list)
Linus Torvalds1da177e2005-04-16 15:20:36 -07002346 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
2347 "protocol",
2348 "size",
2349 "sockets",
2350 "memory",
2351 "press",
2352 "maxhdr",
2353 "slab",
2354 "module",
2355 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
2356 else
Pavel Emelianov60f04382007-07-09 13:15:14 -07002357 proto_seq_printf(seq, list_entry(v, struct proto, node));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002358 return 0;
2359}
2360
Stephen Hemmingerf6908082007-03-12 14:34:29 -07002361static const struct seq_operations proto_seq_ops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002362 .start = proto_seq_start,
2363 .next = proto_seq_next,
2364 .stop = proto_seq_stop,
2365 .show = proto_seq_show,
2366};
2367
2368static int proto_seq_open(struct inode *inode, struct file *file)
2369{
Eric Dumazet14e943d2008-11-19 15:14:01 -08002370 return seq_open_net(inode, file, &proto_seq_ops,
2371 sizeof(struct seq_net_private));
Linus Torvalds1da177e2005-04-16 15:20:36 -07002372}
2373
Arjan van de Ven9a321442007-02-12 00:55:35 -08002374static const struct file_operations proto_seq_fops = {
Linus Torvalds1da177e2005-04-16 15:20:36 -07002375 .owner = THIS_MODULE,
2376 .open = proto_seq_open,
2377 .read = seq_read,
2378 .llseek = seq_lseek,
Eric Dumazet14e943d2008-11-19 15:14:01 -08002379 .release = seq_release_net,
2380};
2381
2382static __net_init int proto_init_net(struct net *net)
2383{
2384 if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
2385 return -ENOMEM;
2386
2387 return 0;
2388}
2389
2390static __net_exit void proto_exit_net(struct net *net)
2391{
2392 proc_net_remove(net, "protocols");
2393}
2394
2395
2396static __net_initdata struct pernet_operations proto_net_ops = {
2397 .init = proto_init_net,
2398 .exit = proto_exit_net,
Linus Torvalds1da177e2005-04-16 15:20:36 -07002399};
2400
2401static int __init proto_init(void)
2402{
Eric Dumazet14e943d2008-11-19 15:14:01 -08002403 return register_pernet_subsys(&proto_net_ops);
Linus Torvalds1da177e2005-04-16 15:20:36 -07002404}
2405
2406subsys_initcall(proto_init);
2407
2408#endif /* PROC_FS */