projects / deliverable / linux.git / blame
? search:
summary | shortlog | log | commit | commitdiff | tree
blob | blame (incremental) | history | HEAD
Merge branch 'qed-driver'
[deliverable/linux.git] / net / core / sock.c
CommitLineData
1da177e4
LT		 1/*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Generic socket support routines. Memory allocators, socket lock/release
7 * handler for protocols to use and generic option handler.
8 *
9 *
02c30a84 10 * Authors: Ross Biro
1da177e4
LT		 11 * 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
4ec93edb 35 * code. The ACK stuff can wait and needs major
1da177e4
LT		 36 * 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
e005d193
JP		 92#define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
93
4fc268d2 94#include <linux/capability.h>
1da177e4 95#include <linux/errno.h>
cb820f8e 96#include <linux/errqueue.h>
1da177e4
LT		 97#include <linux/types.h>
98#include <linux/socket.h>
99#include <linux/in.h>
100#include <linux/kernel.h>
1da177e4
LT		 101#include <linux/module.h>
102#include <linux/proc_fs.h>
103#include <linux/seq_file.h>
104#include <linux/sched.h>
105#include <linux/timer.h>
106#include <linux/string.h>
107#include <linux/sockios.h>
108#include <linux/net.h>
109#include <linux/mm.h>
110#include <linux/slab.h>
111#include <linux/interrupt.h>
112#include <linux/poll.h>
113#include <linux/tcp.h>
114#include <linux/init.h>
a1f8e7f7 115#include <linux/highmem.h>
3f551f94 116#include <linux/user_namespace.h>
c5905afb 117#include <linux/static_key.h>
3969eb38 118#include <linux/memcontrol.h>
8c1ae10d 119#include <linux/prefetch.h>
1da177e4
LT		 120
121#include <asm/uaccess.h>
1da177e4
LT		 122
123#include <linux/netdevice.h>
124#include <net/protocol.h>
125#include <linux/skbuff.h>
457c4cbc 126#include <net/net_namespace.h>
2e6599cb 127#include <net/request_sock.h>
1da177e4 128#include <net/sock.h>
20d49473 129#include <linux/net_tstamp.h>
1da177e4
LT		 130#include <net/xfrm.h>
131#include <linux/ipsec.h>
f8451725 132#include <net/cls_cgroup.h>
5bc1421e 133#include <net/netprio_cgroup.h>
eb4cb008 134#include <linux/sock_diag.h>
1da177e4
LT		 135
136#include <linux/filter.h>
137
3847ce32
SM		 138#include <trace/events/sock.h>
139
1da177e4
LT		 140#ifdef CONFIG_INET
141#include <net/tcp.h>
142#endif
143
076bb0c8 144#include <net/busy_poll.h>
06021292 145
36b77a52 146static DEFINE_MUTEX(proto_list_mutex);
d1a4c0b3
GC		 147static LIST_HEAD(proto_list);
148
a3b299da
EB		 149/**
150 * sk_ns_capable - General socket capability test
151 * @sk: Socket to use a capability on or through
152 * @user_ns: The user namespace of the capability to use
153 * @cap: The capability to use
154 *
155 * Test to see if the opener of the socket had when the socket was
156 * created and the current process has the capability @cap in the user
157 * namespace @user_ns.
158 */
159bool sk_ns_capable(const struct sock *sk,
160 struct user_namespace *user_ns, int cap)
161{
162 return file_ns_capable(sk->sk_socket->file, user_ns, cap) &&
163 ns_capable(user_ns, cap);
164}
165EXPORT_SYMBOL(sk_ns_capable);
166
167/**
168 * sk_capable - Socket global capability test
169 * @sk: Socket to use a capability on or through
e793c0f7 170 * @cap: The global capability to use
a3b299da
EB		 171 *
172 * Test to see if the opener of the socket had when the socket was
173 * created and the current process has the capability @cap in all user
174 * namespaces.
175 */
176bool sk_capable(const struct sock *sk, int cap)
177{
178 return sk_ns_capable(sk, &init_user_ns, cap);
179}
180EXPORT_SYMBOL(sk_capable);
181
182/**
183 * sk_net_capable - Network namespace socket capability test
184 * @sk: Socket to use a capability on or through
185 * @cap: The capability to use
186 *
e793c0f7 187 * Test to see if the opener of the socket had when the socket was created
a3b299da
EB		 188 * and the current process has the capability @cap over the network namespace
189 * the socket is a member of.
190 */
191bool sk_net_capable(const struct sock *sk, int cap)
192{
193 return sk_ns_capable(sk, sock_net(sk)->user_ns, cap);
194}
195EXPORT_SYMBOL(sk_net_capable);
196
197
c255a458 198#ifdef CONFIG_MEMCG_KMEM
1d62e436 199int mem_cgroup_sockets_init(struct mem_cgroup *memcg, struct cgroup_subsys *ss)
d1a4c0b3
GC		 200{
201 struct proto *proto;
202 int ret = 0;
203
36b77a52 204 mutex_lock(&proto_list_mutex);
d1a4c0b3
GC		 205 list_for_each_entry(proto, &proto_list, node) {
206 if (proto->init_cgroup) {
1d62e436 207 ret = proto->init_cgroup(memcg, ss);
d1a4c0b3
GC		 208 if (ret)
209 goto out;
210 }
211 }
212
36b77a52 213 mutex_unlock(&proto_list_mutex);
d1a4c0b3
GC		 214 return ret;
215out:
216 list_for_each_entry_continue_reverse(proto, &proto_list, node)
217 if (proto->destroy_cgroup)
1d62e436 218 proto->destroy_cgroup(memcg);
36b77a52 219 mutex_unlock(&proto_list_mutex);
d1a4c0b3
GC		 220 return ret;
221}
222
1d62e436 223void mem_cgroup_sockets_destroy(struct mem_cgroup *memcg)
d1a4c0b3
GC		 224{
225 struct proto *proto;
226
36b77a52 227 mutex_lock(&proto_list_mutex);
d1a4c0b3
GC		 228 list_for_each_entry_reverse(proto, &proto_list, node)
229 if (proto->destroy_cgroup)
1d62e436 230 proto->destroy_cgroup(memcg);
36b77a52 231 mutex_unlock(&proto_list_mutex);
d1a4c0b3
GC		 232}
233#endif
234
da21f24d
IM		 235/*
236 * Each address family might have different locking rules, so we have
237 * one slock key per address family:
238 */
a5b5bb9a
IM		 239static struct lock_class_key af_family_keys[AF_MAX];
240static struct lock_class_key af_family_slock_keys[AF_MAX];
241
cbda4eaf 242#if defined(CONFIG_MEMCG_KMEM)
c5905afb 243struct static_key memcg_socket_limit_enabled;
e1aab161 244EXPORT_SYMBOL(memcg_socket_limit_enabled);
cbda4eaf 245#endif
e1aab161 246
a5b5bb9a
IM		 247/*
248 * Make lock validator output more readable. (we pre-construct these
249 * strings build-time, so that runtime initialization of socket
250 * locks is fast):
251 */
36cbd3dc 252static const char *const af_family_key_strings[AF_MAX+1] = {
a5b5bb9a
IM		 253 "sk_lock-AF_UNSPEC", "sk_lock-AF_UNIX" , "sk_lock-AF_INET" ,
254 "sk_lock-AF_AX25" , "sk_lock-AF_IPX" , "sk_lock-AF_APPLETALK",
255 "sk_lock-AF_NETROM", "sk_lock-AF_BRIDGE" , "sk_lock-AF_ATMPVC" ,
256 "sk_lock-AF_X25" , "sk_lock-AF_INET6" , "sk_lock-AF_ROSE" ,
257 "sk_lock-AF_DECnet", "sk_lock-AF_NETBEUI" , "sk_lock-AF_SECURITY" ,
258 "sk_lock-AF_KEY" , "sk_lock-AF_NETLINK" , "sk_lock-AF_PACKET" ,
259 "sk_lock-AF_ASH" , "sk_lock-AF_ECONET" , "sk_lock-AF_ATMSVC" ,
cbd151bf 260 "sk_lock-AF_RDS" , "sk_lock-AF_SNA" , "sk_lock-AF_IRDA" ,
a5b5bb9a 261 "sk_lock-AF_PPPOX" , "sk_lock-AF_WANPIPE" , "sk_lock-AF_LLC" ,
cd05acfe 262 "sk_lock-27" , "sk_lock-28" , "sk_lock-AF_CAN" ,
17926a79 263 "sk_lock-AF_TIPC" , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV" ,
bce7b154 264 "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN" , "sk_lock-AF_PHONET" ,
6f107b58 265 "sk_lock-AF_IEEE802154", "sk_lock-AF_CAIF" , "sk_lock-AF_ALG" ,
456db6a4 266 "sk_lock-AF_NFC" , "sk_lock-AF_VSOCK" , "sk_lock-AF_MAX"
a5b5bb9a 267};
36cbd3dc 268static const char *const af_family_slock_key_strings[AF_MAX+1] = {
a5b5bb9a
IM		 269 "slock-AF_UNSPEC", "slock-AF_UNIX" , "slock-AF_INET" ,
270 "slock-AF_AX25" , "slock-AF_IPX" , "slock-AF_APPLETALK",
271 "slock-AF_NETROM", "slock-AF_BRIDGE" , "slock-AF_ATMPVC" ,
272 "slock-AF_X25" , "slock-AF_INET6" , "slock-AF_ROSE" ,
273 "slock-AF_DECnet", "slock-AF_NETBEUI" , "slock-AF_SECURITY" ,
274 "slock-AF_KEY" , "slock-AF_NETLINK" , "slock-AF_PACKET" ,
275 "slock-AF_ASH" , "slock-AF_ECONET" , "slock-AF_ATMSVC" ,
cbd151bf 276 "slock-AF_RDS" , "slock-AF_SNA" , "slock-AF_IRDA" ,
a5b5bb9a 277 "slock-AF_PPPOX" , "slock-AF_WANPIPE" , "slock-AF_LLC" ,
cd05acfe 278 "slock-27" , "slock-28" , "slock-AF_CAN" ,
17926a79 279 "slock-AF_TIPC" , "slock-AF_BLUETOOTH", "slock-AF_IUCV" ,
bce7b154 280 "slock-AF_RXRPC" , "slock-AF_ISDN" , "slock-AF_PHONET" ,
6f107b58 281 "slock-AF_IEEE802154", "slock-AF_CAIF" , "slock-AF_ALG" ,
456db6a4 282 "slock-AF_NFC" , "slock-AF_VSOCK" ,"slock-AF_MAX"
a5b5bb9a 283};
36cbd3dc 284static const char *const af_family_clock_key_strings[AF_MAX+1] = {
443aef0e
PZ		 285 "clock-AF_UNSPEC", "clock-AF_UNIX" , "clock-AF_INET" ,
286 "clock-AF_AX25" , "clock-AF_IPX" , "clock-AF_APPLETALK",
287 "clock-AF_NETROM", "clock-AF_BRIDGE" , "clock-AF_ATMPVC" ,
288 "clock-AF_X25" , "clock-AF_INET6" , "clock-AF_ROSE" ,
289 "clock-AF_DECnet", "clock-AF_NETBEUI" , "clock-AF_SECURITY" ,
290 "clock-AF_KEY" , "clock-AF_NETLINK" , "clock-AF_PACKET" ,
291 "clock-AF_ASH" , "clock-AF_ECONET" , "clock-AF_ATMSVC" ,
cbd151bf 292 "clock-AF_RDS" , "clock-AF_SNA" , "clock-AF_IRDA" ,
443aef0e 293 "clock-AF_PPPOX" , "clock-AF_WANPIPE" , "clock-AF_LLC" ,
b4942af6 294 "clock-27" , "clock-28" , "clock-AF_CAN" ,
e51f802b 295 "clock-AF_TIPC" , "clock-AF_BLUETOOTH", "clock-AF_IUCV" ,
bce7b154 296 "clock-AF_RXRPC" , "clock-AF_ISDN" , "clock-AF_PHONET" ,
6f107b58 297 "clock-AF_IEEE802154", "clock-AF_CAIF" , "clock-AF_ALG" ,
456db6a4 298 "clock-AF_NFC" , "clock-AF_VSOCK" , "clock-AF_MAX"
443aef0e 299};
da21f24d
IM		 300
301/*
302 * sk_callback_lock locking rules are per-address-family,
303 * so split the lock classes by using a per-AF key:
304 */
305static struct lock_class_key af_callback_keys[AF_MAX];
306
1da177e4
LT		 307/* Take into consideration the size of the struct sk_buff overhead in the
308 * determination of these values, since that is non-constant across
309 * platforms. This makes socket queueing behavior and performance
310 * not depend upon such differences.
311 */
312#define _SK_MEM_PACKETS 256
87fb4b7b 313#define _SK_MEM_OVERHEAD SKB_TRUESIZE(256)
1da177e4
LT		 314#define SK_WMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
315#define SK_RMEM_MAX (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
316
317/* Run time adjustable parameters. */
ab32ea5d 318__u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
6d8ebc8a 319EXPORT_SYMBOL(sysctl_wmem_max);
ab32ea5d 320__u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
6d8ebc8a 321EXPORT_SYMBOL(sysctl_rmem_max);
ab32ea5d
BH		 322__u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
323__u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
1da177e4 324
25985edc 325/* Maximal space eaten by iovec or ancillary data plus some space */
ab32ea5d 326int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
2a91525c 327EXPORT_SYMBOL(sysctl_optmem_max);
1da177e4 328
b245be1f
WB		 329int sysctl_tstamp_allow_data __read_mostly = 1;
330
c93bdd0e
MG		 331struct static_key memalloc_socks = STATIC_KEY_INIT_FALSE;
332EXPORT_SYMBOL_GPL(memalloc_socks);
333
7cb02404
MG		 334/**
335 * sk_set_memalloc - sets %SOCK_MEMALLOC
336 * @sk: socket to set it on
337 *
338 * Set %SOCK_MEMALLOC on a socket for access to emergency reserves.
339 * It's the responsibility of the admin to adjust min_free_kbytes
340 * to meet the requirements
341 */
342void sk_set_memalloc(struct sock *sk)
343{
344 sock_set_flag(sk, SOCK_MEMALLOC);
345 sk->sk_allocation |= __GFP_MEMALLOC;
c93bdd0e 346 static_key_slow_inc(&memalloc_socks);
7cb02404
MG		 347}
348EXPORT_SYMBOL_GPL(sk_set_memalloc);
349
350void sk_clear_memalloc(struct sock *sk)
351{
352 sock_reset_flag(sk, SOCK_MEMALLOC);
353 sk->sk_allocation &= ~__GFP_MEMALLOC;
c93bdd0e 354 static_key_slow_dec(&memalloc_socks);
c76562b6
MG		 355
356 /*
357 * SOCK_MEMALLOC is allowed to ignore rmem limits to ensure forward
5d753610
MG		 358 * progress of swapping. SOCK_MEMALLOC may be cleared while
359 * it has rmem allocations due to the last swapfile being deactivated
360 * but there is a risk that the socket is unusable due to exceeding
361 * the rmem limits. Reclaim the reserves and obey rmem limits again.
c76562b6 362 */
5d753610 363 sk_mem_reclaim(sk);
7cb02404
MG		 364}
365EXPORT_SYMBOL_GPL(sk_clear_memalloc);
366
b4b9e355
MG		 367int __sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
368{
369 int ret;
370 unsigned long pflags = current->flags;
371
372 /* these should have been dropped before queueing */
373 BUG_ON(!sock_flag(sk, SOCK_MEMALLOC));
374
375 current->flags |= PF_MEMALLOC;
376 ret = sk->sk_backlog_rcv(sk, skb);
377 tsk_restore_flags(current, pflags, PF_MEMALLOC);
378
379 return ret;
380}
381EXPORT_SYMBOL(__sk_backlog_rcv);
382
1da177e4
LT		 383static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
384{
385 struct timeval tv;
386
387 if (optlen < sizeof(tv))
388 return -EINVAL;
389 if (copy_from_user(&tv, optval, sizeof(tv)))
390 return -EFAULT;
ba78073e
VA		 391 if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
392 return -EDOM;
1da177e4 393
ba78073e 394 if (tv.tv_sec < 0) {
6f11df83
AM		 395 static int warned __read_mostly;
396
ba78073e 397 *timeo_p = 0;
50aab54f 398 if (warned < 10 && net_ratelimit()) {
ba78073e 399 warned++;
e005d193
JP		 400 pr_info("%s: `%s' (pid %d) tries to set negative timeout\n",
401 __func__, current->comm, task_pid_nr(current));
50aab54f 402 }
ba78073e
VA		 403 return 0;
404 }
1da177e4
LT		 405 *timeo_p = MAX_SCHEDULE_TIMEOUT;
406 if (tv.tv_sec == 0 && tv.tv_usec == 0)
407 return 0;
408 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
409 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
410 return 0;
411}
412
413static void sock_warn_obsolete_bsdism(const char *name)
414{
415 static int warned;
416 static char warncomm[TASK_COMM_LEN];
4ec93edb
YH		 417 if (strcmp(warncomm, current->comm) && warned < 5) {
418 strcpy(warncomm, current->comm);
e005d193
JP		 419 pr_warn("process `%s' is using obsolete %s SO_BSDCOMPAT\n",
420 warncomm, name);
1da177e4
LT		 421 warned++;
422 }
423}
424
08e29af3
ED		 425#define SK_FLAGS_TIMESTAMP ((1UL << SOCK_TIMESTAMP) | (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE))
426
427static void sock_disable_timestamp(struct sock *sk, unsigned long flags)
4ec93edb 428{
08e29af3
ED		 429 if (sk->sk_flags & flags) {
430 sk->sk_flags &= ~flags;
431 if (!(sk->sk_flags & SK_FLAGS_TIMESTAMP))
20d49473 432 net_disable_timestamp();
1da177e4
LT		 433 }
434}
435
436
f0088a50
DV		 437int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
438{
766e9037 439 int err;
3b885787
NH		 440 unsigned long flags;
441 struct sk_buff_head *list = &sk->sk_receive_queue;
f0088a50 442
0fd7bac6 443 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf) {
766e9037 444 atomic_inc(&sk->sk_drops);
3847ce32 445 trace_sock_rcvqueue_full(sk, skb);
766e9037 446 return -ENOMEM;
f0088a50
DV		 447 }
448
fda9ef5d 449 err = sk_filter(sk, skb);
f0088a50 450 if (err)
766e9037 451 return err;
f0088a50 452
c76562b6 453 if (!sk_rmem_schedule(sk, skb, skb->truesize)) {
766e9037
ED		 454 atomic_inc(&sk->sk_drops);
455 return -ENOBUFS;
3ab224be
HA		 456 }
457
f0088a50
DV		 458 skb->dev = NULL;
459 skb_set_owner_r(skb, sk);
49ad9599 460
7fee226a
ED		 461 /* we escape from rcu protected region, make sure we dont leak
462 * a norefcounted dst
463 */
464 skb_dst_force(skb);
465
3b885787 466 spin_lock_irqsave(&list->lock, flags);
3bc3b96f 467 sock_skb_set_dropcount(sk, skb);
3b885787
NH		 468 __skb_queue_tail(list, skb);
469 spin_unlock_irqrestore(&list->lock, flags);
f0088a50
DV		 470
471 if (!sock_flag(sk, SOCK_DEAD))
676d2369 472 sk->sk_data_ready(sk);
766e9037 473 return 0;
f0088a50
DV		 474}
475EXPORT_SYMBOL(sock_queue_rcv_skb);
476
58a5a7b9 477int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
f0088a50
DV		 478{
479 int rc = NET_RX_SUCCESS;
480
fda9ef5d 481 if (sk_filter(sk, skb))
f0088a50
DV		 482 goto discard_and_relse;
483
484 skb->dev = NULL;
485
274f482d 486 if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
c377411f
ED		 487 atomic_inc(&sk->sk_drops);
488 goto discard_and_relse;
489 }
58a5a7b9
ACM		 490 if (nested)
491 bh_lock_sock_nested(sk);
492 else
493 bh_lock_sock(sk);
a5b5bb9a
IM		 494 if (!sock_owned_by_user(sk)) {
495 /*
496 * trylock + unlock semantics:
497 */
498 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
499
c57943a1 500 rc = sk_backlog_rcv(sk, skb);
a5b5bb9a
IM		 501
502 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
f545a38f 503 } else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
8eae939f
ZY		 504 bh_unlock_sock(sk);
505 atomic_inc(&sk->sk_drops);
506 goto discard_and_relse;
507 }
508
f0088a50
DV		 509 bh_unlock_sock(sk);
510out:
511 sock_put(sk);
512 return rc;
513discard_and_relse:
514 kfree_skb(skb);
515 goto out;
516}
517EXPORT_SYMBOL(sk_receive_skb);
518
519struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
520{
b6c6712a 521 struct dst_entry *dst = __sk_dst_get(sk);
f0088a50
DV		 522
523 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
e022f0b4 524 sk_tx_queue_clear(sk);
a9b3cd7f 525 RCU_INIT_POINTER(sk->sk_dst_cache, NULL);
f0088a50
DV		 526 dst_release(dst);
527 return NULL;
528 }
529
530 return dst;
531}
532EXPORT_SYMBOL(__sk_dst_check);
533
534struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
535{
536 struct dst_entry *dst = sk_dst_get(sk);
537
538 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
539 sk_dst_reset(sk);
540 dst_release(dst);
541 return NULL;
542 }
543
544 return dst;
545}
546EXPORT_SYMBOL(sk_dst_check);
547
c91f6df2
BH		 548static int sock_setbindtodevice(struct sock *sk, char __user *optval,
549 int optlen)
4878809f
DM		 550{
551 int ret = -ENOPROTOOPT;
552#ifdef CONFIG_NETDEVICES
3b1e0a65 553 struct net *net = sock_net(sk);
4878809f
DM		 554 char devname[IFNAMSIZ];
555 int index;
556
557 /* Sorry... */
558 ret = -EPERM;
5e1fccc0 559 if (!ns_capable(net->user_ns, CAP_NET_RAW))
4878809f
DM		 560 goto out;
561
562 ret = -EINVAL;
563 if (optlen < 0)
564 goto out;
565
566 /* Bind this socket to a particular device like "eth0",
567 * as specified in the passed interface name. If the
568 * name is "" or the option length is zero the socket
569 * is not bound.
570 */
571 if (optlen > IFNAMSIZ - 1)
572 optlen = IFNAMSIZ - 1;
573 memset(devname, 0, sizeof(devname));
574
575 ret = -EFAULT;
576 if (copy_from_user(devname, optval, optlen))
577 goto out;
578
000ba2e4
DM		 579 index = 0;
580 if (devname[0] != '\0') {
bf8e56bf 581 struct net_device *dev;
4878809f 582
bf8e56bf
ED		 583 rcu_read_lock();
584 dev = dev_get_by_name_rcu(net, devname);
585 if (dev)
586 index = dev->ifindex;
587 rcu_read_unlock();
4878809f
DM		 588 ret = -ENODEV;
589 if (!dev)
590 goto out;
4878809f
DM		 591 }
592
593 lock_sock(sk);
594 sk->sk_bound_dev_if = index;
595 sk_dst_reset(sk);
596 release_sock(sk);
597
598 ret = 0;
599
600out:
601#endif
602
603 return ret;
604}
605
c91f6df2
BH		 606static int sock_getbindtodevice(struct sock *sk, char __user *optval,
607 int __user *optlen, int len)
608{
609 int ret = -ENOPROTOOPT;
610#ifdef CONFIG_NETDEVICES
611 struct net *net = sock_net(sk);
c91f6df2 612 char devname[IFNAMSIZ];
c91f6df2
BH		 613
614 if (sk->sk_bound_dev_if == 0) {
615 len = 0;
616 goto zero;
617 }
618
619 ret = -EINVAL;
620 if (len < IFNAMSIZ)
621 goto out;
622
5dbe7c17
NS		 623 ret = netdev_get_name(net, devname, sk->sk_bound_dev_if);
624 if (ret)
c91f6df2 625 goto out;
c91f6df2
BH		 626
627 len = strlen(devname) + 1;
628
629 ret = -EFAULT;
630 if (copy_to_user(optval, devname, len))
631 goto out;
632
633zero:
634 ret = -EFAULT;
635 if (put_user(len, optlen))
636 goto out;
637
638 ret = 0;
639
640out:
641#endif
642
643 return ret;
644}
645
c0ef877b
PE		 646static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
647{
648 if (valbool)
649 sock_set_flag(sk, bit);
650 else
651 sock_reset_flag(sk, bit);
652}
653
f60e5990 654bool sk_mc_loop(struct sock *sk)
655{
656 if (dev_recursion_level())
657 return false;
658 if (!sk)
659 return true;
660 switch (sk->sk_family) {
661 case AF_INET:
662 return inet_sk(sk)->mc_loop;
663#if IS_ENABLED(CONFIG_IPV6)
664 case AF_INET6:
665 return inet6_sk(sk)->mc_loop;
666#endif
667 }
668 WARN_ON(1);
669 return true;
670}
671EXPORT_SYMBOL(sk_mc_loop);
672
1da177e4
LT		 673/*
674 * This is meant for all protocols to use and covers goings on
675 * at the socket level. Everything here is generic.
676 */
677
678int sock_setsockopt(struct socket *sock, int level, int optname,
b7058842 679 char __user *optval, unsigned int optlen)
1da177e4 680{
2a91525c 681 struct sock *sk = sock->sk;
1da177e4
LT		 682 int val;
683 int valbool;
684 struct linger ling;
685 int ret = 0;
4ec93edb 686
1da177e4
LT		 687 /*
688 * Options without arguments
689 */
690
4878809f 691 if (optname == SO_BINDTODEVICE)
c91f6df2 692 return sock_setbindtodevice(sk, optval, optlen);
4878809f 693
e71a4783
SH		 694 if (optlen < sizeof(int))
695 return -EINVAL;
4ec93edb 696
1da177e4
LT		 697 if (get_user(val, (int __user *)optval))
698 return -EFAULT;
4ec93edb 699
2a91525c 700 valbool = val ? 1 : 0;
1da177e4
LT		 701
702 lock_sock(sk);
703
2a91525c 704 switch (optname) {
e71a4783 705 case SO_DEBUG:
2a91525c 706 if (val && !capable(CAP_NET_ADMIN))
e71a4783 707 ret = -EACCES;
2a91525c 708 else
c0ef877b 709 sock_valbool_flag(sk, SOCK_DBG, valbool);
e71a4783
SH		 710 break;
711 case SO_REUSEADDR:
4a17fd52 712 sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);
e71a4783 713 break;
055dc21a
TH		 714 case SO_REUSEPORT:
715 sk->sk_reuseport = valbool;
716 break;
e71a4783 717 case SO_TYPE:
49c794e9 718 case SO_PROTOCOL:
0d6038ee 719 case SO_DOMAIN:
e71a4783
SH		 720 case SO_ERROR:
721 ret = -ENOPROTOOPT;
722 break;
723 case SO_DONTROUTE:
c0ef877b 724 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
e71a4783
SH		 725 break;
726 case SO_BROADCAST:
727 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
728 break;
729 case SO_SNDBUF:
730 /* Don't error on this BSD doesn't and if you think
82981930
ED		 731 * about it this is right. Otherwise apps have to
732 * play 'guess the biggest size' games. RCVBUF/SNDBUF
733 * are treated in BSD as hints
734 */
735 val = min_t(u32, val, sysctl_wmem_max);
b0573dea 736set_sndbuf:
e71a4783 737 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
82981930
ED		 738 sk->sk_sndbuf = max_t(u32, val * 2, SOCK_MIN_SNDBUF);
739 /* Wake up sending tasks if we upped the value. */
e71a4783
SH		 740 sk->sk_write_space(sk);
741 break;
1da177e4 742
e71a4783
SH		 743 case SO_SNDBUFFORCE:
744 if (!capable(CAP_NET_ADMIN)) {
745 ret = -EPERM;
746 break;
747 }
748 goto set_sndbuf;
b0573dea 749
e71a4783
SH		 750 case SO_RCVBUF:
751 /* Don't error on this BSD doesn't and if you think
82981930
ED		 752 * about it this is right. Otherwise apps have to
753 * play 'guess the biggest size' games. RCVBUF/SNDBUF
754 * are treated in BSD as hints
755 */
756 val = min_t(u32, val, sysctl_rmem_max);
b0573dea 757set_rcvbuf:
e71a4783
SH		 758 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
759 /*
760 * We double it on the way in to account for
761 * "struct sk_buff" etc. overhead. Applications
762 * assume that the SO_RCVBUF setting they make will
763 * allow that much actual data to be received on that
764 * socket.
765 *
766 * Applications are unaware that "struct sk_buff" and
767 * other overheads allocate from the receive buffer
768 * during socket buffer allocation.
769 *
770 * And after considering the possible alternatives,
771 * returning the value we actually used in getsockopt
772 * is the most desirable behavior.
773 */
82981930 774 sk->sk_rcvbuf = max_t(u32, val * 2, SOCK_MIN_RCVBUF);
e71a4783
SH		 775 break;
776
777 case SO_RCVBUFFORCE:
778 if (!capable(CAP_NET_ADMIN)) {
779 ret = -EPERM;
1da177e4 780 break;
e71a4783
SH		 781 }
782 goto set_rcvbuf;
1da177e4 783
e71a4783 784 case SO_KEEPALIVE:
1da177e4 785#ifdef CONFIG_INET
3e10986d
ED		 786 if (sk->sk_protocol == IPPROTO_TCP &&
787 sk->sk_type == SOCK_STREAM)
e71a4783 788 tcp_set_keepalive(sk, valbool);
1da177e4 789#endif
e71a4783
SH		 790 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
791 break;
792
793 case SO_OOBINLINE:
794 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
795 break;
796
797 case SO_NO_CHECK:
28448b80 798 sk->sk_no_check_tx = valbool;
e71a4783
SH		 799 break;
800
801 case SO_PRIORITY:
5e1fccc0
EB		 802 if ((val >= 0 && val <= 6) ||
803 ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
e71a4783
SH		 804 sk->sk_priority = val;
805 else
806 ret = -EPERM;
807 break;
808
809 case SO_LINGER:
810 if (optlen < sizeof(ling)) {
811 ret = -EINVAL; /* 1003.1g */
1da177e4 812 break;
e71a4783 813 }
2a91525c 814 if (copy_from_user(&ling, optval, sizeof(ling))) {
e71a4783 815 ret = -EFAULT;
1da177e4 816 break;
e71a4783
SH		 817 }
818 if (!ling.l_onoff)
819 sock_reset_flag(sk, SOCK_LINGER);
820 else {
1da177e4 821#if (BITS_PER_LONG == 32)
e71a4783
SH		 822 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
823 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
1da177e4 824 else
e71a4783
SH		 825#endif
826 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
827 sock_set_flag(sk, SOCK_LINGER);
828 }
829 break;
830
831 case SO_BSDCOMPAT:
832 sock_warn_obsolete_bsdism("setsockopt");
833 break;
834
835 case SO_PASSCRED:
836 if (valbool)
837 set_bit(SOCK_PASSCRED, &sock->flags);
838 else
839 clear_bit(SOCK_PASSCRED, &sock->flags);
840 break;
841
842 case SO_TIMESTAMP:
92f37fd2 843 case SO_TIMESTAMPNS:
e71a4783 844 if (valbool) {
92f37fd2
ED		 845 if (optname == SO_TIMESTAMP)
846 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
847 else
848 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
e71a4783 849 sock_set_flag(sk, SOCK_RCVTSTAMP);
20d49473 850 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
92f37fd2 851 } else {
e71a4783 852 sock_reset_flag(sk, SOCK_RCVTSTAMP);
92f37fd2
ED		 853 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
854 }
e71a4783
SH		 855 break;
856
20d49473
PO		 857 case SO_TIMESTAMPING:
858 if (val & ~SOF_TIMESTAMPING_MASK) {
f249fb78 859 ret = -EINVAL;
20d49473
PO		 860 break;
861 }
b245be1f 862
09c2d251 863 if (val & SOF_TIMESTAMPING_OPT_ID &&
4ed2d765
WB		 864 !(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)) {
865 if (sk->sk_protocol == IPPROTO_TCP) {
866 if (sk->sk_state != TCP_ESTABLISHED) {
867 ret = -EINVAL;
868 break;
869 }
870 sk->sk_tskey = tcp_sk(sk)->snd_una;
871 } else {
872 sk->sk_tskey = 0;
873 }
874 }
b9f40e21 875 sk->sk_tsflags = val;
20d49473
PO		 876 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
877 sock_enable_timestamp(sk,
878 SOCK_TIMESTAMPING_RX_SOFTWARE);
879 else
880 sock_disable_timestamp(sk,
08e29af3 881 (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE));
20d49473
PO		 882 break;
883
e71a4783
SH		 884 case SO_RCVLOWAT:
885 if (val < 0)
886 val = INT_MAX;
887 sk->sk_rcvlowat = val ? : 1;
888 break;
889
890 case SO_RCVTIMEO:
891 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
892 break;
893
894 case SO_SNDTIMEO:
895 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
896 break;
1da177e4 897
e71a4783
SH		 898 case SO_ATTACH_FILTER:
899 ret = -EINVAL;
900 if (optlen == sizeof(struct sock_fprog)) {
901 struct sock_fprog fprog;
1da177e4 902
e71a4783
SH		 903 ret = -EFAULT;
904 if (copy_from_user(&fprog, optval, sizeof(fprog)))
1da177e4 905 break;
e71a4783
SH		 906
907 ret = sk_attach_filter(&fprog, sk);
908 }
909 break;
910
89aa0758
AS		 911 case SO_ATTACH_BPF:
912 ret = -EINVAL;
913 if (optlen == sizeof(u32)) {
914 u32 ufd;
915
916 ret = -EFAULT;
917 if (copy_from_user(&ufd, optval, sizeof(ufd)))
918 break;
919
920 ret = sk_attach_bpf(ufd, sk);
921 }
922 break;
923
e71a4783 924 case SO_DETACH_FILTER:
55b33325 925 ret = sk_detach_filter(sk);
e71a4783 926 break;
1da177e4 927
d59577b6
VB		 928 case SO_LOCK_FILTER:
929 if (sock_flag(sk, SOCK_FILTER_LOCKED) && !valbool)
930 ret = -EPERM;
931 else
932 sock_valbool_flag(sk, SOCK_FILTER_LOCKED, valbool);
933 break;
934
e71a4783
SH		 935 case SO_PASSSEC:
936 if (valbool)
937 set_bit(SOCK_PASSSEC, &sock->flags);
938 else
939 clear_bit(SOCK_PASSSEC, &sock->flags);
940 break;
4a19ec58 941 case SO_MARK:
5e1fccc0 942 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
4a19ec58 943 ret = -EPERM;
2a91525c 944 else
4a19ec58 945 sk->sk_mark = val;
4a19ec58 946 break;
877ce7c1 947
3b885787 948 case SO_RXQ_OVFL:
8083f0fc 949 sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
3b885787 950 break;
6e3e939f
JB		 951
952 case SO_WIFI_STATUS:
953 sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
954 break;
955
ef64a54f
PE		 956 case SO_PEEK_OFF:
957 if (sock->ops->set_peek_off)
12663bfc 958 ret = sock->ops->set_peek_off(sk, val);
ef64a54f
PE		 959 else
960 ret = -EOPNOTSUPP;
961 break;
3bdc0eba
BG		 962
963 case SO_NOFCS:
964 sock_valbool_flag(sk, SOCK_NOFCS, valbool);
965 break;
966
7d4c04fc
KJ		 967 case SO_SELECT_ERR_QUEUE:
968 sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
969 break;
970
e0d1095a 971#ifdef CONFIG_NET_RX_BUSY_POLL
64b0dc51 972 case SO_BUSY_POLL:
dafcc438
ET		 973 /* allow unprivileged users to decrease the value */
974 if ((val > sk->sk_ll_usec) && !capable(CAP_NET_ADMIN))
975 ret = -EPERM;
976 else {
977 if (val < 0)
978 ret = -EINVAL;
979 else
980 sk->sk_ll_usec = val;
981 }
982 break;
983#endif
62748f32
ED		 984
985 case SO_MAX_PACING_RATE:
986 sk->sk_max_pacing_rate = val;
987 sk->sk_pacing_rate = min(sk->sk_pacing_rate,
988 sk->sk_max_pacing_rate);
989 break;
990
70da268b
ED		 991 case SO_INCOMING_CPU:
992 sk->sk_incoming_cpu = val;
993 break;
994
e71a4783
SH		 995 default:
996 ret = -ENOPROTOOPT;
997 break;
4ec93edb 998 }
1da177e4
LT		 999 release_sock(sk);
1000 return ret;
1001}
2a91525c 1002EXPORT_SYMBOL(sock_setsockopt);
1da177e4
LT		 1003
1004
8f09898b 1005static void cred_to_ucred(struct pid *pid, const struct cred *cred,
1006 struct ucred *ucred)
3f551f94
EB		 1007{
1008 ucred->pid = pid_vnr(pid);
1009 ucred->uid = ucred->gid = -1;
1010 if (cred) {
1011 struct user_namespace *current_ns = current_user_ns();
1012
b2e4f544
EB		 1013 ucred->uid = from_kuid_munged(current_ns, cred->euid);
1014 ucred->gid = from_kgid_munged(current_ns, cred->egid);
3f551f94
EB		 1015 }
1016}
1017
1da177e4
LT		 1018int sock_getsockopt(struct socket *sock, int level, int optname,
1019 char __user *optval, int __user *optlen)
1020{
1021 struct sock *sk = sock->sk;
4ec93edb 1022
e71a4783 1023 union {
4ec93edb
YH		 1024 int val;
1025 struct linger ling;
1da177e4
LT		 1026 struct timeval tm;
1027 } v;
4ec93edb 1028
4d0392be 1029 int lv = sizeof(int);
1da177e4 1030 int len;
4ec93edb 1031
e71a4783 1032 if (get_user(len, optlen))
4ec93edb 1033 return -EFAULT;
e71a4783 1034 if (len < 0)
1da177e4 1035 return -EINVAL;
4ec93edb 1036
50fee1de 1037 memset(&v, 0, sizeof(v));
df0bca04 1038
2a91525c 1039 switch (optname) {
e71a4783
SH		 1040 case SO_DEBUG:
1041 v.val = sock_flag(sk, SOCK_DBG);
1042 break;
1043
1044 case SO_DONTROUTE:
1045 v.val = sock_flag(sk, SOCK_LOCALROUTE);
1046 break;
1047
1048 case SO_BROADCAST:
1b23a5df 1049 v.val = sock_flag(sk, SOCK_BROADCAST);
e71a4783
SH		 1050 break;
1051
1052 case SO_SNDBUF:
1053 v.val = sk->sk_sndbuf;
1054 break;
1055
1056 case SO_RCVBUF:
1057 v.val = sk->sk_rcvbuf;
1058 break;
1059
1060 case SO_REUSEADDR:
1061 v.val = sk->sk_reuse;
1062 break;
1063
055dc21a
TH		 1064 case SO_REUSEPORT:
1065 v.val = sk->sk_reuseport;
1066 break;
1067
e71a4783 1068 case SO_KEEPALIVE:
1b23a5df 1069 v.val = sock_flag(sk, SOCK_KEEPOPEN);
e71a4783
SH		 1070 break;
1071
1072 case SO_TYPE:
1073 v.val = sk->sk_type;
1074 break;
1075
49c794e9
JE		 1076 case SO_PROTOCOL:
1077 v.val = sk->sk_protocol;
1078 break;
1079
0d6038ee
JE		 1080 case SO_DOMAIN:
1081 v.val = sk->sk_family;
1082 break;
1083
e71a4783
SH		 1084 case SO_ERROR:
1085 v.val = -sock_error(sk);
2a91525c 1086 if (v.val == 0)
e71a4783
SH		 1087 v.val = xchg(&sk->sk_err_soft, 0);
1088 break;
1089
1090 case SO_OOBINLINE:
1b23a5df 1091 v.val = sock_flag(sk, SOCK_URGINLINE);
e71a4783
SH		 1092 break;
1093
1094 case SO_NO_CHECK:
28448b80 1095 v.val = sk->sk_no_check_tx;
e71a4783
SH		 1096 break;
1097
1098 case SO_PRIORITY:
1099 v.val = sk->sk_priority;
1100 break;
1101
1102 case SO_LINGER:
1103 lv = sizeof(v.ling);
1b23a5df 1104 v.ling.l_onoff = sock_flag(sk, SOCK_LINGER);
e71a4783
SH		 1105 v.ling.l_linger = sk->sk_lingertime / HZ;
1106 break;
1107
1108 case SO_BSDCOMPAT:
1109 sock_warn_obsolete_bsdism("getsockopt");
1110 break;
1111
1112 case SO_TIMESTAMP:
92f37fd2
ED		 1113 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
1114 !sock_flag(sk, SOCK_RCVTSTAMPNS);
1115 break;
1116
1117 case SO_TIMESTAMPNS:
1118 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
e71a4783
SH		 1119 break;
1120
20d49473 1121 case SO_TIMESTAMPING:
b9f40e21 1122 v.val = sk->sk_tsflags;
20d49473
PO		 1123 break;
1124
e71a4783 1125 case SO_RCVTIMEO:
2a91525c 1126 lv = sizeof(struct timeval);
e71a4783
SH		 1127 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
1128 v.tm.tv_sec = 0;
1129 v.tm.tv_usec = 0;
1130 } else {
1131 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
1132 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
1133 }
1134 break;
1135
1136 case SO_SNDTIMEO:
2a91525c 1137 lv = sizeof(struct timeval);
e71a4783
SH		 1138 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
1139 v.tm.tv_sec = 0;
1140 v.tm.tv_usec = 0;
1141 } else {
1142 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
1143 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
1144 }
1145 break;
1da177e4 1146
e71a4783
SH		 1147 case SO_RCVLOWAT:
1148 v.val = sk->sk_rcvlowat;
1149 break;
1da177e4 1150
e71a4783 1151 case SO_SNDLOWAT:
2a91525c 1152 v.val = 1;
e71a4783 1153 break;
1da177e4 1154
e71a4783 1155 case SO_PASSCRED:
82981930 1156 v.val = !!test_bit(SOCK_PASSCRED, &sock->flags);
e71a4783 1157 break;
1da177e4 1158
e71a4783 1159 case SO_PEERCRED:
109f6e39
EB		 1160 {
1161 struct ucred peercred;
1162 if (len > sizeof(peercred))
1163 len = sizeof(peercred);
1164 cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
1165 if (copy_to_user(optval, &peercred, len))
e71a4783
SH		 1166 return -EFAULT;
1167 goto lenout;
109f6e39 1168 }
1da177e4 1169
e71a4783
SH		 1170 case SO_PEERNAME:
1171 {
1172 char address[128];
1173
1174 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
1175 return -ENOTCONN;
1176 if (lv < len)
1177 return -EINVAL;
1178 if (copy_to_user(optval, address, len))
1179 return -EFAULT;
1180 goto lenout;
1181 }
1da177e4 1182
e71a4783
SH		 1183 /* Dubious BSD thing... Probably nobody even uses it, but
1184 * the UNIX standard wants it for whatever reason... -DaveM
1185 */
1186 case SO_ACCEPTCONN:
1187 v.val = sk->sk_state == TCP_LISTEN;
1188 break;
1da177e4 1189
e71a4783 1190 case SO_PASSSEC:
82981930 1191 v.val = !!test_bit(SOCK_PASSSEC, &sock->flags);
e71a4783 1192 break;
877ce7c1 1193
e71a4783
SH		 1194 case SO_PEERSEC:
1195 return security_socket_getpeersec_stream(sock, optval, optlen, len);
1da177e4 1196
4a19ec58
LAT		 1197 case SO_MARK:
1198 v.val = sk->sk_mark;
1199 break;
1200
3b885787 1201 case SO_RXQ_OVFL:
1b23a5df 1202 v.val = sock_flag(sk, SOCK_RXQ_OVFL);
3b885787
NH		 1203 break;
1204
6e3e939f 1205 case SO_WIFI_STATUS:
1b23a5df 1206 v.val = sock_flag(sk, SOCK_WIFI_STATUS);
6e3e939f
JB		 1207 break;
1208
ef64a54f
PE		 1209 case SO_PEEK_OFF:
1210 if (!sock->ops->set_peek_off)
1211 return -EOPNOTSUPP;
1212
1213 v.val = sk->sk_peek_off;
1214 break;
bc2f7996 1215 case SO_NOFCS:
1b23a5df 1216 v.val = sock_flag(sk, SOCK_NOFCS);
bc2f7996 1217 break;
c91f6df2 1218
f7b86bfe 1219 case SO_BINDTODEVICE:
c91f6df2
BH		 1220 return sock_getbindtodevice(sk, optval, optlen, len);
1221
a8fc9277
PE		 1222 case SO_GET_FILTER:
1223 len = sk_get_filter(sk, (struct sock_filter __user *)optval, len);
1224 if (len < 0)
1225 return len;
1226
1227 goto lenout;
c91f6df2 1228
d59577b6
VB		 1229 case SO_LOCK_FILTER:
1230 v.val = sock_flag(sk, SOCK_FILTER_LOCKED);
1231 break;
1232
ea02f941
MS		 1233 case SO_BPF_EXTENSIONS:
1234 v.val = bpf_tell_extensions();
1235 break;
1236
7d4c04fc
KJ		 1237 case SO_SELECT_ERR_QUEUE:
1238 v.val = sock_flag(sk, SOCK_SELECT_ERR_QUEUE);
1239 break;
1240
e0d1095a 1241#ifdef CONFIG_NET_RX_BUSY_POLL
64b0dc51 1242 case SO_BUSY_POLL:
dafcc438
ET		 1243 v.val = sk->sk_ll_usec;
1244 break;
1245#endif
1246
62748f32
ED		 1247 case SO_MAX_PACING_RATE:
1248 v.val = sk->sk_max_pacing_rate;
1249 break;
1250
2c8c56e1
ED		 1251 case SO_INCOMING_CPU:
1252 v.val = sk->sk_incoming_cpu;
1253 break;
1254
e71a4783 1255 default:
443b5991
YH		 1256 /* We implement the SO_SNDLOWAT etc to not be settable
1257 * (1003.1g 7).
1258 */
e71a4783 1259 return -ENOPROTOOPT;
1da177e4 1260 }
e71a4783 1261
1da177e4
LT		 1262 if (len > lv)
1263 len = lv;
1264 if (copy_to_user(optval, &v, len))
1265 return -EFAULT;
1266lenout:
4ec93edb
YH		 1267 if (put_user(len, optlen))
1268 return -EFAULT;
1269 return 0;
1da177e4
LT		 1270}
1271
a5b5bb9a
IM		 1272/*
1273 * Initialize an sk_lock.
1274 *
1275 * (We also register the sk_lock with the lock validator.)
1276 */
b6f99a21 1277static inline void sock_lock_init(struct sock *sk)
a5b5bb9a 1278{
ed07536e
PZ		 1279 sock_lock_init_class_and_name(sk,
1280 af_family_slock_key_strings[sk->sk_family],
1281 af_family_slock_keys + sk->sk_family,
1282 af_family_key_strings[sk->sk_family],
1283 af_family_keys + sk->sk_family);
a5b5bb9a
IM		 1284}
1285
4dc6dc71
ED		 1286/*
1287 * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
1288 * even temporarly, because of RCU lookups. sk_node should also be left as is.
68835aba 1289 * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
4dc6dc71 1290 */
f1a6c4da
PE		 1291static void sock_copy(struct sock *nsk, const struct sock *osk)
1292{
1293#ifdef CONFIG_SECURITY_NETWORK
1294 void *sptr = nsk->sk_security;
1295#endif
68835aba
ED		 1296 memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
1297
1298 memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
1299 osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
1300
f1a6c4da
PE		 1301#ifdef CONFIG_SECURITY_NETWORK
1302 nsk->sk_security = sptr;
1303 security_sk_clone(osk, nsk);
1304#endif
1305}
1306
fcbdf09d
OP		 1307void sk_prot_clear_portaddr_nulls(struct sock *sk, int size)
1308{
1309 unsigned long nulls1, nulls2;
1310
1311 nulls1 = offsetof(struct sock, __sk_common.skc_node.next);
1312 nulls2 = offsetof(struct sock, __sk_common.skc_portaddr_node.next);
1313 if (nulls1 > nulls2)
1314 swap(nulls1, nulls2);
1315
1316 if (nulls1 != 0)
1317 memset((char *)sk, 0, nulls1);
1318 memset((char *)sk + nulls1 + sizeof(void *), 0,
1319 nulls2 - nulls1 - sizeof(void *));
1320 memset((char *)sk + nulls2 + sizeof(void *), 0,
1321 size - nulls2 - sizeof(void *));
1322}
1323EXPORT_SYMBOL(sk_prot_clear_portaddr_nulls);
1324
2e4afe7b
PE		 1325static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
1326 int family)
c308c1b2
PE		 1327{
1328 struct sock *sk;
1329 struct kmem_cache *slab;
1330
1331 slab = prot->slab;
e912b114
ED		 1332 if (slab != NULL) {
1333 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
1334 if (!sk)
1335 return sk;
1336 if (priority & __GFP_ZERO) {
fcbdf09d
OP		 1337 if (prot->clear_sk)
1338 prot->clear_sk(sk, prot->obj_size);
1339 else
1340 sk_prot_clear_nulls(sk, prot->obj_size);
e912b114 1341 }
fcbdf09d 1342 } else
c308c1b2
PE		 1343 sk = kmalloc(prot->obj_size, priority);
1344
2e4afe7b 1345 if (sk != NULL) {
a98b65a3
VN		 1346 kmemcheck_annotate_bitfield(sk, flags);
1347
2e4afe7b
PE		 1348 if (security_sk_alloc(sk, family, priority))
1349 goto out_free;
1350
1351 if (!try_module_get(prot->owner))
1352 goto out_free_sec;
e022f0b4 1353 sk_tx_queue_clear(sk);
2e4afe7b
PE		 1354 }
1355
c308c1b2 1356 return sk;
2e4afe7b
PE		 1357
1358out_free_sec:
1359 security_sk_free(sk);
1360out_free:
1361 if (slab != NULL)
1362 kmem_cache_free(slab, sk);
1363 else
1364 kfree(sk);
1365 return NULL;
c308c1b2
PE		 1366}
1367
1368static void sk_prot_free(struct proto *prot, struct sock *sk)
1369{
1370 struct kmem_cache *slab;
2e4afe7b 1371 struct module *owner;
c308c1b2 1372
2e4afe7b 1373 owner = prot->owner;
c308c1b2 1374 slab = prot->slab;
2e4afe7b
PE		 1375
1376 security_sk_free(sk);
c308c1b2
PE		 1377 if (slab != NULL)
1378 kmem_cache_free(slab, sk);
1379 else
1380 kfree(sk);
2e4afe7b 1381 module_put(owner);
c308c1b2
PE		 1382}
1383
86f8515f 1384#if IS_ENABLED(CONFIG_CGROUP_NET_PRIO)
6ffd4641 1385void sock_update_netprioidx(struct sock *sk)
5bc1421e 1386{
5bc1421e
NH		 1387 if (in_interrupt())
1388 return;
2b73bc65 1389
6ffd4641 1390 sk->sk_cgrp_prioidx = task_netprioidx(current);
5bc1421e
NH		 1391}
1392EXPORT_SYMBOL_GPL(sock_update_netprioidx);
f8451725
HX		 1393#endif
1394
1da177e4
LT		 1395/**
1396 * sk_alloc - All socket objects are allocated here
c4ea43c5 1397 * @net: the applicable net namespace
4dc3b16b
PP		 1398 * @family: protocol family
1399 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1400 * @prot: struct proto associated with this new sock instance
11aa9c28 1401 * @kern: is this to be a kernel socket?
1da177e4 1402 */
1b8d7ae4 1403struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
11aa9c28 1404 struct proto *prot, int kern)
1da177e4 1405{
c308c1b2 1406 struct sock *sk;
1da177e4 1407
154adbc8 1408 sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
1da177e4 1409 if (sk) {
154adbc8
PE		 1410 sk->sk_family = family;
1411 /*
1412 * See comment in struct sock definition to understand
1413 * why we need sk_prot_creator -acme
1414 */
1415 sk->sk_prot = sk->sk_prot_creator = prot;
1416 sock_lock_init(sk);
26abe143
EB		 1417 sk->sk_net_refcnt = kern ? 0 : 1;
1418 if (likely(sk->sk_net_refcnt))
1419 get_net(net);
1420 sock_net_set(sk, net);
d66ee058 1421 atomic_set(&sk->sk_wmem_alloc, 1);
f8451725 1422
211d2f97 1423 sock_update_classid(sk);
6ffd4641 1424 sock_update_netprioidx(sk);
1da177e4 1425 }
a79af59e 1426
2e4afe7b 1427 return sk;
1da177e4 1428}
2a91525c 1429EXPORT_SYMBOL(sk_alloc);
1da177e4 1430
eb4cb008 1431void sk_destruct(struct sock *sk)
1da177e4
LT		 1432{
1433 struct sk_filter *filter;
1da177e4
LT		 1434
1435 if (sk->sk_destruct)
1436 sk->sk_destruct(sk);
1437
a898def2
PM		 1438 filter = rcu_dereference_check(sk->sk_filter,
1439 atomic_read(&sk->sk_wmem_alloc) == 0);
1da177e4 1440 if (filter) {
309dd5fc 1441 sk_filter_uncharge(sk, filter);
a9b3cd7f 1442 RCU_INIT_POINTER(sk->sk_filter, NULL);
1da177e4
LT		 1443 }
1444
08e29af3 1445 sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
1da177e4
LT		 1446
1447 if (atomic_read(&sk->sk_omem_alloc))
e005d193
JP		 1448 pr_debug("%s: optmem leakage (%d bytes) detected\n",
1449 __func__, atomic_read(&sk->sk_omem_alloc));
1da177e4 1450
109f6e39
EB		 1451 if (sk->sk_peer_cred)
1452 put_cred(sk->sk_peer_cred);
1453 put_pid(sk->sk_peer_pid);
26abe143
EB		 1454 if (likely(sk->sk_net_refcnt))
1455 put_net(sock_net(sk));
c308c1b2 1456 sk_prot_free(sk->sk_prot_creator, sk);
1da177e4 1457}
2b85a34e 1458
eb4cb008
CG		 1459static void __sk_free(struct sock *sk)
1460{
b922622e 1461 if (unlikely(sock_diag_has_destroy_listeners(sk) && sk->sk_net_refcnt))
eb4cb008
CG		 1462 sock_diag_broadcast_destroy(sk);
1463 else
1464 sk_destruct(sk);
1465}
1466
2b85a34e
ED		 1467void sk_free(struct sock *sk)
1468{
1469 /*
25985edc 1470 * We subtract one from sk_wmem_alloc and can know if
2b85a34e
ED		 1471 * some packets are still in some tx queue.
1472 * If not null, sock_wfree() will call __sk_free(sk) later
1473 */
1474 if (atomic_dec_and_test(&sk->sk_wmem_alloc))
1475 __sk_free(sk);
1476}
2a91525c 1477EXPORT_SYMBOL(sk_free);
1da177e4 1478
475f1b52
SR		 1479static void sk_update_clone(const struct sock *sk, struct sock *newsk)
1480{
1481 if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
1482 sock_update_memcg(newsk);
1483}
1484
e56c57d0
ED		 1485/**
1486 * sk_clone_lock - clone a socket, and lock its clone
1487 * @sk: the socket to clone
1488 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1489 *
1490 * Caller must unlock socket even in error path (bh_unlock_sock(newsk))
1491 */
1492struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
87d11ceb 1493{
8fd1d178 1494 struct sock *newsk;
278571ba 1495 bool is_charged = true;
87d11ceb 1496
8fd1d178 1497 newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
87d11ceb
ACM		 1498 if (newsk != NULL) {
1499 struct sk_filter *filter;
1500
892c141e 1501 sock_copy(newsk, sk);
87d11ceb
ACM		 1502
1503 /* SANITY */
8a681736
SV		 1504 if (likely(newsk->sk_net_refcnt))
1505 get_net(sock_net(newsk));
87d11ceb
ACM		 1506 sk_node_init(&newsk->sk_node);
1507 sock_lock_init(newsk);
1508 bh_lock_sock(newsk);
fa438ccf 1509 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
8eae939f 1510 newsk->sk_backlog.len = 0;
87d11ceb
ACM		 1511
1512 atomic_set(&newsk->sk_rmem_alloc, 0);
2b85a34e
ED		 1513 /*
1514 * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1515 */
1516 atomic_set(&newsk->sk_wmem_alloc, 1);
87d11ceb
ACM		 1517 atomic_set(&newsk->sk_omem_alloc, 0);
1518 skb_queue_head_init(&newsk->sk_receive_queue);
1519 skb_queue_head_init(&newsk->sk_write_queue);
1520
b6c6712a 1521 spin_lock_init(&newsk->sk_dst_lock);
87d11ceb 1522 rwlock_init(&newsk->sk_callback_lock);
443aef0e
PZ		 1523 lockdep_set_class_and_name(&newsk->sk_callback_lock,
1524 af_callback_keys + newsk->sk_family,
1525 af_family_clock_key_strings[newsk->sk_family]);
87d11ceb
ACM		 1526
1527 newsk->sk_dst_cache = NULL;
1528 newsk->sk_wmem_queued = 0;
1529 newsk->sk_forward_alloc = 0;
1530 newsk->sk_send_head = NULL;
87d11ceb
ACM		 1531 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1532
1533 sock_reset_flag(newsk, SOCK_DONE);
1534 skb_queue_head_init(&newsk->sk_error_queue);
1535
0d7da9dd 1536 filter = rcu_dereference_protected(newsk->sk_filter, 1);
87d11ceb 1537 if (filter != NULL)
278571ba
AS		 1538 /* though it's an empty new sock, the charging may fail
1539 * if sysctl_optmem_max was changed between creation of
1540 * original socket and cloning
1541 */
1542 is_charged = sk_filter_charge(newsk, filter);
87d11ceb 1543
278571ba 1544 if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk))) {
87d11ceb
ACM		 1545 /* It is still raw copy of parent, so invalidate
1546 * destructor and make plain sk_free() */
1547 newsk->sk_destruct = NULL;
b0691c8e 1548 bh_unlock_sock(newsk);
87d11ceb
ACM		 1549 sk_free(newsk);
1550 newsk = NULL;
1551 goto out;
1552 }
1553
1554 newsk->sk_err = 0;
1555 newsk->sk_priority = 0;
2c8c56e1 1556 newsk->sk_incoming_cpu = raw_smp_processor_id();
33cf7c90 1557 atomic64_set(&newsk->sk_cookie, 0);
4dc6dc71
ED		 1558 /*
1559 * Before updating sk_refcnt, we must commit prior changes to memory
1560 * (Documentation/RCU/rculist_nulls.txt for details)
1561 */
1562 smp_wmb();
87d11ceb
ACM		 1563 atomic_set(&newsk->sk_refcnt, 2);
1564
1565 /*
1566 * Increment the counter in the same struct proto as the master
1567 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1568 * is the same as sk->sk_prot->socks, as this field was copied
1569 * with memcpy).
1570 *
1571 * This _changes_ the previous behaviour, where
1572 * tcp_create_openreq_child always was incrementing the
1573 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1574 * to be taken into account in all callers. -acme
1575 */
1576 sk_refcnt_debug_inc(newsk);
972692e0 1577 sk_set_socket(newsk, NULL);
43815482 1578 newsk->sk_wq = NULL;
87d11ceb 1579
f3f511e1
GC		 1580 sk_update_clone(sk, newsk);
1581
87d11ceb 1582 if (newsk->sk_prot->sockets_allocated)
180d8cd9 1583 sk_sockets_allocated_inc(newsk);
704da560 1584
08e29af3 1585 if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
704da560 1586 net_enable_timestamp();
87d11ceb
ACM		 1587 }
1588out:
1589 return newsk;
1590}
e56c57d0 1591EXPORT_SYMBOL_GPL(sk_clone_lock);
87d11ceb 1592
9958089a
AK		 1593void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1594{
d6a4e26a
ED		 1595 u32 max_segs = 1;
1596
9958089a
AK		 1597 __sk_dst_set(sk, dst);
1598 sk->sk_route_caps = dst->dev->features;
1599 if (sk->sk_route_caps & NETIF_F_GSO)
4fcd6b99 1600 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
a465419b 1601 sk->sk_route_caps &= ~sk->sk_route_nocaps;
9958089a 1602 if (sk_can_gso(sk)) {
82cc1a7a 1603 if (dst->header_len) {
9958089a 1604 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
82cc1a7a 1605 } else {
9958089a 1606 sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
82cc1a7a 1607 sk->sk_gso_max_size = dst->dev->gso_max_size;
d6a4e26a 1608 max_segs = max_t(u32, dst->dev->gso_max_segs, 1);
82cc1a7a 1609 }
9958089a 1610 }
d6a4e26a 1611 sk->sk_gso_max_segs = max_segs;
9958089a
AK		 1612}
1613EXPORT_SYMBOL_GPL(sk_setup_caps);
1614
1da177e4
LT		 1615/*
1616 * Simple resource managers for sockets.
1617 */
1618
1619
4ec93edb
YH		 1620/*
1621 * Write buffer destructor automatically called from kfree_skb.
1da177e4
LT		 1622 */
1623void sock_wfree(struct sk_buff *skb)
1624{
1625 struct sock *sk = skb->sk;
d99927f4 1626 unsigned int len = skb->truesize;
1da177e4 1627
d99927f4
ED		 1628 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1629 /*
1630 * Keep a reference on sk_wmem_alloc, this will be released
1631 * after sk_write_space() call
1632 */
1633 atomic_sub(len - 1, &sk->sk_wmem_alloc);
1da177e4 1634 sk->sk_write_space(sk);
d99927f4
ED		 1635 len = 1;
1636 }
2b85a34e 1637 /*
d99927f4
ED		 1638 * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1639 * could not do because of in-flight packets
2b85a34e 1640 */
d99927f4 1641 if (atomic_sub_and_test(len, &sk->sk_wmem_alloc))
2b85a34e 1642 __sk_free(sk);
1da177e4 1643}
2a91525c 1644EXPORT_SYMBOL(sock_wfree);
1da177e4 1645
f2f872f9
ED		 1646void skb_orphan_partial(struct sk_buff *skb)
1647{
1648 /* TCP stack sets skb->ooo_okay based on sk_wmem_alloc,
1649 * so we do not completely orphan skb, but transfert all
1650 * accounted bytes but one, to avoid unexpected reorders.
1651 */
1652 if (skb->destructor == sock_wfree
1653#ifdef CONFIG_INET
1654 || skb->destructor == tcp_wfree
1655#endif
1656 ) {
1657 atomic_sub(skb->truesize - 1, &skb->sk->sk_wmem_alloc);
1658 skb->truesize = 1;
1659 } else {
1660 skb_orphan(skb);
1661 }
1662}
1663EXPORT_SYMBOL(skb_orphan_partial);
1664
4ec93edb
YH		 1665/*
1666 * Read buffer destructor automatically called from kfree_skb.
1da177e4
LT		 1667 */
1668void sock_rfree(struct sk_buff *skb)
1669{
1670 struct sock *sk = skb->sk;
d361fd59 1671 unsigned int len = skb->truesize;
1da177e4 1672
d361fd59
ED		 1673 atomic_sub(len, &sk->sk_rmem_alloc);
1674 sk_mem_uncharge(sk, len);
1da177e4 1675}
2a91525c 1676EXPORT_SYMBOL(sock_rfree);
1da177e4 1677
7768eed8
OH		 1678/*
1679 * Buffer destructor for skbs that are not used directly in read or write
1680 * path, e.g. for error handler skbs. Automatically called from kfree_skb.
1681 */
62bccb8c
AD		 1682void sock_efree(struct sk_buff *skb)
1683{
1684 sock_put(skb->sk);
1685}
1686EXPORT_SYMBOL(sock_efree);
1687
976d0201 1688kuid_t sock_i_uid(struct sock *sk)
1da177e4 1689{
976d0201 1690 kuid_t uid;
1da177e4 1691
f064af1e 1692 read_lock_bh(&sk->sk_callback_lock);
976d0201 1693 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
f064af1e 1694 read_unlock_bh(&sk->sk_callback_lock);
1da177e4
LT		 1695 return uid;
1696}
2a91525c 1697EXPORT_SYMBOL(sock_i_uid);
1da177e4
LT		 1698
1699unsigned long sock_i_ino(struct sock *sk)
1700{
1701 unsigned long ino;
1702
f064af1e 1703 read_lock_bh(&sk->sk_callback_lock);
1da177e4 1704 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
f064af1e 1705 read_unlock_bh(&sk->sk_callback_lock);
1da177e4
LT		 1706 return ino;
1707}
2a91525c 1708EXPORT_SYMBOL(sock_i_ino);
1da177e4
LT		 1709
1710/*
1711 * Allocate a skb from the socket's send buffer.
1712 */
86a76caf 1713struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
dd0fc66f 1714 gfp_t priority)
1da177e4
LT		 1715{
1716 if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
2a91525c 1717 struct sk_buff *skb = alloc_skb(size, priority);
1da177e4
LT		 1718 if (skb) {
1719 skb_set_owner_w(skb, sk);
1720 return skb;
1721 }
1722 }
1723 return NULL;
1724}
2a91525c 1725EXPORT_SYMBOL(sock_wmalloc);
1da177e4 1726
4ec93edb 1727/*
1da177e4 1728 * Allocate a memory block from the socket's option memory buffer.
4ec93edb 1729 */
dd0fc66f 1730void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1da177e4 1731{
95c96174 1732 if ((unsigned int)size <= sysctl_optmem_max &&
1da177e4
LT		 1733 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1734 void *mem;
1735 /* First do the add, to avoid the race if kmalloc
4ec93edb 1736 * might sleep.
1da177e4
LT		 1737 */
1738 atomic_add(size, &sk->sk_omem_alloc);
1739 mem = kmalloc(size, priority);
1740 if (mem)
1741 return mem;
1742 atomic_sub(size, &sk->sk_omem_alloc);
1743 }
1744 return NULL;
1745}
2a91525c 1746EXPORT_SYMBOL(sock_kmalloc);
1da177e4 1747
79e88659
DB		 1748/* Free an option memory block. Note, we actually want the inline
1749 * here as this allows gcc to detect the nullify and fold away the
1750 * condition entirely.
1da177e4 1751 */
79e88659
DB		 1752static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
1753 const bool nullify)
1da177e4 1754{
e53da5fb
DM		 1755 if (WARN_ON_ONCE(!mem))
1756 return;
79e88659
DB		 1757 if (nullify)
1758 kzfree(mem);
1759 else
1760 kfree(mem);
1da177e4
LT		 1761 atomic_sub(size, &sk->sk_omem_alloc);
1762}
79e88659
DB		 1763
1764void sock_kfree_s(struct sock *sk, void *mem, int size)
1765{
1766 __sock_kfree_s(sk, mem, size, false);
1767}
2a91525c 1768EXPORT_SYMBOL(sock_kfree_s);
1da177e4 1769
79e88659
DB		 1770void sock_kzfree_s(struct sock *sk, void *mem, int size)
1771{
1772 __sock_kfree_s(sk, mem, size, true);
1773}
1774EXPORT_SYMBOL(sock_kzfree_s);
1775
1da177e4
LT		 1776/* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1777 I think, these locks should be removed for datagram sockets.
1778 */
2a91525c 1779static long sock_wait_for_wmem(struct sock *sk, long timeo)
1da177e4
LT		 1780{
1781 DEFINE_WAIT(wait);
1782
1783 clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1784 for (;;) {
1785 if (!timeo)
1786 break;
1787 if (signal_pending(current))
1788 break;
1789 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
aa395145 1790 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1da177e4
LT		 1791 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1792 break;
1793 if (sk->sk_shutdown & SEND_SHUTDOWN)
1794 break;
1795 if (sk->sk_err)
1796 break;
1797 timeo = schedule_timeout(timeo);
1798 }
aa395145 1799 finish_wait(sk_sleep(sk), &wait);
1da177e4
LT		 1800 return timeo;
1801}
1802
1803
1804/*
1805 * Generic send/receive buffer handlers
1806 */
1807
4cc7f68d
HX		 1808struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1809 unsigned long data_len, int noblock,
28d64271 1810 int *errcode, int max_page_order)
1da177e4 1811{
2e4e4410 1812 struct sk_buff *skb;
1da177e4
LT		 1813 long timeo;
1814 int err;
1815
1da177e4 1816 timeo = sock_sndtimeo(sk, noblock);
2e4e4410 1817 for (;;) {
1da177e4
LT		 1818 err = sock_error(sk);
1819 if (err != 0)
1820 goto failure;
1821
1822 err = -EPIPE;
1823 if (sk->sk_shutdown & SEND_SHUTDOWN)
1824 goto failure;
1825
2e4e4410
ED		 1826 if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
1827 break;
28d64271 1828
2e4e4410
ED		 1829 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1830 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1831 err = -EAGAIN;
1832 if (!timeo)
1da177e4 1833 goto failure;
2e4e4410
ED		 1834 if (signal_pending(current))
1835 goto interrupted;
1836 timeo = sock_wait_for_wmem(sk, timeo);
1da177e4 1837 }
2e4e4410
ED		 1838 skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
1839 errcode, sk->sk_allocation);
1840 if (skb)
1841 skb_set_owner_w(skb, sk);
1da177e4
LT		 1842 return skb;
1843
1844interrupted:
1845 err = sock_intr_errno(timeo);
1846failure:
1847 *errcode = err;
1848 return NULL;
1849}
4cc7f68d 1850EXPORT_SYMBOL(sock_alloc_send_pskb);
1da177e4 1851
4ec93edb 1852struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1da177e4
LT		 1853 int noblock, int *errcode)
1854{
28d64271 1855 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode, 0);
1da177e4 1856}
2a91525c 1857EXPORT_SYMBOL(sock_alloc_send_skb);
1da177e4 1858
f28ea365
EJ		 1859int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
1860 struct sockcm_cookie *sockc)
1861{
1862 struct cmsghdr *cmsg;
1863
1864 for_each_cmsghdr(cmsg, msg) {
1865 if (!CMSG_OK(msg, cmsg))
1866 return -EINVAL;
1867 if (cmsg->cmsg_level != SOL_SOCKET)
1868 continue;
1869 switch (cmsg->cmsg_type) {
1870 case SO_MARK:
1871 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
1872 return -EPERM;
1873 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
1874 return -EINVAL;
1875 sockc->mark = *(u32 *)CMSG_DATA(cmsg);
1876 break;
1877 default:
1878 return -EINVAL;
1879 }
1880 }
1881 return 0;
1882}
1883EXPORT_SYMBOL(sock_cmsg_send);
1884
5640f768
ED		 1885/* On 32bit arches, an skb frag is limited to 2^15 */
1886#define SKB_FRAG_PAGE_ORDER get_order(32768)
1887
400dfd3a
ED		 1888/**
1889 * skb_page_frag_refill - check that a page_frag contains enough room
1890 * @sz: minimum size of the fragment we want to get
1891 * @pfrag: pointer to page_frag
82d5e2b8 1892 * @gfp: priority for memory allocation
400dfd3a
ED		 1893 *
1894 * Note: While this allocator tries to use high order pages, there is
1895 * no guarantee that allocations succeed. Therefore, @sz MUST be
1896 * less or equal than PAGE_SIZE.
1897 */
d9b2938a 1898bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
5640f768 1899{
5640f768
ED		 1900 if (pfrag->page) {
1901 if (atomic_read(&pfrag->page->_count) == 1) {
1902 pfrag->offset = 0;
1903 return true;
1904 }
400dfd3a 1905 if (pfrag->offset + sz <= pfrag->size)
5640f768
ED		 1906 return true;
1907 put_page(pfrag->page);
1908 }
1909
d9b2938a
ED		 1910 pfrag->offset = 0;
1911 if (SKB_FRAG_PAGE_ORDER) {
fb05e7a8 1912 pfrag->page = alloc_pages((gfp & ~__GFP_WAIT) | __GFP_COMP |
d9b2938a
ED		 1913 __GFP_NOWARN | __GFP_NORETRY,
1914 SKB_FRAG_PAGE_ORDER);
5640f768 1915 if (likely(pfrag->page)) {
d9b2938a 1916 pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
5640f768
ED		 1917 return true;
1918 }
d9b2938a
ED		 1919 }
1920 pfrag->page = alloc_page(gfp);
1921 if (likely(pfrag->page)) {
1922 pfrag->size = PAGE_SIZE;
1923 return true;
1924 }
400dfd3a
ED		 1925 return false;
1926}
1927EXPORT_SYMBOL(skb_page_frag_refill);
1928
1929bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
1930{
1931 if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
1932 return true;
1933
5640f768
ED		 1934 sk_enter_memory_pressure(sk);
1935 sk_stream_moderate_sndbuf(sk);
1936 return false;
1937}
1938EXPORT_SYMBOL(sk_page_frag_refill);
1939
1da177e4 1940static void __lock_sock(struct sock *sk)
f39234d6
NK		 1941 __releases(&sk->sk_lock.slock)
1942 __acquires(&sk->sk_lock.slock)
1da177e4
LT		 1943{
1944 DEFINE_WAIT(wait);
1945
e71a4783 1946 for (;;) {
1da177e4
LT		 1947 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1948 TASK_UNINTERRUPTIBLE);
1949 spin_unlock_bh(&sk->sk_lock.slock);
1950 schedule();
1951 spin_lock_bh(&sk->sk_lock.slock);
e71a4783 1952 if (!sock_owned_by_user(sk))
1da177e4
LT		 1953 break;
1954 }
1955 finish_wait(&sk->sk_lock.wq, &wait);
1956}
1957
1958static void __release_sock(struct sock *sk)
f39234d6
NK		 1959 __releases(&sk->sk_lock.slock)
1960 __acquires(&sk->sk_lock.slock)
1da177e4
LT		 1961{
1962 struct sk_buff *skb = sk->sk_backlog.head;
1963
1964 do {
1965 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1966 bh_unlock_sock(sk);
1967
1968 do {
1969 struct sk_buff *next = skb->next;
1970
e4cbb02a 1971 prefetch(next);
7fee226a 1972 WARN_ON_ONCE(skb_dst_is_noref(skb));
1da177e4 1973 skb->next = NULL;
c57943a1 1974 sk_backlog_rcv(sk, skb);
1da177e4
LT		 1975
1976 /*
1977 * We are in process context here with softirqs
1978 * disabled, use cond_resched_softirq() to preempt.
1979 * This is safe to do because we've taken the backlog
1980 * queue private:
1981 */
1982 cond_resched_softirq();
1983
1984 skb = next;
1985 } while (skb != NULL);
1986
1987 bh_lock_sock(sk);
e71a4783 1988 } while ((skb = sk->sk_backlog.head) != NULL);
8eae939f
ZY		 1989
1990 /*
1991 * Doing the zeroing here guarantee we can not loop forever
1992 * while a wild producer attempts to flood us.
1993 */
1994 sk->sk_backlog.len = 0;
1da177e4
LT		 1995}
1996
1997/**
1998 * sk_wait_data - wait for data to arrive at sk_receive_queue
4dc3b16b
PP		 1999 * @sk: sock to wait on
2000 * @timeo: for how long
dfbafc99 2001 * @skb: last skb seen on sk_receive_queue
1da177e4
LT		 2002 *
2003 * Now socket state including sk->sk_err is changed only under lock,
2004 * hence we may omit checks after joining wait queue.
2005 * We check receive queue before schedule() only as optimization;
2006 * it is very likely that release_sock() added new data.
2007 */
dfbafc99 2008int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
1da177e4
LT		 2009{
2010 int rc;
2011 DEFINE_WAIT(wait);
2012
aa395145 2013 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1da177e4 2014 set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
dfbafc99 2015 rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb);
1da177e4 2016 clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
aa395145 2017 finish_wait(sk_sleep(sk), &wait);
1da177e4
LT		 2018 return rc;
2019}
1da177e4
LT		 2020EXPORT_SYMBOL(sk_wait_data);
2021
3ab224be
HA		 2022/**
2023 * __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
2024 * @sk: socket
2025 * @size: memory size to allocate
2026 * @kind: allocation type
2027 *
2028 * If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
2029 * rmem allocation. This function assumes that protocols which have
2030 * memory_pressure use sk_wmem_queued as write buffer accounting.
2031 */
2032int __sk_mem_schedule(struct sock *sk, int size, int kind)
2033{
2034 struct proto *prot = sk->sk_prot;
2035 int amt = sk_mem_pages(size);
8d987e5c 2036 long allocated;
e1aab161 2037 int parent_status = UNDER_LIMIT;
3ab224be
HA		 2038
2039 sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
180d8cd9 2040
e1aab161 2041 allocated = sk_memory_allocated_add(sk, amt, &parent_status);
3ab224be
HA		 2042
2043 /* Under limit. */
e1aab161
GC		 2044 if (parent_status == UNDER_LIMIT &&
2045 allocated <= sk_prot_mem_limits(sk, 0)) {
180d8cd9 2046 sk_leave_memory_pressure(sk);
3ab224be
HA		 2047 return 1;
2048 }
2049
e1aab161
GC		 2050 /* Under pressure. (we or our parents) */
2051 if ((parent_status > SOFT_LIMIT) ||
2052 allocated > sk_prot_mem_limits(sk, 1))
180d8cd9 2053 sk_enter_memory_pressure(sk);
3ab224be 2054
e1aab161
GC		 2055 /* Over hard limit (we or our parents) */
2056 if ((parent_status == OVER_LIMIT) ||
2057 (allocated > sk_prot_mem_limits(sk, 2)))
3ab224be
HA		 2058 goto suppress_allocation;
2059
2060 /* guarantee minimum buffer size under pressure */
2061 if (kind == SK_MEM_RECV) {
2062 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
2063 return 1;
180d8cd9 2064
3ab224be
HA		 2065 } else { /* SK_MEM_SEND */
2066 if (sk->sk_type == SOCK_STREAM) {
2067 if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
2068 return 1;
2069 } else if (atomic_read(&sk->sk_wmem_alloc) <
2070 prot->sysctl_wmem[0])
2071 return 1;
2072 }
2073
180d8cd9 2074 if (sk_has_memory_pressure(sk)) {
1748376b
ED		 2075 int alloc;
2076
180d8cd9 2077 if (!sk_under_memory_pressure(sk))
1748376b 2078 return 1;
180d8cd9
GC		 2079 alloc = sk_sockets_allocated_read_positive(sk);
2080 if (sk_prot_mem_limits(sk, 2) > alloc *
3ab224be
HA		 2081 sk_mem_pages(sk->sk_wmem_queued +
2082 atomic_read(&sk->sk_rmem_alloc) +
2083 sk->sk_forward_alloc))
2084 return 1;
2085 }
2086
2087suppress_allocation:
2088
2089 if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
2090 sk_stream_moderate_sndbuf(sk);
2091
2092 /* Fail only if socket is _under_ its sndbuf.
2093 * In this case we cannot block, so that we have to fail.
2094 */
2095 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
2096 return 1;
2097 }
2098
3847ce32
SM		 2099 trace_sock_exceed_buf_limit(sk, prot, allocated);
2100
3ab224be
HA		 2101 /* Alas. Undo changes. */
2102 sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
180d8cd9 2103
0e90b31f 2104 sk_memory_allocated_sub(sk, amt);
180d8cd9 2105
3ab224be
HA		 2106 return 0;
2107}
3ab224be
HA		 2108EXPORT_SYMBOL(__sk_mem_schedule);
2109
2110/**
69dba9bb 2111 * __sk_mem_reclaim - reclaim memory_allocated
3ab224be 2112 * @sk: socket
1a24e04e 2113 * @amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)
3ab224be 2114 */
1a24e04e 2115void __sk_mem_reclaim(struct sock *sk, int amount)
3ab224be 2116{
1a24e04e
ED		 2117 amount >>= SK_MEM_QUANTUM_SHIFT;
2118 sk_memory_allocated_sub(sk, amount);
2119 sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
3ab224be 2120
180d8cd9
GC		 2121 if (sk_under_memory_pressure(sk) &&
2122 (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
2123 sk_leave_memory_pressure(sk);
3ab224be 2124}
3ab224be
HA		 2125EXPORT_SYMBOL(__sk_mem_reclaim);
2126
2127
1da177e4
LT		 2128/*
2129 * Set of default routines for initialising struct proto_ops when
2130 * the protocol does not support a particular function. In certain
2131 * cases where it makes no sense for a protocol to have a "do nothing"
2132 * function, some default processing is provided.
2133 */
2134
2135int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
2136{
2137 return -EOPNOTSUPP;
2138}
2a91525c 2139EXPORT_SYMBOL(sock_no_bind);
1da177e4 2140
4ec93edb 2141int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1da177e4
LT		 2142 int len, int flags)
2143{
2144 return -EOPNOTSUPP;
2145}
2a91525c 2146EXPORT_SYMBOL(sock_no_connect);
1da177e4
LT		 2147
2148int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
2149{
2150 return -EOPNOTSUPP;
2151}
2a91525c 2152EXPORT_SYMBOL(sock_no_socketpair);
1da177e4
LT		 2153
2154int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
2155{
2156 return -EOPNOTSUPP;
2157}
2a91525c 2158EXPORT_SYMBOL(sock_no_accept);
1da177e4 2159
4ec93edb 2160int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1da177e4
LT		 2161 int *len, int peer)
2162{
2163 return -EOPNOTSUPP;
2164}
2a91525c 2165EXPORT_SYMBOL(sock_no_getname);
1da177e4 2166
2a91525c 2167unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
1da177e4
LT		 2168{
2169 return 0;
2170}
2a91525c 2171EXPORT_SYMBOL(sock_no_poll);
1da177e4
LT		 2172
2173int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2174{
2175 return -EOPNOTSUPP;
2176}
2a91525c 2177EXPORT_SYMBOL(sock_no_ioctl);
1da177e4
LT		 2178
2179int sock_no_listen(struct socket *sock, int backlog)
2180{
2181 return -EOPNOTSUPP;
2182}
2a91525c 2183EXPORT_SYMBOL(sock_no_listen);
1da177e4
LT		 2184
2185int sock_no_shutdown(struct socket *sock, int how)
2186{
2187 return -EOPNOTSUPP;
2188}
2a91525c 2189EXPORT_SYMBOL(sock_no_shutdown);
1da177e4
LT		 2190
2191int sock_no_setsockopt(struct socket *sock, int level, int optname,
b7058842 2192 char __user *optval, unsigned int optlen)
1da177e4
LT		 2193{
2194 return -EOPNOTSUPP;
2195}
2a91525c 2196EXPORT_SYMBOL(sock_no_setsockopt);
1da177e4
LT		 2197
2198int sock_no_getsockopt(struct socket *sock, int level, int optname,
2199 char __user *optval, int __user *optlen)
2200{
2201 return -EOPNOTSUPP;
2202}
2a91525c 2203EXPORT_SYMBOL(sock_no_getsockopt);
1da177e4 2204
1b784140 2205int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
1da177e4
LT		 2206{
2207 return -EOPNOTSUPP;
2208}
2a91525c 2209EXPORT_SYMBOL(sock_no_sendmsg);
1da177e4 2210
1b784140
YX		 2211int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
2212 int flags)
1da177e4
LT		 2213{
2214 return -EOPNOTSUPP;
2215}
2a91525c 2216EXPORT_SYMBOL(sock_no_recvmsg);
1da177e4
LT		 2217
2218int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
2219{
2220 /* Mirror missing mmap method error code */
2221 return -ENODEV;
2222}
2a91525c 2223EXPORT_SYMBOL(sock_no_mmap);
1da177e4
LT		 2224
2225ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
2226{
2227 ssize_t res;
2228 struct msghdr msg = {.msg_flags = flags};
2229 struct kvec iov;
2230 char *kaddr = kmap(page);
2231 iov.iov_base = kaddr + offset;
2232 iov.iov_len = size;
2233 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
2234 kunmap(page);
2235 return res;
2236}
2a91525c 2237EXPORT_SYMBOL(sock_no_sendpage);
1da177e4
LT		 2238
2239/*
2240 * Default Socket Callbacks
2241 */
2242
2243static void sock_def_wakeup(struct sock *sk)
2244{
43815482
ED		 2245 struct socket_wq *wq;
2246
2247 rcu_read_lock();
2248 wq = rcu_dereference(sk->sk_wq);
2249 if (wq_has_sleeper(wq))
2250 wake_up_interruptible_all(&wq->wait);
2251 rcu_read_unlock();
1da177e4
LT		 2252}
2253
2254static void sock_def_error_report(struct sock *sk)
2255{
43815482
ED		 2256 struct socket_wq *wq;
2257
2258 rcu_read_lock();
2259 wq = rcu_dereference(sk->sk_wq);
2260 if (wq_has_sleeper(wq))
2261 wake_up_interruptible_poll(&wq->wait, POLLERR);
8d8ad9d7 2262 sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
43815482 2263 rcu_read_unlock();
1da177e4
LT		 2264}
2265
676d2369 2266static void sock_def_readable(struct sock *sk)
1da177e4 2267{
43815482
ED		 2268 struct socket_wq *wq;
2269
2270 rcu_read_lock();
2271 wq = rcu_dereference(sk->sk_wq);
2272 if (wq_has_sleeper(wq))
2c6607c6 2273 wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
37e5540b 2274 POLLRDNORM | POLLRDBAND);
8d8ad9d7 2275 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
43815482 2276 rcu_read_unlock();
1da177e4
LT		 2277}
2278
2279static void sock_def_write_space(struct sock *sk)
2280{
43815482
ED		 2281 struct socket_wq *wq;
2282
2283 rcu_read_lock();
1da177e4
LT		 2284
2285 /* Do not wake up a writer until he can make "significant"
2286 * progress. --DaveM
2287 */
e71a4783 2288 if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
43815482
ED		 2289 wq = rcu_dereference(sk->sk_wq);
2290 if (wq_has_sleeper(wq))
2291 wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
37e5540b 2292 POLLWRNORM | POLLWRBAND);
1da177e4
LT		 2293
2294 /* Should agree with poll, otherwise some programs break */
2295 if (sock_writeable(sk))
8d8ad9d7 2296 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
1da177e4
LT		 2297 }
2298
43815482 2299 rcu_read_unlock();
1da177e4
LT		 2300}
2301
2302static void sock_def_destruct(struct sock *sk)
2303{
1da177e4
LT		 2304}
2305
2306void sk_send_sigurg(struct sock *sk)
2307{
2308 if (sk->sk_socket && sk->sk_socket->file)
2309 if (send_sigurg(&sk->sk_socket->file->f_owner))
8d8ad9d7 2310 sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
1da177e4 2311}
2a91525c 2312EXPORT_SYMBOL(sk_send_sigurg);
1da177e4
LT		 2313
2314void sk_reset_timer(struct sock *sk, struct timer_list* timer,
2315 unsigned long expires)
2316{
2317 if (!mod_timer(timer, expires))
2318 sock_hold(sk);
2319}
1da177e4
LT		 2320EXPORT_SYMBOL(sk_reset_timer);
2321
2322void sk_stop_timer(struct sock *sk, struct timer_list* timer)
2323{
25cc4ae9 2324 if (del_timer(timer))
1da177e4
LT		 2325 __sock_put(sk);
2326}
1da177e4
LT		 2327EXPORT_SYMBOL(sk_stop_timer);
2328
2329void sock_init_data(struct socket *sock, struct sock *sk)
2330{
2331 skb_queue_head_init(&sk->sk_receive_queue);
2332 skb_queue_head_init(&sk->sk_write_queue);
2333 skb_queue_head_init(&sk->sk_error_queue);
2334
2335 sk->sk_send_head = NULL;
2336
2337 init_timer(&sk->sk_timer);
4ec93edb 2338
1da177e4
LT		 2339 sk->sk_allocation = GFP_KERNEL;
2340 sk->sk_rcvbuf = sysctl_rmem_default;
2341 sk->sk_sndbuf = sysctl_wmem_default;
2342 sk->sk_state = TCP_CLOSE;
972692e0 2343 sk_set_socket(sk, sock);
1da177e4
LT		 2344
2345 sock_set_flag(sk, SOCK_ZAPPED);
2346
e71a4783 2347 if (sock) {
1da177e4 2348 sk->sk_type = sock->type;
43815482 2349 sk->sk_wq = sock->wq;
1da177e4
LT		 2350 sock->sk = sk;
2351 } else
43815482 2352 sk->sk_wq = NULL;
1da177e4 2353
b6c6712a 2354 spin_lock_init(&sk->sk_dst_lock);
1da177e4 2355 rwlock_init(&sk->sk_callback_lock);
443aef0e
PZ		 2356 lockdep_set_class_and_name(&sk->sk_callback_lock,
2357 af_callback_keys + sk->sk_family,
2358 af_family_clock_key_strings[sk->sk_family]);
1da177e4
LT		 2359
2360 sk->sk_state_change = sock_def_wakeup;
2361 sk->sk_data_ready = sock_def_readable;
2362 sk->sk_write_space = sock_def_write_space;
2363 sk->sk_error_report = sock_def_error_report;
2364 sk->sk_destruct = sock_def_destruct;
2365
5640f768
ED		 2366 sk->sk_frag.page = NULL;
2367 sk->sk_frag.offset = 0;
ef64a54f 2368 sk->sk_peek_off = -1;
1da177e4 2369
109f6e39
EB		 2370 sk->sk_peer_pid = NULL;
2371 sk->sk_peer_cred = NULL;
1da177e4
LT		 2372 sk->sk_write_pending = 0;
2373 sk->sk_rcvlowat = 1;
2374 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
2375 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
2376
f37f0afb 2377 sk->sk_stamp = ktime_set(-1L, 0);
1da177e4 2378
e0d1095a 2379#ifdef CONFIG_NET_RX_BUSY_POLL
06021292 2380 sk->sk_napi_id = 0;
64b0dc51 2381 sk->sk_ll_usec = sysctl_net_busy_read;
06021292
ET		 2382#endif
2383
62748f32 2384 sk->sk_max_pacing_rate = ~0U;
7eec4174 2385 sk->sk_pacing_rate = ~0U;
70da268b 2386 sk->sk_incoming_cpu = -1;
4dc6dc71
ED		 2387 /*
2388 * Before updating sk_refcnt, we must commit prior changes to memory
2389 * (Documentation/RCU/rculist_nulls.txt for details)
2390 */
2391 smp_wmb();
1da177e4 2392 atomic_set(&sk->sk_refcnt, 1);
33c732c3 2393 atomic_set(&sk->sk_drops, 0);
1da177e4 2394}
2a91525c 2395EXPORT_SYMBOL(sock_init_data);
1da177e4 2396
b5606c2d 2397void lock_sock_nested(struct sock *sk, int subclass)
1da177e4
LT		 2398{
2399 might_sleep();
a5b5bb9a 2400 spin_lock_bh(&sk->sk_lock.slock);
d2e9117c 2401 if (sk->sk_lock.owned)
1da177e4 2402 __lock_sock(sk);
d2e9117c 2403 sk->sk_lock.owned = 1;
a5b5bb9a
IM		 2404 spin_unlock(&sk->sk_lock.slock);
2405 /*
2406 * The sk_lock has mutex_lock() semantics here:
2407 */
fcc70d5f 2408 mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
a5b5bb9a 2409 local_bh_enable();
1da177e4 2410}
fcc70d5f 2411EXPORT_SYMBOL(lock_sock_nested);
1da177e4 2412
b5606c2d 2413void release_sock(struct sock *sk)
1da177e4 2414{
a5b5bb9a
IM		 2415 /*
2416 * The sk_lock has mutex_unlock() semantics:
2417 */
2418 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
2419
2420 spin_lock_bh(&sk->sk_lock.slock);
1da177e4
LT		 2421 if (sk->sk_backlog.tail)
2422 __release_sock(sk);
46d3ceab 2423
c3f9b018
ED		 2424 /* Warning : release_cb() might need to release sk ownership,
2425 * ie call sock_release_ownership(sk) before us.
2426 */
46d3ceab
ED		 2427 if (sk->sk_prot->release_cb)
2428 sk->sk_prot->release_cb(sk);
2429
c3f9b018 2430 sock_release_ownership(sk);
a5b5bb9a
IM		 2431 if (waitqueue_active(&sk->sk_lock.wq))
2432 wake_up(&sk->sk_lock.wq);
2433 spin_unlock_bh(&sk->sk_lock.slock);
1da177e4
LT		 2434}
2435EXPORT_SYMBOL(release_sock);
2436
8a74ad60
ED		 2437/**
2438 * lock_sock_fast - fast version of lock_sock
2439 * @sk: socket
2440 *
2441 * This version should be used for very small section, where process wont block
2442 * return false if fast path is taken
2443 * sk_lock.slock locked, owned = 0, BH disabled
2444 * return true if slow path is taken
2445 * sk_lock.slock unlocked, owned = 1, BH enabled
2446 */
2447bool lock_sock_fast(struct sock *sk)
2448{
2449 might_sleep();
2450 spin_lock_bh(&sk->sk_lock.slock);
2451
2452 if (!sk->sk_lock.owned)
2453 /*
2454 * Note : We must disable BH
2455 */
2456 return false;
2457
2458 __lock_sock(sk);
2459 sk->sk_lock.owned = 1;
2460 spin_unlock(&sk->sk_lock.slock);
2461 /*
2462 * The sk_lock has mutex_lock() semantics here:
2463 */
2464 mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
2465 local_bh_enable();
2466 return true;
2467}
2468EXPORT_SYMBOL(lock_sock_fast);
2469
1da177e4 2470int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
4ec93edb 2471{
b7aa0bf7 2472 struct timeval tv;
1da177e4 2473 if (!sock_flag(sk, SOCK_TIMESTAMP))
20d49473 2474 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
b7aa0bf7
ED		 2475 tv = ktime_to_timeval(sk->sk_stamp);
2476 if (tv.tv_sec == -1)
1da177e4 2477 return -ENOENT;
b7aa0bf7
ED		 2478 if (tv.tv_sec == 0) {
2479 sk->sk_stamp = ktime_get_real();
2480 tv = ktime_to_timeval(sk->sk_stamp);
2481 }
2482 return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
4ec93edb 2483}
1da177e4
LT		 2484EXPORT_SYMBOL(sock_get_timestamp);
2485
ae40eb1e
ED		 2486int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2487{
2488 struct timespec ts;
2489 if (!sock_flag(sk, SOCK_TIMESTAMP))
20d49473 2490 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
ae40eb1e
ED		 2491 ts = ktime_to_timespec(sk->sk_stamp);
2492 if (ts.tv_sec == -1)
2493 return -ENOENT;
2494 if (ts.tv_sec == 0) {
2495 sk->sk_stamp = ktime_get_real();
2496 ts = ktime_to_timespec(sk->sk_stamp);
2497 }
2498 return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2499}
2500EXPORT_SYMBOL(sock_get_timestampns);
2501
20d49473 2502void sock_enable_timestamp(struct sock *sk, int flag)
4ec93edb 2503{
20d49473 2504 if (!sock_flag(sk, flag)) {
08e29af3
ED		 2505 unsigned long previous_flags = sk->sk_flags;
2506
20d49473
PO		 2507 sock_set_flag(sk, flag);
2508 /*
2509 * we just set one of the two flags which require net
2510 * time stamping, but time stamping might have been on
2511 * already because of the other one
2512 */
08e29af3 2513 if (!(previous_flags & SK_FLAGS_TIMESTAMP))
20d49473 2514 net_enable_timestamp();
1da177e4
LT		 2515 }
2516}
1da177e4 2517
cb820f8e
RC		 2518int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
2519 int level, int type)
2520{
2521 struct sock_exterr_skb *serr;
364a9e93 2522 struct sk_buff *skb;
cb820f8e
RC		 2523 int copied, err;
2524
2525 err = -EAGAIN;
364a9e93 2526 skb = sock_dequeue_err_skb(sk);
cb820f8e
RC		 2527 if (skb == NULL)
2528 goto out;
2529
2530 copied = skb->len;
2531 if (copied > len) {
2532 msg->msg_flags |= MSG_TRUNC;
2533 copied = len;
2534 }
51f3d02b 2535 err = skb_copy_datagram_msg(skb, 0, msg, copied);
cb820f8e
RC		 2536 if (err)
2537 goto out_free_skb;
2538
2539 sock_recv_timestamp(msg, sk, skb);
2540
2541 serr = SKB_EXT_ERR(skb);
2542 put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
2543
2544 msg->msg_flags |= MSG_ERRQUEUE;
2545 err = copied;
2546
cb820f8e
RC		 2547out_free_skb:
2548 kfree_skb(skb);
2549out:
2550 return err;
2551}
2552EXPORT_SYMBOL(sock_recv_errqueue);
2553
1da177e4
LT		 2554/*
2555 * Get a socket option on an socket.
2556 *
2557 * FIX: POSIX 1003.1g is very ambiguous here. It states that
2558 * asynchronous errors should be reported by getsockopt. We assume
2559 * this means if you specify SO_ERROR (otherwise whats the point of it).
2560 */
2561int sock_common_getsockopt(struct socket *sock, int level, int optname,
2562 char __user *optval, int __user *optlen)
2563{
2564 struct sock *sk = sock->sk;
2565
2566 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2567}
1da177e4
LT		 2568EXPORT_SYMBOL(sock_common_getsockopt);
2569
3fdadf7d 2570#ifdef CONFIG_COMPAT
543d9cfe
ACM		 2571int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
2572 char __user *optval, int __user *optlen)
3fdadf7d
DM		 2573{
2574 struct sock *sk = sock->sk;
2575
1e51f951 2576 if (sk->sk_prot->compat_getsockopt != NULL)
543d9cfe
ACM		 2577 return sk->sk_prot->compat_getsockopt(sk, level, optname,
2578 optval, optlen);
3fdadf7d
DM		 2579 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2580}
2581EXPORT_SYMBOL(compat_sock_common_getsockopt);
2582#endif
2583
1b784140
YX		 2584int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
2585 int flags)
1da177e4
LT		 2586{
2587 struct sock *sk = sock->sk;
2588 int addr_len = 0;
2589 int err;
2590
1b784140 2591 err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
1da177e4
LT		 2592 flags & ~MSG_DONTWAIT, &addr_len);
2593 if (err >= 0)
2594 msg->msg_namelen = addr_len;
2595 return err;
2596}
1da177e4
LT		 2597EXPORT_SYMBOL(sock_common_recvmsg);
2598
2599/*
2600 * Set socket options on an inet socket.
2601 */
2602int sock_common_setsockopt(struct socket *sock, int level, int optname,
b7058842 2603 char __user *optval, unsigned int optlen)
1da177e4
LT		 2604{
2605 struct sock *sk = sock->sk;
2606
2607 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2608}
1da177e4
LT		 2609EXPORT_SYMBOL(sock_common_setsockopt);
2610
3fdadf7d 2611#ifdef CONFIG_COMPAT
543d9cfe 2612int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
b7058842 2613 char __user *optval, unsigned int optlen)
3fdadf7d
DM		 2614{
2615 struct sock *sk = sock->sk;
2616
543d9cfe
ACM		 2617 if (sk->sk_prot->compat_setsockopt != NULL)
2618 return sk->sk_prot->compat_setsockopt(sk, level, optname,
2619 optval, optlen);
3fdadf7d
DM		 2620 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2621}
2622EXPORT_SYMBOL(compat_sock_common_setsockopt);
2623#endif
2624
1da177e4
LT		 2625void sk_common_release(struct sock *sk)
2626{
2627 if (sk->sk_prot->destroy)
2628 sk->sk_prot->destroy(sk);
2629
2630 /*
2631 * Observation: when sock_common_release is called, processes have
2632 * no access to socket. But net still has.
2633 * Step one, detach it from networking:
2634 *
2635 * A. Remove from hash tables.
2636 */
2637
2638 sk->sk_prot->unhash(sk);
2639
2640 /*
2641 * In this point socket cannot receive new packets, but it is possible
2642 * that some packets are in flight because some CPU runs receiver and
2643 * did hash table lookup before we unhashed socket. They will achieve
2644 * receive queue and will be purged by socket destructor.
2645 *
2646 * Also we still have packets pending on receive queue and probably,
2647 * our own packets waiting in device queues. sock_destroy will drain
2648 * receive queue, but transmitted packets will delay socket destruction
2649 * until the last reference will be released.
2650 */
2651
2652 sock_orphan(sk);
2653
2654 xfrm_sk_free_policy(sk);
2655
e6848976 2656 sk_refcnt_debug_release(sk);
5640f768
ED		 2657
2658 if (sk->sk_frag.page) {
2659 put_page(sk->sk_frag.page);
2660 sk->sk_frag.page = NULL;
2661 }
2662
1da177e4
LT		 2663 sock_put(sk);
2664}
1da177e4
LT		 2665EXPORT_SYMBOL(sk_common_release);
2666
13ff3d6f
PE		 2667#ifdef CONFIG_PROC_FS
2668#define PROTO_INUSE_NR 64 /* should be enough for the first time */
1338d466
PE		 2669struct prot_inuse {
2670 int val[PROTO_INUSE_NR];
2671};
13ff3d6f
PE		 2672
2673static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
70ee1159
PE		 2674
2675#ifdef CONFIG_NET_NS
2676void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2677{
d6d9ca0f 2678 __this_cpu_add(net->core.inuse->val[prot->inuse_idx], val);
70ee1159
PE		 2679}
2680EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2681
2682int sock_prot_inuse_get(struct net *net, struct proto *prot)
2683{
2684 int cpu, idx = prot->inuse_idx;
2685 int res = 0;
2686
2687 for_each_possible_cpu(cpu)
2688 res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2689
2690 return res >= 0 ? res : 0;
2691}
2692EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2693
2c8c1e72 2694static int __net_init sock_inuse_init_net(struct net *net)
70ee1159
PE		 2695{
2696 net->core.inuse = alloc_percpu(struct prot_inuse);
2697 return net->core.inuse ? 0 : -ENOMEM;
2698}
2699
2c8c1e72 2700static void __net_exit sock_inuse_exit_net(struct net *net)
70ee1159
PE		 2701{
2702 free_percpu(net->core.inuse);
2703}
2704
2705static struct pernet_operations net_inuse_ops = {
2706 .init = sock_inuse_init_net,
2707 .exit = sock_inuse_exit_net,
2708};
2709
2710static __init int net_inuse_init(void)
2711{
2712 if (register_pernet_subsys(&net_inuse_ops))
2713 panic("Cannot initialize net inuse counters");
2714
2715 return 0;
2716}
2717
2718core_initcall(net_inuse_init);
2719#else
1338d466
PE		 2720static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2721
c29a0bc4 2722void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
1338d466 2723{
d6d9ca0f 2724 __this_cpu_add(prot_inuse.val[prot->inuse_idx], val);
1338d466
PE		 2725}
2726EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2727
c29a0bc4 2728int sock_prot_inuse_get(struct net *net, struct proto *prot)
1338d466
PE		 2729{
2730 int cpu, idx = prot->inuse_idx;
2731 int res = 0;
2732
2733 for_each_possible_cpu(cpu)
2734 res += per_cpu(prot_inuse, cpu).val[idx];
2735
2736 return res >= 0 ? res : 0;
2737}
2738EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
70ee1159 2739#endif
13ff3d6f
PE		 2740
2741static void assign_proto_idx(struct proto *prot)
2742{
2743 prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2744
2745 if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
e005d193 2746 pr_err("PROTO_INUSE_NR exhausted\n");
13ff3d6f
PE		 2747 return;
2748 }
2749
2750 set_bit(prot->inuse_idx, proto_inuse_idx);
2751}
2752
2753static void release_proto_idx(struct proto *prot)
2754{
2755 if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2756 clear_bit(prot->inuse_idx, proto_inuse_idx);
2757}
2758#else
2759static inline void assign_proto_idx(struct proto *prot)
2760{
2761}
2762
2763static inline void release_proto_idx(struct proto *prot)
2764{
2765}
2766#endif
2767
0159dfd3
ED		 2768static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
2769{
2770 if (!rsk_prot)
2771 return;
2772 kfree(rsk_prot->slab_name);
2773 rsk_prot->slab_name = NULL;
adf78eda
JL		 2774 kmem_cache_destroy(rsk_prot->slab);
2775 rsk_prot->slab = NULL;
0159dfd3
ED		 2776}
2777
2778static int req_prot_init(const struct proto *prot)
2779{
2780 struct request_sock_ops *rsk_prot = prot->rsk_prot;
2781
2782 if (!rsk_prot)
2783 return 0;
2784
2785 rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
2786 prot->name);
2787 if (!rsk_prot->slab_name)
2788 return -ENOMEM;
2789
2790 rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
2791 rsk_prot->obj_size, 0,
e96f78ab 2792 prot->slab_flags, NULL);
0159dfd3
ED		 2793
2794 if (!rsk_prot->slab) {
2795 pr_crit("%s: Can't create request sock SLAB cache!\n",
2796 prot->name);
2797 return -ENOMEM;
2798 }
2799 return 0;
2800}
2801
b733c007
PE		 2802int proto_register(struct proto *prot, int alloc_slab)
2803{
1da177e4
LT		 2804 if (alloc_slab) {
2805 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
271b72c7
ED		 2806 SLAB_HWCACHE_ALIGN | prot->slab_flags,
2807 NULL);
1da177e4
LT		 2808
2809 if (prot->slab == NULL) {
e005d193
JP		 2810 pr_crit("%s: Can't create sock SLAB cache!\n",
2811 prot->name);
60e7663d 2812 goto out;
1da177e4 2813 }
2e6599cb 2814
0159dfd3
ED		 2815 if (req_prot_init(prot))
2816 goto out_free_request_sock_slab;
8feaf0c0 2817
6d6ee43e 2818 if (prot->twsk_prot != NULL) {
faf23422 2819 prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
8feaf0c0 2820
7e56b5d6 2821 if (prot->twsk_prot->twsk_slab_name == NULL)
8feaf0c0
ACM		 2822 goto out_free_request_sock_slab;
2823
6d6ee43e 2824 prot->twsk_prot->twsk_slab =
7e56b5d6 2825 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
6d6ee43e 2826 prot->twsk_prot->twsk_obj_size,
3ab5aee7 2827 0,
52db70dc 2828 prot->slab_flags,
20c2df83 2829 NULL);
6d6ee43e 2830 if (prot->twsk_prot->twsk_slab == NULL)
8feaf0c0
ACM		 2831 goto out_free_timewait_sock_slab_name;
2832 }
1da177e4
LT		 2833 }
2834
36b77a52 2835 mutex_lock(&proto_list_mutex);
1da177e4 2836 list_add(&prot->node, &proto_list);
13ff3d6f 2837 assign_proto_idx(prot);
36b77a52 2838 mutex_unlock(&proto_list_mutex);
b733c007
PE		 2839 return 0;
2840
8feaf0c0 2841out_free_timewait_sock_slab_name:
7e56b5d6 2842 kfree(prot->twsk_prot->twsk_slab_name);
8feaf0c0 2843out_free_request_sock_slab:
0159dfd3
ED		 2844 req_prot_cleanup(prot->rsk_prot);
2845
2e6599cb
ACM		 2846 kmem_cache_destroy(prot->slab);
2847 prot->slab = NULL;
b733c007
PE		 2848out:
2849 return -ENOBUFS;
1da177e4 2850}
1da177e4
LT		 2851EXPORT_SYMBOL(proto_register);
2852
2853void proto_unregister(struct proto *prot)
2854{
36b77a52 2855 mutex_lock(&proto_list_mutex);
13ff3d6f 2856 release_proto_idx(prot);
0a3f4358 2857 list_del(&prot->node);
36b77a52 2858 mutex_unlock(&proto_list_mutex);
1da177e4 2859
adf78eda
JL		 2860 kmem_cache_destroy(prot->slab);
2861 prot->slab = NULL;
1da177e4 2862
0159dfd3 2863 req_prot_cleanup(prot->rsk_prot);
2e6599cb 2864
6d6ee43e 2865 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
6d6ee43e 2866 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
7e56b5d6 2867 kfree(prot->twsk_prot->twsk_slab_name);
6d6ee43e 2868 prot->twsk_prot->twsk_slab = NULL;
8feaf0c0 2869 }
1da177e4 2870}
1da177e4
LT		 2871EXPORT_SYMBOL(proto_unregister);
2872
2873#ifdef CONFIG_PROC_FS
1da177e4 2874static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
36b77a52 2875 __acquires(proto_list_mutex)
1da177e4 2876{
36b77a52 2877 mutex_lock(&proto_list_mutex);
60f0438a 2878 return seq_list_start_head(&proto_list, *pos);
1da177e4
LT		 2879}
2880
2881static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2882{
60f0438a 2883 return seq_list_next(v, &proto_list, pos);
1da177e4
LT		 2884}
2885
2886static void proto_seq_stop(struct seq_file *seq, void *v)
36b77a52 2887 __releases(proto_list_mutex)
1da177e4 2888{
36b77a52 2889 mutex_unlock(&proto_list_mutex);
1da177e4
LT		 2890}
2891
2892static char proto_method_implemented(const void *method)
2893{
2894 return method == NULL ? 'n' : 'y';
2895}
180d8cd9
GC		 2896static long sock_prot_memory_allocated(struct proto *proto)
2897{
cb75a36c 2898 return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
180d8cd9
GC		 2899}
2900
2901static char *sock_prot_memory_pressure(struct proto *proto)
2902{
2903 return proto->memory_pressure != NULL ?
2904 proto_memory_pressure(proto) ? "yes" : "no" : "NI";
2905}
1da177e4
LT		 2906
2907static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
2908{
180d8cd9 2909
8d987e5c 2910 seq_printf(seq, "%-9s %4u %6d %6ld %-3s %6u %-3s %-10s "
1da177e4
LT		 2911 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
2912 proto->name,
2913 proto->obj_size,
14e943db 2914 sock_prot_inuse_get(seq_file_net(seq), proto),
180d8cd9
GC		 2915 sock_prot_memory_allocated(proto),
2916 sock_prot_memory_pressure(proto),
1da177e4
LT		 2917 proto->max_header,
2918 proto->slab == NULL ? "no" : "yes",
2919 module_name(proto->owner),
2920 proto_method_implemented(proto->close),
2921 proto_method_implemented(proto->connect),
2922 proto_method_implemented(proto->disconnect),
2923 proto_method_implemented(proto->accept),
2924 proto_method_implemented(proto->ioctl),
2925 proto_method_implemented(proto->init),
2926 proto_method_implemented(proto->destroy),
2927 proto_method_implemented(proto->shutdown),
2928 proto_method_implemented(proto->setsockopt),
2929 proto_method_implemented(proto->getsockopt),
2930 proto_method_implemented(proto->sendmsg),
2931 proto_method_implemented(proto->recvmsg),
2932 proto_method_implemented(proto->sendpage),
2933 proto_method_implemented(proto->bind),
2934 proto_method_implemented(proto->backlog_rcv),
2935 proto_method_implemented(proto->hash),
2936 proto_method_implemented(proto->unhash),
2937 proto_method_implemented(proto->get_port),
2938 proto_method_implemented(proto->enter_memory_pressure));
2939}
2940
2941static int proto_seq_show(struct seq_file *seq, void *v)
2942{
60f0438a 2943 if (v == &proto_list)
1da177e4
LT		 2944 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
2945 "protocol",
2946 "size",
2947 "sockets",
2948 "memory",
2949 "press",
2950 "maxhdr",
2951 "slab",
2952 "module",
2953 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
2954 else
60f0438a 2955 proto_seq_printf(seq, list_entry(v, struct proto, node));
1da177e4
LT		 2956 return 0;
2957}
2958
f690808e 2959static const struct seq_operations proto_seq_ops = {
1da177e4
LT		 2960 .start = proto_seq_start,
2961 .next = proto_seq_next,
2962 .stop = proto_seq_stop,
2963 .show = proto_seq_show,
2964};
2965
2966static int proto_seq_open(struct inode *inode, struct file *file)
2967{
14e943db
ED		 2968 return seq_open_net(inode, file, &proto_seq_ops,
2969 sizeof(struct seq_net_private));
1da177e4
LT		 2970}
2971
9a32144e 2972static const struct file_operations proto_seq_fops = {
1da177e4
LT		 2973 .owner = THIS_MODULE,
2974 .open = proto_seq_open,
2975 .read = seq_read,
2976 .llseek = seq_lseek,
14e943db
ED		 2977 .release = seq_release_net,
2978};
2979
2980static __net_init int proto_init_net(struct net *net)
2981{
d4beaa66 2982 if (!proc_create("protocols", S_IRUGO, net->proc_net, &proto_seq_fops))
14e943db
ED		 2983 return -ENOMEM;
2984
2985 return 0;
2986}
2987
2988static __net_exit void proto_exit_net(struct net *net)
2989{
ece31ffd 2990 remove_proc_entry("protocols", net->proc_net);
14e943db
ED		 2991}
2992
2993
2994static __net_initdata struct pernet_operations proto_net_ops = {
2995 .init = proto_init_net,
2996 .exit = proto_exit_net,
1da177e4
LT		 2997};
2998
2999static int __init proto_init(void)
3000{
14e943db 3001 return register_pernet_subsys(&proto_net_ops);
1da177e4
LT		 3002}
3003
3004subsys_initcall(proto_init);
3005
3006#endif /* PROC_FS */
Linux kernel - Deliverables
This page took 1.69785 seconds and 5 git commands to generate.