?  search:
summary | log | graphiclog1 | graphiclog2 | commit | commitdiff | tree | refs | edit | fork
blame | history | raw | HEAD
ARM: shmobile: defconfig: Enable reset controller support
[linux/fpc-iii.git] / net / core / sock.c
blobbcc41829a16d50714bdd3c25c976c0b7296fab84
1 /*
2 * INET An implementation of the TCP/IP protocol suite for the LINUX
3 * operating system. INET is implemented using the BSD Socket
4 * interface as the means of communication with the user level.
5 *
6 * Generic socket support routines. Memory allocators, socket lock/release
7 * handler for protocols to use and generic option handler.
8 *
9 *
10 * Authors: Ross Biro
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
35 * code. The ACK stuff can wait and needs major
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
92 #define pr_fmt(fmt) KBUILD_MODNAME ": " fmt
93
94 #include <linux/capability.h>
95 #include <linux/errno.h>
96 #include <linux/errqueue.h>
97 #include <linux/types.h>
98 #include <linux/socket.h>
99 #include <linux/in.h>
100 #include <linux/kernel.h>
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/sched/mm.h>
106 #include <linux/timer.h>
107 #include <linux/string.h>
108 #include <linux/sockios.h>
109 #include <linux/net.h>
110 #include <linux/mm.h>
111 #include <linux/slab.h>
112 #include <linux/interrupt.h>
113 #include <linux/poll.h>
114 #include <linux/tcp.h>
115 #include <linux/init.h>
116 #include <linux/highmem.h>
117 #include <linux/user_namespace.h>
118 #include <linux/static_key.h>
119 #include <linux/memcontrol.h>
120 #include <linux/prefetch.h>
121
122 #include <linux/uaccess.h>
123
124 #include <linux/netdevice.h>
125 #include <net/protocol.h>
126 #include <linux/skbuff.h>
127 #include <net/net_namespace.h>
128 #include <net/request_sock.h>
129 #include <net/sock.h>
130 #include <linux/net_tstamp.h>
131 #include <net/xfrm.h>
132 #include <linux/ipsec.h>
133 #include <net/cls_cgroup.h>
134 #include <net/netprio_cgroup.h>
135 #include <linux/sock_diag.h>
136
137 #include <linux/filter.h>
138 #include <net/sock_reuseport.h>
139
140 #include <trace/events/sock.h>
141
142 #include <net/tcp.h>
143 #include <net/busy_poll.h>
144
145 static DEFINE_MUTEX(proto_list_mutex);
146 static LIST_HEAD(proto_list);
147
148 static void sock_inuse_add(struct net *net, int val);
149
150 /**
151 * sk_ns_capable - General socket capability test
152 * @sk: Socket to use a capability on or through
153 * @user_ns: The user namespace of the capability to use
154 * @cap: The capability to use
155 *
156 * Test to see if the opener of the socket had when the socket was
157 * created and the current process has the capability @cap in the user
158 * namespace @user_ns.
159 */
160 bool sk_ns_capable(const struct sock *sk,
161 struct user_namespace *user_ns, int cap)
162 {
163 return file_ns_capable(sk->sk_socket->file, user_ns, cap) &&
164 ns_capable(user_ns, cap);
165 }
166 EXPORT_SYMBOL(sk_ns_capable);
167
168 /**
169 * sk_capable - Socket global capability test
170 * @sk: Socket to use a capability on or through
171 * @cap: The global capability to use
172 *
173 * Test to see if the opener of the socket had when the socket was
174 * created and the current process has the capability @cap in all user
175 * namespaces.
176 */
177 bool sk_capable(const struct sock *sk, int cap)
178 {
179 return sk_ns_capable(sk, &init_user_ns, cap);
180 }
181 EXPORT_SYMBOL(sk_capable);
182
183 /**
184 * sk_net_capable - Network namespace socket capability test
185 * @sk: Socket to use a capability on or through
186 * @cap: The capability to use
187 *
188 * Test to see if the opener of the socket had when the socket was created
189 * and the current process has the capability @cap over the network namespace
190 * the socket is a member of.
191 */
192 bool sk_net_capable(const struct sock *sk, int cap)
193 {
194 return sk_ns_capable(sk, sock_net(sk)->user_ns, cap);
195 }
196 EXPORT_SYMBOL(sk_net_capable);
197
198 /*
199 * Each address family might have different locking rules, so we have
200 * one slock key per address family and separate keys for internal and
201 * userspace sockets.
202 */
203 static struct lock_class_key af_family_keys[AF_MAX];
204 static struct lock_class_key af_family_kern_keys[AF_MAX];
205 static struct lock_class_key af_family_slock_keys[AF_MAX];
206 static struct lock_class_key af_family_kern_slock_keys[AF_MAX];
207
208 /*
209 * Make lock validator output more readable. (we pre-construct these
210 * strings build-time, so that runtime initialization of socket
211 * locks is fast):
212 */
213
214 #define _sock_locks(x) \
215 x "AF_UNSPEC", x "AF_UNIX" , x "AF_INET" , \
216 x "AF_AX25" , x "AF_IPX" , x "AF_APPLETALK", \
217 x "AF_NETROM", x "AF_BRIDGE" , x "AF_ATMPVC" , \
218 x "AF_X25" , x "AF_INET6" , x "AF_ROSE" , \
219 x "AF_DECnet", x "AF_NETBEUI" , x "AF_SECURITY" , \
220 x "AF_KEY" , x "AF_NETLINK" , x "AF_PACKET" , \
221 x "AF_ASH" , x "AF_ECONET" , x "AF_ATMSVC" , \
222 x "AF_RDS" , x "AF_SNA" , x "AF_IRDA" , \
223 x "AF_PPPOX" , x "AF_WANPIPE" , x "AF_LLC" , \
224 x "27" , x "28" , x "AF_CAN" , \
225 x "AF_TIPC" , x "AF_BLUETOOTH", x "IUCV" , \
226 x "AF_RXRPC" , x "AF_ISDN" , x "AF_PHONET" , \
227 x "AF_IEEE802154", x "AF_CAIF" , x "AF_ALG" , \
228 x "AF_NFC" , x "AF_VSOCK" , x "AF_KCM" , \
229 x "AF_QIPCRTR", x "AF_SMC" , x "AF_XDP" , \
230 x "AF_MAX"
231
232 static const char *const af_family_key_strings[AF_MAX+1] = {
233 _sock_locks("sk_lock-")
234 };
235 static const char *const af_family_slock_key_strings[AF_MAX+1] = {
236 _sock_locks("slock-")
237 };
238 static const char *const af_family_clock_key_strings[AF_MAX+1] = {
239 _sock_locks("clock-")
240 };
241
242 static const char *const af_family_kern_key_strings[AF_MAX+1] = {
243 _sock_locks("k-sk_lock-")
244 };
245 static const char *const af_family_kern_slock_key_strings[AF_MAX+1] = {
246 _sock_locks("k-slock-")
247 };
248 static const char *const af_family_kern_clock_key_strings[AF_MAX+1] = {
249 _sock_locks("k-clock-")
250 };
251 static const char *const af_family_rlock_key_strings[AF_MAX+1] = {
252 "rlock-AF_UNSPEC", "rlock-AF_UNIX" , "rlock-AF_INET" ,
253 "rlock-AF_AX25" , "rlock-AF_IPX" , "rlock-AF_APPLETALK",
254 "rlock-AF_NETROM", "rlock-AF_BRIDGE" , "rlock-AF_ATMPVC" ,
255 "rlock-AF_X25" , "rlock-AF_INET6" , "rlock-AF_ROSE" ,
256 "rlock-AF_DECnet", "rlock-AF_NETBEUI" , "rlock-AF_SECURITY" ,
257 "rlock-AF_KEY" , "rlock-AF_NETLINK" , "rlock-AF_PACKET" ,
258 "rlock-AF_ASH" , "rlock-AF_ECONET" , "rlock-AF_ATMSVC" ,
259 "rlock-AF_RDS" , "rlock-AF_SNA" , "rlock-AF_IRDA" ,
260 "rlock-AF_PPPOX" , "rlock-AF_WANPIPE" , "rlock-AF_LLC" ,
261 "rlock-27" , "rlock-28" , "rlock-AF_CAN" ,
262 "rlock-AF_TIPC" , "rlock-AF_BLUETOOTH", "rlock-AF_IUCV" ,
263 "rlock-AF_RXRPC" , "rlock-AF_ISDN" , "rlock-AF_PHONET" ,
264 "rlock-AF_IEEE802154", "rlock-AF_CAIF" , "rlock-AF_ALG" ,
265 "rlock-AF_NFC" , "rlock-AF_VSOCK" , "rlock-AF_KCM" ,
266 "rlock-AF_QIPCRTR", "rlock-AF_SMC" , "rlock-AF_XDP" ,
267 "rlock-AF_MAX"
268 };
269 static const char *const af_family_wlock_key_strings[AF_MAX+1] = {
270 "wlock-AF_UNSPEC", "wlock-AF_UNIX" , "wlock-AF_INET" ,
271 "wlock-AF_AX25" , "wlock-AF_IPX" , "wlock-AF_APPLETALK",
272 "wlock-AF_NETROM", "wlock-AF_BRIDGE" , "wlock-AF_ATMPVC" ,
273 "wlock-AF_X25" , "wlock-AF_INET6" , "wlock-AF_ROSE" ,
274 "wlock-AF_DECnet", "wlock-AF_NETBEUI" , "wlock-AF_SECURITY" ,
275 "wlock-AF_KEY" , "wlock-AF_NETLINK" , "wlock-AF_PACKET" ,
276 "wlock-AF_ASH" , "wlock-AF_ECONET" , "wlock-AF_ATMSVC" ,
277 "wlock-AF_RDS" , "wlock-AF_SNA" , "wlock-AF_IRDA" ,
278 "wlock-AF_PPPOX" , "wlock-AF_WANPIPE" , "wlock-AF_LLC" ,
279 "wlock-27" , "wlock-28" , "wlock-AF_CAN" ,
280 "wlock-AF_TIPC" , "wlock-AF_BLUETOOTH", "wlock-AF_IUCV" ,
281 "wlock-AF_RXRPC" , "wlock-AF_ISDN" , "wlock-AF_PHONET" ,
282 "wlock-AF_IEEE802154", "wlock-AF_CAIF" , "wlock-AF_ALG" ,
283 "wlock-AF_NFC" , "wlock-AF_VSOCK" , "wlock-AF_KCM" ,
284 "wlock-AF_QIPCRTR", "wlock-AF_SMC" , "wlock-AF_XDP" ,
285 "wlock-AF_MAX"
286 };
287 static const char *const af_family_elock_key_strings[AF_MAX+1] = {
288 "elock-AF_UNSPEC", "elock-AF_UNIX" , "elock-AF_INET" ,
289 "elock-AF_AX25" , "elock-AF_IPX" , "elock-AF_APPLETALK",
290 "elock-AF_NETROM", "elock-AF_BRIDGE" , "elock-AF_ATMPVC" ,
291 "elock-AF_X25" , "elock-AF_INET6" , "elock-AF_ROSE" ,
292 "elock-AF_DECnet", "elock-AF_NETBEUI" , "elock-AF_SECURITY" ,
293 "elock-AF_KEY" , "elock-AF_NETLINK" , "elock-AF_PACKET" ,
294 "elock-AF_ASH" , "elock-AF_ECONET" , "elock-AF_ATMSVC" ,
295 "elock-AF_RDS" , "elock-AF_SNA" , "elock-AF_IRDA" ,
296 "elock-AF_PPPOX" , "elock-AF_WANPIPE" , "elock-AF_LLC" ,
297 "elock-27" , "elock-28" , "elock-AF_CAN" ,
298 "elock-AF_TIPC" , "elock-AF_BLUETOOTH", "elock-AF_IUCV" ,
299 "elock-AF_RXRPC" , "elock-AF_ISDN" , "elock-AF_PHONET" ,
300 "elock-AF_IEEE802154", "elock-AF_CAIF" , "elock-AF_ALG" ,
301 "elock-AF_NFC" , "elock-AF_VSOCK" , "elock-AF_KCM" ,
302 "elock-AF_QIPCRTR", "elock-AF_SMC" , "elock-AF_XDP" ,
303 "elock-AF_MAX"
304 };
305
306 /*
307 * sk_callback_lock and sk queues locking rules are per-address-family,
308 * so split the lock classes by using a per-AF key:
309 */
310 static struct lock_class_key af_callback_keys[AF_MAX];
311 static struct lock_class_key af_rlock_keys[AF_MAX];
312 static struct lock_class_key af_wlock_keys[AF_MAX];
313 static struct lock_class_key af_elock_keys[AF_MAX];
314 static struct lock_class_key af_kern_callback_keys[AF_MAX];
315
316 /* Run time adjustable parameters. */
317 __u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
318 EXPORT_SYMBOL(sysctl_wmem_max);
319 __u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
320 EXPORT_SYMBOL(sysctl_rmem_max);
321 __u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
322 __u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
323
324 /* Maximal space eaten by iovec or ancillary data plus some space */
325 int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
326 EXPORT_SYMBOL(sysctl_optmem_max);
327
328 int sysctl_tstamp_allow_data __read_mostly = 1;
329
330 DEFINE_STATIC_KEY_FALSE(memalloc_socks_key);
331 EXPORT_SYMBOL_GPL(memalloc_socks_key);
332
333 /**
334 * sk_set_memalloc - sets %SOCK_MEMALLOC
335 * @sk: socket to set it on
336 *
337 * Set %SOCK_MEMALLOC on a socket for access to emergency reserves.
338 * It's the responsibility of the admin to adjust min_free_kbytes
339 * to meet the requirements
340 */
341 void sk_set_memalloc(struct sock *sk)
342 {
343 sock_set_flag(sk, SOCK_MEMALLOC);
344 sk->sk_allocation |= __GFP_MEMALLOC;
345 static_branch_inc(&memalloc_socks_key);
346 }
347 EXPORT_SYMBOL_GPL(sk_set_memalloc);
348
349 void sk_clear_memalloc(struct sock *sk)
350 {
351 sock_reset_flag(sk, SOCK_MEMALLOC);
352 sk->sk_allocation &= ~__GFP_MEMALLOC;
353 static_branch_dec(&memalloc_socks_key);
354
355 /*
356 * SOCK_MEMALLOC is allowed to ignore rmem limits to ensure forward
357 * progress of swapping. SOCK_MEMALLOC may be cleared while
358 * it has rmem allocations due to the last swapfile being deactivated
359 * but there is a risk that the socket is unusable due to exceeding
360 * the rmem limits. Reclaim the reserves and obey rmem limits again.
361 */
362 sk_mem_reclaim(sk);
363 }
364 EXPORT_SYMBOL_GPL(sk_clear_memalloc);
365
366 int __sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
367 {
368 int ret;
369 unsigned int noreclaim_flag;
370
371 /* these should have been dropped before queueing */
372 BUG_ON(!sock_flag(sk, SOCK_MEMALLOC));
373
374 noreclaim_flag = memalloc_noreclaim_save();
375 ret = sk->sk_backlog_rcv(sk, skb);
376 memalloc_noreclaim_restore(noreclaim_flag);
377
378 return ret;
379 }
380 EXPORT_SYMBOL(__sk_backlog_rcv);
381
382 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
383 {
384 struct timeval tv;
385
386 if (optlen < sizeof(tv))
387 return -EINVAL;
388 if (copy_from_user(&tv, optval, sizeof(tv)))
389 return -EFAULT;
390 if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
391 return -EDOM;
392
393 if (tv.tv_sec < 0) {
394 static int warned __read_mostly;
395
396 *timeo_p = 0;
397 if (warned < 10 && net_ratelimit()) {
398 warned++;
399 pr_info("%s: `%s' (pid %d) tries to set negative timeout\n",
400 __func__, current->comm, task_pid_nr(current));
401 }
402 return 0;
403 }
404 *timeo_p = MAX_SCHEDULE_TIMEOUT;
405 if (tv.tv_sec == 0 && tv.tv_usec == 0)
406 return 0;
407 if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
408 *timeo_p = tv.tv_sec * HZ + DIV_ROUND_UP(tv.tv_usec, USEC_PER_SEC / HZ);
409 return 0;
410 }
411
412 static void sock_warn_obsolete_bsdism(const char *name)
413 {
414 static int warned;
415 static char warncomm[TASK_COMM_LEN];
416 if (strcmp(warncomm, current->comm) && warned < 5) {
417 strcpy(warncomm, current->comm);
418 pr_warn("process `%s' is using obsolete %s SO_BSDCOMPAT\n",
419 warncomm, name);
420 warned++;
421 }
422 }
423
424 static bool sock_needs_netstamp(const struct sock *sk)
425 {
426 switch (sk->sk_family) {
427 case AF_UNSPEC:
428 case AF_UNIX:
429 return false;
430 default:
431 return true;
432 }
433 }
434
435 static void sock_disable_timestamp(struct sock *sk, unsigned long flags)
436 {
437 if (sk->sk_flags & flags) {
438 sk->sk_flags &= ~flags;
439 if (sock_needs_netstamp(sk) &&
440 !(sk->sk_flags & SK_FLAGS_TIMESTAMP))
441 net_disable_timestamp();
442 }
443 }
444
445
446 int __sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
447 {
448 unsigned long flags;
449 struct sk_buff_head *list = &sk->sk_receive_queue;
450
451 if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf) {
452 atomic_inc(&sk->sk_drops);
453 trace_sock_rcvqueue_full(sk, skb);
454 return -ENOMEM;
455 }
456
457 if (!sk_rmem_schedule(sk, skb, skb->truesize)) {
458 atomic_inc(&sk->sk_drops);
459 return -ENOBUFS;
460 }
461
462 skb->dev = NULL;
463 skb_set_owner_r(skb, sk);
464
465 /* we escape from rcu protected region, make sure we dont leak
466 * a norefcounted dst
467 */
468 skb_dst_force(skb);
469
470 spin_lock_irqsave(&list->lock, flags);
471 sock_skb_set_dropcount(sk, skb);
472 __skb_queue_tail(list, skb);
473 spin_unlock_irqrestore(&list->lock, flags);
474
475 if (!sock_flag(sk, SOCK_DEAD))
476 sk->sk_data_ready(sk);
477 return 0;
478 }
479 EXPORT_SYMBOL(__sock_queue_rcv_skb);
480
481 int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
482 {
483 int err;
484
485 err = sk_filter(sk, skb);
486 if (err)
487 return err;
488
489 return __sock_queue_rcv_skb(sk, skb);
490 }
491 EXPORT_SYMBOL(sock_queue_rcv_skb);
492
493 int __sk_receive_skb(struct sock *sk, struct sk_buff *skb,
494 const int nested, unsigned int trim_cap, bool refcounted)
495 {
496 int rc = NET_RX_SUCCESS;
497
498 if (sk_filter_trim_cap(sk, skb, trim_cap))
499 goto discard_and_relse;
500
501 skb->dev = NULL;
502
503 if (sk_rcvqueues_full(sk, sk->sk_rcvbuf)) {
504 atomic_inc(&sk->sk_drops);
505 goto discard_and_relse;
506 }
507 if (nested)
508 bh_lock_sock_nested(sk);
509 else
510 bh_lock_sock(sk);
511 if (!sock_owned_by_user(sk)) {
512 /*
513 * trylock + unlock semantics:
514 */
515 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
516
517 rc = sk_backlog_rcv(sk, skb);
518
519 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
520 } else if (sk_add_backlog(sk, skb, sk->sk_rcvbuf)) {
521 bh_unlock_sock(sk);
522 atomic_inc(&sk->sk_drops);
523 goto discard_and_relse;
524 }
525
526 bh_unlock_sock(sk);
527 out:
528 if (refcounted)
529 sock_put(sk);
530 return rc;
531 discard_and_relse:
532 kfree_skb(skb);
533 goto out;
534 }
535 EXPORT_SYMBOL(__sk_receive_skb);
536
537 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
538 {
539 struct dst_entry *dst = __sk_dst_get(sk);
540
541 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
542 sk_tx_queue_clear(sk);
543 sk->sk_dst_pending_confirm = 0;
544 RCU_INIT_POINTER(sk->sk_dst_cache, NULL);
545 dst_release(dst);
546 return NULL;
547 }
548
549 return dst;
550 }
551 EXPORT_SYMBOL(__sk_dst_check);
552
553 struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
554 {
555 struct dst_entry *dst = sk_dst_get(sk);
556
557 if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
558 sk_dst_reset(sk);
559 dst_release(dst);
560 return NULL;
561 }
562
563 return dst;
564 }
565 EXPORT_SYMBOL(sk_dst_check);
566
567 static int sock_setbindtodevice(struct sock *sk, char __user *optval,
568 int optlen)
569 {
570 int ret = -ENOPROTOOPT;
571 #ifdef CONFIG_NETDEVICES
572 struct net *net = sock_net(sk);
573 char devname[IFNAMSIZ];
574 int index;
575
576 /* Sorry... */
577 ret = -EPERM;
578 if (!ns_capable(net->user_ns, CAP_NET_RAW))
579 goto out;
580
581 ret = -EINVAL;
582 if (optlen < 0)
583 goto out;
584
585 /* Bind this socket to a particular device like "eth0",
586 * as specified in the passed interface name. If the
587 * name is "" or the option length is zero the socket
588 * is not bound.
589 */
590 if (optlen > IFNAMSIZ - 1)
591 optlen = IFNAMSIZ - 1;
592 memset(devname, 0, sizeof(devname));
593
594 ret = -EFAULT;
595 if (copy_from_user(devname, optval, optlen))
596 goto out;
597
598 index = 0;
599 if (devname[0] != '\0') {
600 struct net_device *dev;
601
602 rcu_read_lock();
603 dev = dev_get_by_name_rcu(net, devname);
604 if (dev)
605 index = dev->ifindex;
606 rcu_read_unlock();
607 ret = -ENODEV;
608 if (!dev)
609 goto out;
610 }
611
612 lock_sock(sk);
613 sk->sk_bound_dev_if = index;
614 sk_dst_reset(sk);
615 release_sock(sk);
616
617 ret = 0;
618
619 out:
620 #endif
621
622 return ret;
623 }
624
625 static int sock_getbindtodevice(struct sock *sk, char __user *optval,
626 int __user *optlen, int len)
627 {
628 int ret = -ENOPROTOOPT;
629 #ifdef CONFIG_NETDEVICES
630 struct net *net = sock_net(sk);
631 char devname[IFNAMSIZ];
632
633 if (sk->sk_bound_dev_if == 0) {
634 len = 0;
635 goto zero;
636 }
637
638 ret = -EINVAL;
639 if (len < IFNAMSIZ)
640 goto out;
641
642 ret = netdev_get_name(net, devname, sk->sk_bound_dev_if);
643 if (ret)
644 goto out;
645
646 len = strlen(devname) + 1;
647
648 ret = -EFAULT;
649 if (copy_to_user(optval, devname, len))
650 goto out;
651
652 zero:
653 ret = -EFAULT;
654 if (put_user(len, optlen))
655 goto out;
656
657 ret = 0;
658
659 out:
660 #endif
661
662 return ret;
663 }
664
665 static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
666 {
667 if (valbool)
668 sock_set_flag(sk, bit);
669 else
670 sock_reset_flag(sk, bit);
671 }
672
673 bool sk_mc_loop(struct sock *sk)
674 {
675 if (dev_recursion_level())
676 return false;
677 if (!sk)
678 return true;
679 switch (sk->sk_family) {
680 case AF_INET:
681 return inet_sk(sk)->mc_loop;
682 #if IS_ENABLED(CONFIG_IPV6)
683 case AF_INET6:
684 return inet6_sk(sk)->mc_loop;
685 #endif
686 }
687 WARN_ON(1);
688 return true;
689 }
690 EXPORT_SYMBOL(sk_mc_loop);
691
692 /*
693 * This is meant for all protocols to use and covers goings on
694 * at the socket level. Everything here is generic.
695 */
696
697 int sock_setsockopt(struct socket *sock, int level, int optname,
698 char __user *optval, unsigned int optlen)
699 {
700 struct sock *sk = sock->sk;
701 int val;
702 int valbool;
703 struct linger ling;
704 int ret = 0;
705
706 /*
707 * Options without arguments
708 */
709
710 if (optname == SO_BINDTODEVICE)
711 return sock_setbindtodevice(sk, optval, optlen);
712
713 if (optlen < sizeof(int))
714 return -EINVAL;
715
716 if (get_user(val, (int __user *)optval))
717 return -EFAULT;
718
719 valbool = val ? 1 : 0;
720
721 lock_sock(sk);
722
723 switch (optname) {
724 case SO_DEBUG:
725 if (val && !capable(CAP_NET_ADMIN))
726 ret = -EACCES;
727 else
728 sock_valbool_flag(sk, SOCK_DBG, valbool);
729 break;
730 case SO_REUSEADDR:
731 sk->sk_reuse = (valbool ? SK_CAN_REUSE : SK_NO_REUSE);
732 break;
733 case SO_REUSEPORT:
734 sk->sk_reuseport = valbool;
735 break;
736 case SO_TYPE:
737 case SO_PROTOCOL:
738 case SO_DOMAIN:
739 case SO_ERROR:
740 ret = -ENOPROTOOPT;
741 break;
742 case SO_DONTROUTE:
743 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
744 break;
745 case SO_BROADCAST:
746 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
747 break;
748 case SO_SNDBUF:
749 /* Don't error on this BSD doesn't and if you think
750 * about it this is right. Otherwise apps have to
751 * play 'guess the biggest size' games. RCVBUF/SNDBUF
752 * are treated in BSD as hints
753 */
754 val = min_t(u32, val, sysctl_wmem_max);
755 set_sndbuf:
756 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
757 sk->sk_sndbuf = max_t(int, val * 2, SOCK_MIN_SNDBUF);
758 /* Wake up sending tasks if we upped the value. */
759 sk->sk_write_space(sk);
760 break;
761
762 case SO_SNDBUFFORCE:
763 if (!capable(CAP_NET_ADMIN)) {
764 ret = -EPERM;
765 break;
766 }
767 goto set_sndbuf;
768
769 case SO_RCVBUF:
770 /* Don't error on this BSD doesn't and if you think
771 * about it this is right. Otherwise apps have to
772 * play 'guess the biggest size' games. RCVBUF/SNDBUF
773 * are treated in BSD as hints
774 */
775 val = min_t(u32, val, sysctl_rmem_max);
776 set_rcvbuf:
777 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
778 /*
779 * We double it on the way in to account for
780 * "struct sk_buff" etc. overhead. Applications
781 * assume that the SO_RCVBUF setting they make will
782 * allow that much actual data to be received on that
783 * socket.
784 *
785 * Applications are unaware that "struct sk_buff" and
786 * other overheads allocate from the receive buffer
787 * during socket buffer allocation.
788 *
789 * And after considering the possible alternatives,
790 * returning the value we actually used in getsockopt
791 * is the most desirable behavior.
792 */
793 sk->sk_rcvbuf = max_t(int, val * 2, SOCK_MIN_RCVBUF);
794 break;
795
796 case SO_RCVBUFFORCE:
797 if (!capable(CAP_NET_ADMIN)) {
798 ret = -EPERM;
799 break;
800 }
801 goto set_rcvbuf;
802
803 case SO_KEEPALIVE:
804 if (sk->sk_prot->keepalive)
805 sk->sk_prot->keepalive(sk, valbool);
806 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
807 break;
808
809 case SO_OOBINLINE:
810 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
811 break;
812
813 case SO_NO_CHECK:
814 sk->sk_no_check_tx = valbool;
815 break;
816
817 case SO_PRIORITY:
818 if ((val >= 0 && val <= 6) ||
819 ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
820 sk->sk_priority = val;
821 else
822 ret = -EPERM;
823 break;
824
825 case SO_LINGER:
826 if (optlen < sizeof(ling)) {
827 ret = -EINVAL; /* 1003.1g */
828 break;
829 }
830 if (copy_from_user(&ling, optval, sizeof(ling))) {
831 ret = -EFAULT;
832 break;
833 }
834 if (!ling.l_onoff)
835 sock_reset_flag(sk, SOCK_LINGER);
836 else {
837 #if (BITS_PER_LONG == 32)
838 if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
839 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
840 else
841 #endif
842 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
843 sock_set_flag(sk, SOCK_LINGER);
844 }
845 break;
846
847 case SO_BSDCOMPAT:
848 sock_warn_obsolete_bsdism("setsockopt");
849 break;
850
851 case SO_PASSCRED:
852 if (valbool)
853 set_bit(SOCK_PASSCRED, &sock->flags);
854 else
855 clear_bit(SOCK_PASSCRED, &sock->flags);
856 break;
857
858 case SO_TIMESTAMP:
859 case SO_TIMESTAMPNS:
860 if (valbool) {
861 if (optname == SO_TIMESTAMP)
862 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
863 else
864 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
865 sock_set_flag(sk, SOCK_RCVTSTAMP);
866 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
867 } else {
868 sock_reset_flag(sk, SOCK_RCVTSTAMP);
869 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
870 }
871 break;
872
873 case SO_TIMESTAMPING:
874 if (val & ~SOF_TIMESTAMPING_MASK) {
875 ret = -EINVAL;
876 break;
877 }
878
879 if (val & SOF_TIMESTAMPING_OPT_ID &&
880 !(sk->sk_tsflags & SOF_TIMESTAMPING_OPT_ID)) {
881 if (sk->sk_protocol == IPPROTO_TCP &&
882 sk->sk_type == SOCK_STREAM) {
883 if ((1 << sk->sk_state) &
884 (TCPF_CLOSE | TCPF_LISTEN)) {
885 ret = -EINVAL;
886 break;
887 }
888 sk->sk_tskey = tcp_sk(sk)->snd_una;
889 } else {
890 sk->sk_tskey = 0;
891 }
892 }
893
894 if (val & SOF_TIMESTAMPING_OPT_STATS &&
895 !(val & SOF_TIMESTAMPING_OPT_TSONLY)) {
896 ret = -EINVAL;
897 break;
898 }
899
900 sk->sk_tsflags = val;
901 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
902 sock_enable_timestamp(sk,
903 SOCK_TIMESTAMPING_RX_SOFTWARE);
904 else
905 sock_disable_timestamp(sk,
906 (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE));
907 break;
908
909 case SO_RCVLOWAT:
910 if (val < 0)
911 val = INT_MAX;
912 if (sock->ops->set_rcvlowat)
913 ret = sock->ops->set_rcvlowat(sk, val);
914 else
915 sk->sk_rcvlowat = val ? : 1;
916 break;
917
918 case SO_RCVTIMEO:
919 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
920 break;
921
922 case SO_SNDTIMEO:
923 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
924 break;
925
926 case SO_ATTACH_FILTER:
927 ret = -EINVAL;
928 if (optlen == sizeof(struct sock_fprog)) {
929 struct sock_fprog fprog;
930
931 ret = -EFAULT;
932 if (copy_from_user(&fprog, optval, sizeof(fprog)))
933 break;
934
935 ret = sk_attach_filter(&fprog, sk);
936 }
937 break;
938
939 case SO_ATTACH_BPF:
940 ret = -EINVAL;
941 if (optlen == sizeof(u32)) {
942 u32 ufd;
943
944 ret = -EFAULT;
945 if (copy_from_user(&ufd, optval, sizeof(ufd)))
946 break;
947
948 ret = sk_attach_bpf(ufd, sk);
949 }
950 break;
951
952 case SO_ATTACH_REUSEPORT_CBPF:
953 ret = -EINVAL;
954 if (optlen == sizeof(struct sock_fprog)) {
955 struct sock_fprog fprog;
956
957 ret = -EFAULT;
958 if (copy_from_user(&fprog, optval, sizeof(fprog)))
959 break;
960
961 ret = sk_reuseport_attach_filter(&fprog, sk);
962 }
963 break;
964
965 case SO_ATTACH_REUSEPORT_EBPF:
966 ret = -EINVAL;
967 if (optlen == sizeof(u32)) {
968 u32 ufd;
969
970 ret = -EFAULT;
971 if (copy_from_user(&ufd, optval, sizeof(ufd)))
972 break;
973
974 ret = sk_reuseport_attach_bpf(ufd, sk);
975 }
976 break;
977
978 case SO_DETACH_FILTER:
979 ret = sk_detach_filter(sk);
980 break;
981
982 case SO_LOCK_FILTER:
983 if (sock_flag(sk, SOCK_FILTER_LOCKED) && !valbool)
984 ret = -EPERM;
985 else
986 sock_valbool_flag(sk, SOCK_FILTER_LOCKED, valbool);
987 break;
988
989 case SO_PASSSEC:
990 if (valbool)
991 set_bit(SOCK_PASSSEC, &sock->flags);
992 else
993 clear_bit(SOCK_PASSSEC, &sock->flags);
994 break;
995 case SO_MARK:
996 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
997 ret = -EPERM;
998 else
999 sk->sk_mark = val;
1000 break;
1001
1002 case SO_RXQ_OVFL:
1003 sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
1004 break;
1005
1006 case SO_WIFI_STATUS:
1007 sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
1008 break;
1009
1010 case SO_PEEK_OFF:
1011 if (sock->ops->set_peek_off)
1012 ret = sock->ops->set_peek_off(sk, val);
1013 else
1014 ret = -EOPNOTSUPP;
1015 break;
1016
1017 case SO_NOFCS:
1018 sock_valbool_flag(sk, SOCK_NOFCS, valbool);
1019 break;
1020
1021 case SO_SELECT_ERR_QUEUE:
1022 sock_valbool_flag(sk, SOCK_SELECT_ERR_QUEUE, valbool);
1023 break;
1024
1025 #ifdef CONFIG_NET_RX_BUSY_POLL
1026 case SO_BUSY_POLL:
1027 /* allow unprivileged users to decrease the value */
1028 if ((val > sk->sk_ll_usec) && !capable(CAP_NET_ADMIN))
1029 ret = -EPERM;
1030 else {
1031 if (val < 0)
1032 ret = -EINVAL;
1033 else
1034 sk->sk_ll_usec = val;
1035 }
1036 break;
1037 #endif
1038
1039 case SO_MAX_PACING_RATE:
1040 if (val != ~0U)
1041 cmpxchg(&sk->sk_pacing_status,
1042 SK_PACING_NONE,
1043 SK_PACING_NEEDED);
1044 sk->sk_max_pacing_rate = val;
1045 sk->sk_pacing_rate = min(sk->sk_pacing_rate,
1046 sk->sk_max_pacing_rate);
1047 break;
1048
1049 case SO_INCOMING_CPU:
1050 sk->sk_incoming_cpu = val;
1051 break;
1052
1053 case SO_CNX_ADVICE:
1054 if (val == 1)
1055 dst_negative_advice(sk);
1056 break;
1057
1058 case SO_ZEROCOPY:
1059 if (sk->sk_family == PF_INET || sk->sk_family == PF_INET6) {
1060 if (sk->sk_protocol != IPPROTO_TCP)
1061 ret = -ENOTSUPP;
1062 } else if (sk->sk_family != PF_RDS) {
1063 ret = -ENOTSUPP;
1064 }
1065 if (!ret) {
1066 if (val < 0 || val > 1)
1067 ret = -EINVAL;
1068 else
1069 sock_valbool_flag(sk, SOCK_ZEROCOPY, valbool);
1070 }
1071 break;
1072
1073 default:
1074 ret = -ENOPROTOOPT;
1075 break;
1076 }
1077 release_sock(sk);
1078 return ret;
1079 }
1080 EXPORT_SYMBOL(sock_setsockopt);
1081
1082
1083 static void cred_to_ucred(struct pid *pid, const struct cred *cred,
1084 struct ucred *ucred)
1085 {
1086 ucred->pid = pid_vnr(pid);
1087 ucred->uid = ucred->gid = -1;
1088 if (cred) {
1089 struct user_namespace *current_ns = current_user_ns();
1090
1091 ucred->uid = from_kuid_munged(current_ns, cred->euid);
1092 ucred->gid = from_kgid_munged(current_ns, cred->egid);
1093 }
1094 }
1095
1096 static int groups_to_user(gid_t __user *dst, const struct group_info *src)
1097 {
1098 struct user_namespace *user_ns = current_user_ns();
1099 int i;
1100
1101 for (i = 0; i < src->ngroups; i++)
1102 if (put_user(from_kgid_munged(user_ns, src->gid[i]), dst + i))
1103 return -EFAULT;
1104
1105 return 0;
1106 }
1107
1108 int sock_getsockopt(struct socket *sock, int level, int optname,
1109 char __user *optval, int __user *optlen)
1110 {
1111 struct sock *sk = sock->sk;
1112
1113 union {
1114 int val;
1115 u64 val64;
1116 struct linger ling;
1117 struct timeval tm;
1118 } v;
1119
1120 int lv = sizeof(int);
1121 int len;
1122
1123 if (get_user(len, optlen))
1124 return -EFAULT;
1125 if (len < 0)
1126 return -EINVAL;
1127
1128 memset(&v, 0, sizeof(v));
1129
1130 switch (optname) {
1131 case SO_DEBUG:
1132 v.val = sock_flag(sk, SOCK_DBG);
1133 break;
1134
1135 case SO_DONTROUTE:
1136 v.val = sock_flag(sk, SOCK_LOCALROUTE);
1137 break;
1138
1139 case SO_BROADCAST:
1140 v.val = sock_flag(sk, SOCK_BROADCAST);
1141 break;
1142
1143 case SO_SNDBUF:
1144 v.val = sk->sk_sndbuf;
1145 break;
1146
1147 case SO_RCVBUF:
1148 v.val = sk->sk_rcvbuf;
1149 break;
1150
1151 case SO_REUSEADDR:
1152 v.val = sk->sk_reuse;
1153 break;
1154
1155 case SO_REUSEPORT:
1156 v.val = sk->sk_reuseport;
1157 break;
1158
1159 case SO_KEEPALIVE:
1160 v.val = sock_flag(sk, SOCK_KEEPOPEN);
1161 break;
1162
1163 case SO_TYPE:
1164 v.val = sk->sk_type;
1165 break;
1166
1167 case SO_PROTOCOL:
1168 v.val = sk->sk_protocol;
1169 break;
1170
1171 case SO_DOMAIN:
1172 v.val = sk->sk_family;
1173 break;
1174
1175 case SO_ERROR:
1176 v.val = -sock_error(sk);
1177 if (v.val == 0)
1178 v.val = xchg(&sk->sk_err_soft, 0);
1179 break;
1180
1181 case SO_OOBINLINE:
1182 v.val = sock_flag(sk, SOCK_URGINLINE);
1183 break;
1184
1185 case SO_NO_CHECK:
1186 v.val = sk->sk_no_check_tx;
1187 break;
1188
1189 case SO_PRIORITY:
1190 v.val = sk->sk_priority;
1191 break;
1192
1193 case SO_LINGER:
1194 lv = sizeof(v.ling);
1195 v.ling.l_onoff = sock_flag(sk, SOCK_LINGER);
1196 v.ling.l_linger = sk->sk_lingertime / HZ;
1197 break;
1198
1199 case SO_BSDCOMPAT:
1200 sock_warn_obsolete_bsdism("getsockopt");
1201 break;
1202
1203 case SO_TIMESTAMP:
1204 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
1205 !sock_flag(sk, SOCK_RCVTSTAMPNS);
1206 break;
1207
1208 case SO_TIMESTAMPNS:
1209 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
1210 break;
1211
1212 case SO_TIMESTAMPING:
1213 v.val = sk->sk_tsflags;
1214 break;
1215
1216 case SO_RCVTIMEO:
1217 lv = sizeof(struct timeval);
1218 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
1219 v.tm.tv_sec = 0;
1220 v.tm.tv_usec = 0;
1221 } else {
1222 v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
1223 v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * USEC_PER_SEC) / HZ;
1224 }
1225 break;
1226
1227 case SO_SNDTIMEO:
1228 lv = sizeof(struct timeval);
1229 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
1230 v.tm.tv_sec = 0;
1231 v.tm.tv_usec = 0;
1232 } else {
1233 v.tm.tv_sec = sk->sk_sndtimeo / HZ;
1234 v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * USEC_PER_SEC) / HZ;
1235 }
1236 break;
1237
1238 case SO_RCVLOWAT:
1239 v.val = sk->sk_rcvlowat;
1240 break;
1241
1242 case SO_SNDLOWAT:
1243 v.val = 1;
1244 break;
1245
1246 case SO_PASSCRED:
1247 v.val = !!test_bit(SOCK_PASSCRED, &sock->flags);
1248 break;
1249
1250 case SO_PEERCRED:
1251 {
1252 struct ucred peercred;
1253 if (len > sizeof(peercred))
1254 len = sizeof(peercred);
1255 cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred, &peercred);
1256 if (copy_to_user(optval, &peercred, len))
1257 return -EFAULT;
1258 goto lenout;
1259 }
1260
1261 case SO_PEERGROUPS:
1262 {
1263 int ret, n;
1264
1265 if (!sk->sk_peer_cred)
1266 return -ENODATA;
1267
1268 n = sk->sk_peer_cred->group_info->ngroups;
1269 if (len < n * sizeof(gid_t)) {
1270 len = n * sizeof(gid_t);
1271 return put_user(len, optlen) ? -EFAULT : -ERANGE;
1272 }
1273 len = n * sizeof(gid_t);
1274
1275 ret = groups_to_user((gid_t __user *)optval,
1276 sk->sk_peer_cred->group_info);
1277 if (ret)
1278 return ret;
1279 goto lenout;
1280 }
1281
1282 case SO_PEERNAME:
1283 {
1284 char address[128];
1285
1286 lv = sock->ops->getname(sock, (struct sockaddr *)address, 2);
1287 if (lv < 0)
1288 return -ENOTCONN;
1289 if (lv < len)
1290 return -EINVAL;
1291 if (copy_to_user(optval, address, len))
1292 return -EFAULT;
1293 goto lenout;
1294 }
1295
1296 /* Dubious BSD thing... Probably nobody even uses it, but
1297 * the UNIX standard wants it for whatever reason... -DaveM
1298 */
1299 case SO_ACCEPTCONN:
1300 v.val = sk->sk_state == TCP_LISTEN;
1301 break;
1302
1303 case SO_PASSSEC:
1304 v.val = !!test_bit(SOCK_PASSSEC, &sock->flags);
1305 break;
1306
1307 case SO_PEERSEC:
1308 return security_socket_getpeersec_stream(sock, optval, optlen, len);
1309
1310 case SO_MARK:
1311 v.val = sk->sk_mark;
1312 break;
1313
1314 case SO_RXQ_OVFL:
1315 v.val = sock_flag(sk, SOCK_RXQ_OVFL);
1316 break;
1317
1318 case SO_WIFI_STATUS:
1319 v.val = sock_flag(sk, SOCK_WIFI_STATUS);
1320 break;
1321
1322 case SO_PEEK_OFF:
1323 if (!sock->ops->set_peek_off)
1324 return -EOPNOTSUPP;
1325
1326 v.val = sk->sk_peek_off;
1327 break;
1328 case SO_NOFCS:
1329 v.val = sock_flag(sk, SOCK_NOFCS);
1330 break;
1331
1332 case SO_BINDTODEVICE:
1333 return sock_getbindtodevice(sk, optval, optlen, len);
1334
1335 case SO_GET_FILTER:
1336 len = sk_get_filter(sk, (struct sock_filter __user *)optval, len);
1337 if (len < 0)
1338 return len;
1339
1340 goto lenout;
1341
1342 case SO_LOCK_FILTER:
1343 v.val = sock_flag(sk, SOCK_FILTER_LOCKED);
1344 break;
1345
1346 case SO_BPF_EXTENSIONS:
1347 v.val = bpf_tell_extensions();
1348 break;
1349
1350 case SO_SELECT_ERR_QUEUE:
1351 v.val = sock_flag(sk, SOCK_SELECT_ERR_QUEUE);
1352 break;
1353
1354 #ifdef CONFIG_NET_RX_BUSY_POLL
1355 case SO_BUSY_POLL:
1356 v.val = sk->sk_ll_usec;
1357 break;
1358 #endif
1359
1360 case SO_MAX_PACING_RATE:
1361 v.val = sk->sk_max_pacing_rate;
1362 break;
1363
1364 case SO_INCOMING_CPU:
1365 v.val = sk->sk_incoming_cpu;
1366 break;
1367
1368 case SO_MEMINFO:
1369 {
1370 u32 meminfo[SK_MEMINFO_VARS];
1371
1372 if (get_user(len, optlen))
1373 return -EFAULT;
1374
1375 sk_get_meminfo(sk, meminfo);
1376
1377 len = min_t(unsigned int, len, sizeof(meminfo));
1378 if (copy_to_user(optval, &meminfo, len))
1379 return -EFAULT;
1380
1381 goto lenout;
1382 }
1383
1384 #ifdef CONFIG_NET_RX_BUSY_POLL
1385 case SO_INCOMING_NAPI_ID:
1386 v.val = READ_ONCE(sk->sk_napi_id);
1387
1388 /* aggregate non-NAPI IDs down to 0 */
1389 if (v.val < MIN_NAPI_ID)
1390 v.val = 0;
1391
1392 break;
1393 #endif
1394
1395 case SO_COOKIE:
1396 lv = sizeof(u64);
1397 if (len < lv)
1398 return -EINVAL;
1399 v.val64 = sock_gen_cookie(sk);
1400 break;
1401
1402 case SO_ZEROCOPY:
1403 v.val = sock_flag(sk, SOCK_ZEROCOPY);
1404 break;
1405
1406 default:
1407 /* We implement the SO_SNDLOWAT etc to not be settable
1408 * (1003.1g 7).
1409 */
1410 return -ENOPROTOOPT;
1411 }
1412
1413 if (len > lv)
1414 len = lv;
1415 if (copy_to_user(optval, &v, len))
1416 return -EFAULT;
1417 lenout:
1418 if (put_user(len, optlen))
1419 return -EFAULT;
1420 return 0;
1421 }
1422
1423 /*
1424 * Initialize an sk_lock.
1425 *
1426 * (We also register the sk_lock with the lock validator.)
1427 */
1428 static inline void sock_lock_init(struct sock *sk)
1429 {
1430 if (sk->sk_kern_sock)
1431 sock_lock_init_class_and_name(
1432 sk,
1433 af_family_kern_slock_key_strings[sk->sk_family],
1434 af_family_kern_slock_keys + sk->sk_family,
1435 af_family_kern_key_strings[sk->sk_family],
1436 af_family_kern_keys + sk->sk_family);
1437 else
1438 sock_lock_init_class_and_name(
1439 sk,
1440 af_family_slock_key_strings[sk->sk_family],
1441 af_family_slock_keys + sk->sk_family,
1442 af_family_key_strings[sk->sk_family],
1443 af_family_keys + sk->sk_family);
1444 }
1445
1446 /*
1447 * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
1448 * even temporarly, because of RCU lookups. sk_node should also be left as is.
1449 * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
1450 */
1451 static void sock_copy(struct sock *nsk, const struct sock *osk)
1452 {
1453 #ifdef CONFIG_SECURITY_NETWORK
1454 void *sptr = nsk->sk_security;
1455 #endif
1456 memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
1457
1458 memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
1459 osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
1460
1461 #ifdef CONFIG_SECURITY_NETWORK
1462 nsk->sk_security = sptr;
1463 security_sk_clone(osk, nsk);
1464 #endif
1465 }
1466
1467 static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
1468 int family)
1469 {
1470 struct sock *sk;
1471 struct kmem_cache *slab;
1472
1473 slab = prot->slab;
1474 if (slab != NULL) {
1475 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
1476 if (!sk)
1477 return sk;
1478 if (priority & __GFP_ZERO)
1479 sk_prot_clear_nulls(sk, prot->obj_size);
1480 } else
1481 sk = kmalloc(prot->obj_size, priority);
1482
1483 if (sk != NULL) {
1484 if (security_sk_alloc(sk, family, priority))
1485 goto out_free;
1486
1487 if (!try_module_get(prot->owner))
1488 goto out_free_sec;
1489 sk_tx_queue_clear(sk);
1490 }
1491
1492 return sk;
1493
1494 out_free_sec:
1495 security_sk_free(sk);
1496 out_free:
1497 if (slab != NULL)
1498 kmem_cache_free(slab, sk);
1499 else
1500 kfree(sk);
1501 return NULL;
1502 }
1503
1504 static void sk_prot_free(struct proto *prot, struct sock *sk)
1505 {
1506 struct kmem_cache *slab;
1507 struct module *owner;
1508
1509 owner = prot->owner;
1510 slab = prot->slab;
1511
1512 cgroup_sk_free(&sk->sk_cgrp_data);
1513 mem_cgroup_sk_free(sk);
1514 security_sk_free(sk);
1515 if (slab != NULL)
1516 kmem_cache_free(slab, sk);
1517 else
1518 kfree(sk);
1519 module_put(owner);
1520 }
1521
1522 /**
1523 * sk_alloc - All socket objects are allocated here
1524 * @net: the applicable net namespace
1525 * @family: protocol family
1526 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1527 * @prot: struct proto associated with this new sock instance
1528 * @kern: is this to be a kernel socket?
1529 */
1530 struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
1531 struct proto *prot, int kern)
1532 {
1533 struct sock *sk;
1534
1535 sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
1536 if (sk) {
1537 sk->sk_family = family;
1538 /*
1539 * See comment in struct sock definition to understand
1540 * why we need sk_prot_creator -acme
1541 */
1542 sk->sk_prot = sk->sk_prot_creator = prot;
1543 sk->sk_kern_sock = kern;
1544 sock_lock_init(sk);
1545 sk->sk_net_refcnt = kern ? 0 : 1;
1546 if (likely(sk->sk_net_refcnt)) {
1547 get_net(net);
1548 sock_inuse_add(net, 1);
1549 }
1550
1551 sock_net_set(sk, net);
1552 refcount_set(&sk->sk_wmem_alloc, 1);
1553
1554 mem_cgroup_sk_alloc(sk);
1555 cgroup_sk_alloc(&sk->sk_cgrp_data);
1556 sock_update_classid(&sk->sk_cgrp_data);
1557 sock_update_netprioidx(&sk->sk_cgrp_data);
1558 }
1559
1560 return sk;
1561 }
1562 EXPORT_SYMBOL(sk_alloc);
1563
1564 /* Sockets having SOCK_RCU_FREE will call this function after one RCU
1565 * grace period. This is the case for UDP sockets and TCP listeners.
1566 */
1567 static void __sk_destruct(struct rcu_head *head)
1568 {
1569 struct sock *sk = container_of(head, struct sock, sk_rcu);
1570 struct sk_filter *filter;
1571
1572 if (sk->sk_destruct)
1573 sk->sk_destruct(sk);
1574
1575 filter = rcu_dereference_check(sk->sk_filter,
1576 refcount_read(&sk->sk_wmem_alloc) == 0);
1577 if (filter) {
1578 sk_filter_uncharge(sk, filter);
1579 RCU_INIT_POINTER(sk->sk_filter, NULL);
1580 }
1581 if (rcu_access_pointer(sk->sk_reuseport_cb))
1582 reuseport_detach_sock(sk);
1583
1584 sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
1585
1586 if (atomic_read(&sk->sk_omem_alloc))
1587 pr_debug("%s: optmem leakage (%d bytes) detected\n",
1588 __func__, atomic_read(&sk->sk_omem_alloc));
1589
1590 if (sk->sk_frag.page) {
1591 put_page(sk->sk_frag.page);
1592 sk->sk_frag.page = NULL;
1593 }
1594
1595 if (sk->sk_peer_cred)
1596 put_cred(sk->sk_peer_cred);
1597 put_pid(sk->sk_peer_pid);
1598 if (likely(sk->sk_net_refcnt))
1599 put_net(sock_net(sk));
1600 sk_prot_free(sk->sk_prot_creator, sk);
1601 }
1602
1603 void sk_destruct(struct sock *sk)
1604 {
1605 if (sock_flag(sk, SOCK_RCU_FREE))
1606 call_rcu(&sk->sk_rcu, __sk_destruct);
1607 else
1608 __sk_destruct(&sk->sk_rcu);
1609 }
1610
1611 static void __sk_free(struct sock *sk)
1612 {
1613 if (likely(sk->sk_net_refcnt))
1614 sock_inuse_add(sock_net(sk), -1);
1615
1616 if (unlikely(sk->sk_net_refcnt && sock_diag_has_destroy_listeners(sk)))
1617 sock_diag_broadcast_destroy(sk);
1618 else
1619 sk_destruct(sk);
1620 }
1621
1622 void sk_free(struct sock *sk)
1623 {
1624 /*
1625 * We subtract one from sk_wmem_alloc and can know if
1626 * some packets are still in some tx queue.
1627 * If not null, sock_wfree() will call __sk_free(sk) later
1628 */
1629 if (refcount_dec_and_test(&sk->sk_wmem_alloc))
1630 __sk_free(sk);
1631 }
1632 EXPORT_SYMBOL(sk_free);
1633
1634 static void sk_init_common(struct sock *sk)
1635 {
1636 skb_queue_head_init(&sk->sk_receive_queue);
1637 skb_queue_head_init(&sk->sk_write_queue);
1638 skb_queue_head_init(&sk->sk_error_queue);
1639
1640 rwlock_init(&sk->sk_callback_lock);
1641 lockdep_set_class_and_name(&sk->sk_receive_queue.lock,
1642 af_rlock_keys + sk->sk_family,
1643 af_family_rlock_key_strings[sk->sk_family]);
1644 lockdep_set_class_and_name(&sk->sk_write_queue.lock,
1645 af_wlock_keys + sk->sk_family,
1646 af_family_wlock_key_strings[sk->sk_family]);
1647 lockdep_set_class_and_name(&sk->sk_error_queue.lock,
1648 af_elock_keys + sk->sk_family,
1649 af_family_elock_key_strings[sk->sk_family]);
1650 lockdep_set_class_and_name(&sk->sk_callback_lock,
1651 af_callback_keys + sk->sk_family,
1652 af_family_clock_key_strings[sk->sk_family]);
1653 }
1654
1655 /**
1656 * sk_clone_lock - clone a socket, and lock its clone
1657 * @sk: the socket to clone
1658 * @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1659 *
1660 * Caller must unlock socket even in error path (bh_unlock_sock(newsk))
1661 */
1662 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
1663 {
1664 struct sock *newsk;
1665 bool is_charged = true;
1666
1667 newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
1668 if (newsk != NULL) {
1669 struct sk_filter *filter;
1670
1671 sock_copy(newsk, sk);
1672
1673 newsk->sk_prot_creator = sk->sk_prot;
1674
1675 /* SANITY */
1676 if (likely(newsk->sk_net_refcnt))
1677 get_net(sock_net(newsk));
1678 sk_node_init(&newsk->sk_node);
1679 sock_lock_init(newsk);
1680 bh_lock_sock(newsk);
1681 newsk->sk_backlog.head = newsk->sk_backlog.tail = NULL;
1682 newsk->sk_backlog.len = 0;
1683
1684 atomic_set(&newsk->sk_rmem_alloc, 0);
1685 /*
1686 * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1687 */
1688 refcount_set(&newsk->sk_wmem_alloc, 1);
1689 atomic_set(&newsk->sk_omem_alloc, 0);
1690 sk_init_common(newsk);
1691
1692 newsk->sk_dst_cache = NULL;
1693 newsk->sk_dst_pending_confirm = 0;
1694 newsk->sk_wmem_queued = 0;
1695 newsk->sk_forward_alloc = 0;
1696 atomic_set(&newsk->sk_drops, 0);
1697 newsk->sk_send_head = NULL;
1698 newsk->sk_userlocks = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1699 atomic_set(&newsk->sk_zckey, 0);
1700
1701 sock_reset_flag(newsk, SOCK_DONE);
1702 mem_cgroup_sk_alloc(newsk);
1703 cgroup_sk_alloc(&newsk->sk_cgrp_data);
1704
1705 rcu_read_lock();
1706 filter = rcu_dereference(sk->sk_filter);
1707 if (filter != NULL)
1708 /* though it's an empty new sock, the charging may fail
1709 * if sysctl_optmem_max was changed between creation of
1710 * original socket and cloning
1711 */
1712 is_charged = sk_filter_charge(newsk, filter);
1713 RCU_INIT_POINTER(newsk->sk_filter, filter);
1714 rcu_read_unlock();
1715
1716 if (unlikely(!is_charged || xfrm_sk_clone_policy(newsk, sk))) {
1717 /* We need to make sure that we don't uncharge the new
1718 * socket if we couldn't charge it in the first place
1719 * as otherwise we uncharge the parent's filter.
1720 */
1721 if (!is_charged)
1722 RCU_INIT_POINTER(newsk->sk_filter, NULL);
1723 sk_free_unlock_clone(newsk);
1724 newsk = NULL;
1725 goto out;
1726 }
1727 RCU_INIT_POINTER(newsk->sk_reuseport_cb, NULL);
1728
1729 newsk->sk_err = 0;
1730 newsk->sk_err_soft = 0;
1731 newsk->sk_priority = 0;
1732 newsk->sk_incoming_cpu = raw_smp_processor_id();
1733 atomic64_set(&newsk->sk_cookie, 0);
1734 if (likely(newsk->sk_net_refcnt))
1735 sock_inuse_add(sock_net(newsk), 1);
1736
1737 /*
1738 * Before updating sk_refcnt, we must commit prior changes to memory
1739 * (Documentation/RCU/rculist_nulls.txt for details)
1740 */
1741 smp_wmb();
1742 refcount_set(&newsk->sk_refcnt, 2);
1743
1744 /*
1745 * Increment the counter in the same struct proto as the master
1746 * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1747 * is the same as sk->sk_prot->socks, as this field was copied
1748 * with memcpy).
1749 *
1750 * This _changes_ the previous behaviour, where
1751 * tcp_create_openreq_child always was incrementing the
1752 * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1753 * to be taken into account in all callers. -acme
1754 */
1755 sk_refcnt_debug_inc(newsk);
1756 sk_set_socket(newsk, NULL);
1757 newsk->sk_wq = NULL;
1758
1759 if (newsk->sk_prot->sockets_allocated)
1760 sk_sockets_allocated_inc(newsk);
1761
1762 if (sock_needs_netstamp(sk) &&
1763 newsk->sk_flags & SK_FLAGS_TIMESTAMP)
1764 net_enable_timestamp();
1765 }
1766 out:
1767 return newsk;
1768 }
1769 EXPORT_SYMBOL_GPL(sk_clone_lock);
1770
1771 void sk_free_unlock_clone(struct sock *sk)
1772 {
1773 /* It is still raw copy of parent, so invalidate
1774 * destructor and make plain sk_free() */
1775 sk->sk_destruct = NULL;
1776 bh_unlock_sock(sk);
1777 sk_free(sk);
1778 }
1779 EXPORT_SYMBOL_GPL(sk_free_unlock_clone);
1780
1781 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1782 {
1783 u32 max_segs = 1;
1784
1785 sk_dst_set(sk, dst);
1786 sk->sk_route_caps = dst->dev->features | sk->sk_route_forced_caps;
1787 if (sk->sk_route_caps & NETIF_F_GSO)
1788 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1789 sk->sk_route_caps &= ~sk->sk_route_nocaps;
1790 if (sk_can_gso(sk)) {
1791 if (dst->header_len && !xfrm_dst_offload_ok(dst)) {
1792 sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1793 } else {
1794 sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1795 sk->sk_gso_max_size = dst->dev->gso_max_size;
1796 max_segs = max_t(u32, dst->dev->gso_max_segs, 1);
1797 }
1798 }
1799 sk->sk_gso_max_segs = max_segs;
1800 }
1801 EXPORT_SYMBOL_GPL(sk_setup_caps);
1802
1803 /*
1804 * Simple resource managers for sockets.
1805 */
1806
1807
1808 /*
1809 * Write buffer destructor automatically called from kfree_skb.
1810 */
1811 void sock_wfree(struct sk_buff *skb)
1812 {
1813 struct sock *sk = skb->sk;
1814 unsigned int len = skb->truesize;
1815
1816 if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1817 /*
1818 * Keep a reference on sk_wmem_alloc, this will be released
1819 * after sk_write_space() call
1820 */
1821 WARN_ON(refcount_sub_and_test(len - 1, &sk->sk_wmem_alloc));
1822 sk->sk_write_space(sk);
1823 len = 1;
1824 }
1825 /*
1826 * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1827 * could not do because of in-flight packets
1828 */
1829 if (refcount_sub_and_test(len, &sk->sk_wmem_alloc))
1830 __sk_free(sk);
1831 }
1832 EXPORT_SYMBOL(sock_wfree);
1833
1834 /* This variant of sock_wfree() is used by TCP,
1835 * since it sets SOCK_USE_WRITE_QUEUE.
1836 */
1837 void __sock_wfree(struct sk_buff *skb)
1838 {
1839 struct sock *sk = skb->sk;
1840
1841 if (refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc))
1842 __sk_free(sk);
1843 }
1844
1845 void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
1846 {
1847 skb_orphan(skb);
1848 skb->sk = sk;
1849 #ifdef CONFIG_INET
1850 if (unlikely(!sk_fullsock(sk))) {
1851 skb->destructor = sock_edemux;
1852 sock_hold(sk);
1853 return;
1854 }
1855 #endif
1856 skb->destructor = sock_wfree;
1857 skb_set_hash_from_sk(skb, sk);
1858 /*
1859 * We used to take a refcount on sk, but following operation
1860 * is enough to guarantee sk_free() wont free this sock until
1861 * all in-flight packets are completed
1862 */
1863 refcount_add(skb->truesize, &sk->sk_wmem_alloc);
1864 }
1865 EXPORT_SYMBOL(skb_set_owner_w);
1866
1867 /* This helper is used by netem, as it can hold packets in its
1868 * delay queue. We want to allow the owner socket to send more
1869 * packets, as if they were already TX completed by a typical driver.
1870 * But we also want to keep skb->sk set because some packet schedulers
1871 * rely on it (sch_fq for example).
1872 */
1873 void skb_orphan_partial(struct sk_buff *skb)
1874 {
1875 if (skb_is_tcp_pure_ack(skb))
1876 return;
1877
1878 if (skb->destructor == sock_wfree
1879 #ifdef CONFIG_INET
1880 || skb->destructor == tcp_wfree
1881 #endif
1882 ) {
1883 struct sock *sk = skb->sk;
1884
1885 if (refcount_inc_not_zero(&sk->sk_refcnt)) {
1886 WARN_ON(refcount_sub_and_test(skb->truesize, &sk->sk_wmem_alloc));
1887 skb->destructor = sock_efree;
1888 }
1889 } else {
1890 skb_orphan(skb);
1891 }
1892 }
1893 EXPORT_SYMBOL(skb_orphan_partial);
1894
1895 /*
1896 * Read buffer destructor automatically called from kfree_skb.
1897 */
1898 void sock_rfree(struct sk_buff *skb)
1899 {
1900 struct sock *sk = skb->sk;
1901 unsigned int len = skb->truesize;
1902
1903 atomic_sub(len, &sk->sk_rmem_alloc);
1904 sk_mem_uncharge(sk, len);
1905 }
1906 EXPORT_SYMBOL(sock_rfree);
1907
1908 /*
1909 * Buffer destructor for skbs that are not used directly in read or write
1910 * path, e.g. for error handler skbs. Automatically called from kfree_skb.
1911 */
1912 void sock_efree(struct sk_buff *skb)
1913 {
1914 sock_put(skb->sk);
1915 }
1916 EXPORT_SYMBOL(sock_efree);
1917
1918 kuid_t sock_i_uid(struct sock *sk)
1919 {
1920 kuid_t uid;
1921
1922 read_lock_bh(&sk->sk_callback_lock);
1923 uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : GLOBAL_ROOT_UID;
1924 read_unlock_bh(&sk->sk_callback_lock);
1925 return uid;
1926 }
1927 EXPORT_SYMBOL(sock_i_uid);
1928
1929 unsigned long sock_i_ino(struct sock *sk)
1930 {
1931 unsigned long ino;
1932
1933 read_lock_bh(&sk->sk_callback_lock);
1934 ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1935 read_unlock_bh(&sk->sk_callback_lock);
1936 return ino;
1937 }
1938 EXPORT_SYMBOL(sock_i_ino);
1939
1940 /*
1941 * Allocate a skb from the socket's send buffer.
1942 */
1943 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1944 gfp_t priority)
1945 {
1946 if (force || refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1947 struct sk_buff *skb = alloc_skb(size, priority);
1948 if (skb) {
1949 skb_set_owner_w(skb, sk);
1950 return skb;
1951 }
1952 }
1953 return NULL;
1954 }
1955 EXPORT_SYMBOL(sock_wmalloc);
1956
1957 static void sock_ofree(struct sk_buff *skb)
1958 {
1959 struct sock *sk = skb->sk;
1960
1961 atomic_sub(skb->truesize, &sk->sk_omem_alloc);
1962 }
1963
1964 struct sk_buff *sock_omalloc(struct sock *sk, unsigned long size,
1965 gfp_t priority)
1966 {
1967 struct sk_buff *skb;
1968
1969 /* small safe race: SKB_TRUESIZE may differ from final skb->truesize */
1970 if (atomic_read(&sk->sk_omem_alloc) + SKB_TRUESIZE(size) >
1971 sysctl_optmem_max)
1972 return NULL;
1973
1974 skb = alloc_skb(size, priority);
1975 if (!skb)
1976 return NULL;
1977
1978 atomic_add(skb->truesize, &sk->sk_omem_alloc);
1979 skb->sk = sk;
1980 skb->destructor = sock_ofree;
1981 return skb;
1982 }
1983
1984 /*
1985 * Allocate a memory block from the socket's option memory buffer.
1986 */
1987 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1988 {
1989 if ((unsigned int)size <= sysctl_optmem_max &&
1990 atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1991 void *mem;
1992 /* First do the add, to avoid the race if kmalloc
1993 * might sleep.
1994 */
1995 atomic_add(size, &sk->sk_omem_alloc);
1996 mem = kmalloc(size, priority);
1997 if (mem)
1998 return mem;
1999 atomic_sub(size, &sk->sk_omem_alloc);
2000 }
2001 return NULL;
2002 }
2003 EXPORT_SYMBOL(sock_kmalloc);
2004
2005 /* Free an option memory block. Note, we actually want the inline
2006 * here as this allows gcc to detect the nullify and fold away the
2007 * condition entirely.
2008 */
2009 static inline void __sock_kfree_s(struct sock *sk, void *mem, int size,
2010 const bool nullify)
2011 {
2012 if (WARN_ON_ONCE(!mem))
2013 return;
2014 if (nullify)
2015 kzfree(mem);
2016 else
2017 kfree(mem);
2018 atomic_sub(size, &sk->sk_omem_alloc);
2019 }
2020
2021 void sock_kfree_s(struct sock *sk, void *mem, int size)
2022 {
2023 __sock_kfree_s(sk, mem, size, false);
2024 }
2025 EXPORT_SYMBOL(sock_kfree_s);
2026
2027 void sock_kzfree_s(struct sock *sk, void *mem, int size)
2028 {
2029 __sock_kfree_s(sk, mem, size, true);
2030 }
2031 EXPORT_SYMBOL(sock_kzfree_s);
2032
2033 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
2034 I think, these locks should be removed for datagram sockets.
2035 */
2036 static long sock_wait_for_wmem(struct sock *sk, long timeo)
2037 {
2038 DEFINE_WAIT(wait);
2039
2040 sk_clear_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2041 for (;;) {
2042 if (!timeo)
2043 break;
2044 if (signal_pending(current))
2045 break;
2046 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
2047 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
2048 if (refcount_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
2049 break;
2050 if (sk->sk_shutdown & SEND_SHUTDOWN)
2051 break;
2052 if (sk->sk_err)
2053 break;
2054 timeo = schedule_timeout(timeo);
2055 }
2056 finish_wait(sk_sleep(sk), &wait);
2057 return timeo;
2058 }
2059
2060
2061 /*
2062 * Generic send/receive buffer handlers
2063 */
2064
2065 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
2066 unsigned long data_len, int noblock,
2067 int *errcode, int max_page_order)
2068 {
2069 struct sk_buff *skb;
2070 long timeo;
2071 int err;
2072
2073 timeo = sock_sndtimeo(sk, noblock);
2074 for (;;) {
2075 err = sock_error(sk);
2076 if (err != 0)
2077 goto failure;
2078
2079 err = -EPIPE;
2080 if (sk->sk_shutdown & SEND_SHUTDOWN)
2081 goto failure;
2082
2083 if (sk_wmem_alloc_get(sk) < sk->sk_sndbuf)
2084 break;
2085
2086 sk_set_bit(SOCKWQ_ASYNC_NOSPACE, sk);
2087 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
2088 err = -EAGAIN;
2089 if (!timeo)
2090 goto failure;
2091 if (signal_pending(current))
2092 goto interrupted;
2093 timeo = sock_wait_for_wmem(sk, timeo);
2094 }
2095 skb = alloc_skb_with_frags(header_len, data_len, max_page_order,
2096 errcode, sk->sk_allocation);
2097 if (skb)
2098 skb_set_owner_w(skb, sk);
2099 return skb;
2100
2101 interrupted:
2102 err = sock_intr_errno(timeo);
2103 failure:
2104 *errcode = err;
2105 return NULL;
2106 }
2107 EXPORT_SYMBOL(sock_alloc_send_pskb);
2108
2109 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
2110 int noblock, int *errcode)
2111 {
2112 return sock_alloc_send_pskb(sk, size, 0, noblock, errcode, 0);
2113 }
2114 EXPORT_SYMBOL(sock_alloc_send_skb);
2115
2116 int __sock_cmsg_send(struct sock *sk, struct msghdr *msg, struct cmsghdr *cmsg,
2117 struct sockcm_cookie *sockc)
2118 {
2119 u32 tsflags;
2120
2121 switch (cmsg->cmsg_type) {
2122 case SO_MARK:
2123 if (!ns_capable(sock_net(sk)->user_ns, CAP_NET_ADMIN))
2124 return -EPERM;
2125 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
2126 return -EINVAL;
2127 sockc->mark = *(u32 *)CMSG_DATA(cmsg);
2128 break;
2129 case SO_TIMESTAMPING:
2130 if (cmsg->cmsg_len != CMSG_LEN(sizeof(u32)))
2131 return -EINVAL;
2132
2133 tsflags = *(u32 *)CMSG_DATA(cmsg);
2134 if (tsflags & ~SOF_TIMESTAMPING_TX_RECORD_MASK)
2135 return -EINVAL;
2136
2137 sockc->tsflags &= ~SOF_TIMESTAMPING_TX_RECORD_MASK;
2138 sockc->tsflags |= tsflags;
2139 break;
2140 /* SCM_RIGHTS and SCM_CREDENTIALS are semantically in SOL_UNIX. */
2141 case SCM_RIGHTS:
2142 case SCM_CREDENTIALS:
2143 break;
2144 default:
2145 return -EINVAL;
2146 }
2147 return 0;
2148 }
2149 EXPORT_SYMBOL(__sock_cmsg_send);
2150
2151 int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
2152 struct sockcm_cookie *sockc)
2153 {
2154 struct cmsghdr *cmsg;
2155 int ret;
2156
2157 for_each_cmsghdr(cmsg, msg) {
2158 if (!CMSG_OK(msg, cmsg))
2159 return -EINVAL;
2160 if (cmsg->cmsg_level != SOL_SOCKET)
2161 continue;
2162 ret = __sock_cmsg_send(sk, msg, cmsg, sockc);
2163 if (ret)
2164 return ret;
2165 }
2166 return 0;
2167 }
2168 EXPORT_SYMBOL(sock_cmsg_send);
2169
2170 static void sk_enter_memory_pressure(struct sock *sk)
2171 {
2172 if (!sk->sk_prot->enter_memory_pressure)
2173 return;
2174
2175 sk->sk_prot->enter_memory_pressure(sk);
2176 }
2177
2178 static void sk_leave_memory_pressure(struct sock *sk)
2179 {
2180 if (sk->sk_prot->leave_memory_pressure) {
2181 sk->sk_prot->leave_memory_pressure(sk);
2182 } else {
2183 unsigned long *memory_pressure = sk->sk_prot->memory_pressure;
2184
2185 if (memory_pressure && *memory_pressure)
2186 *memory_pressure = 0;
2187 }
2188 }
2189
2190 /* On 32bit arches, an skb frag is limited to 2^15 */
2191 #define SKB_FRAG_PAGE_ORDER get_order(32768)
2192
2193 /**
2194 * skb_page_frag_refill - check that a page_frag contains enough room
2195 * @sz: minimum size of the fragment we want to get
2196 * @pfrag: pointer to page_frag
2197 * @gfp: priority for memory allocation
2198 *
2199 * Note: While this allocator tries to use high order pages, there is
2200 * no guarantee that allocations succeed. Therefore, @sz MUST be
2201 * less or equal than PAGE_SIZE.
2202 */
2203 bool skb_page_frag_refill(unsigned int sz, struct page_frag *pfrag, gfp_t gfp)
2204 {
2205 if (pfrag->page) {
2206 if (page_ref_count(pfrag->page) == 1) {
2207 pfrag->offset = 0;
2208 return true;
2209 }
2210 if (pfrag->offset + sz <= pfrag->size)
2211 return true;
2212 put_page(pfrag->page);
2213 }
2214
2215 pfrag->offset = 0;
2216 if (SKB_FRAG_PAGE_ORDER) {
2217 /* Avoid direct reclaim but allow kswapd to wake */
2218 pfrag->page = alloc_pages((gfp & ~__GFP_DIRECT_RECLAIM) |
2219 __GFP_COMP | __GFP_NOWARN |
2220 __GFP_NORETRY,
2221 SKB_FRAG_PAGE_ORDER);
2222 if (likely(pfrag->page)) {
2223 pfrag->size = PAGE_SIZE << SKB_FRAG_PAGE_ORDER;
2224 return true;
2225 }
2226 }
2227 pfrag->page = alloc_page(gfp);
2228 if (likely(pfrag->page)) {
2229 pfrag->size = PAGE_SIZE;
2230 return true;
2231 }
2232 return false;
2233 }
2234 EXPORT_SYMBOL(skb_page_frag_refill);
2235
2236 bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
2237 {
2238 if (likely(skb_page_frag_refill(32U, pfrag, sk->sk_allocation)))
2239 return true;
2240
2241 sk_enter_memory_pressure(sk);
2242 sk_stream_moderate_sndbuf(sk);
2243 return false;
2244 }
2245 EXPORT_SYMBOL(sk_page_frag_refill);
2246
2247 int sk_alloc_sg(struct sock *sk, int len, struct scatterlist *sg,
2248 int sg_start, int *sg_curr_index, unsigned int *sg_curr_size,
2249 int first_coalesce)
2250 {
2251 int sg_curr = *sg_curr_index, use = 0, rc = 0;
2252 unsigned int size = *sg_curr_size;
2253 struct page_frag *pfrag;
2254 struct scatterlist *sge;
2255
2256 len -= size;
2257 pfrag = sk_page_frag(sk);
2258
2259 while (len > 0) {
2260 unsigned int orig_offset;
2261
2262 if (!sk_page_frag_refill(sk, pfrag)) {
2263 rc = -ENOMEM;
2264 goto out;
2265 }
2266
2267 use = min_t(int, len, pfrag->size - pfrag->offset);
2268
2269 if (!sk_wmem_schedule(sk, use)) {
2270 rc = -ENOMEM;
2271 goto out;
2272 }
2273
2274 sk_mem_charge(sk, use);
2275 size += use;
2276 orig_offset = pfrag->offset;
2277 pfrag->offset += use;
2278
2279 sge = sg + sg_curr - 1;
2280 if (sg_curr > first_coalesce && sg_page(sg) == pfrag->page &&
2281 sg->offset + sg->length == orig_offset) {
2282 sg->length += use;
2283 } else {
2284 sge = sg + sg_curr;
2285 sg_unmark_end(sge);
2286 sg_set_page(sge, pfrag->page, use, orig_offset);
2287 get_page(pfrag->page);
2288 sg_curr++;
2289
2290 if (sg_curr == MAX_SKB_FRAGS)
2291 sg_curr = 0;
2292
2293 if (sg_curr == sg_start) {
2294 rc = -ENOSPC;
2295 break;
2296 }
2297 }
2298
2299 len -= use;
2300 }
2301 out:
2302 *sg_curr_size = size;
2303 *sg_curr_index = sg_curr;
2304 return rc;
2305 }
2306 EXPORT_SYMBOL(sk_alloc_sg);
2307
2308 static void __lock_sock(struct sock *sk)
2309 __releases(&sk->sk_lock.slock)
2310 __acquires(&sk->sk_lock.slock)
2311 {
2312 DEFINE_WAIT(wait);
2313
2314 for (;;) {
2315 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
2316 TASK_UNINTERRUPTIBLE);
2317 spin_unlock_bh(&sk->sk_lock.slock);
2318 schedule();
2319 spin_lock_bh(&sk->sk_lock.slock);
2320 if (!sock_owned_by_user(sk))
2321 break;
2322 }
2323 finish_wait(&sk->sk_lock.wq, &wait);
2324 }
2325
2326 static void __release_sock(struct sock *sk)
2327 __releases(&sk->sk_lock.slock)
2328 __acquires(&sk->sk_lock.slock)
2329 {
2330 struct sk_buff *skb, *next;
2331
2332 while ((skb = sk->sk_backlog.head) != NULL) {
2333 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
2334
2335 spin_unlock_bh(&sk->sk_lock.slock);
2336
2337 do {
2338 next = skb->next;
2339 prefetch(next);
2340 WARN_ON_ONCE(skb_dst_is_noref(skb));
2341 skb->next = NULL;
2342 sk_backlog_rcv(sk, skb);
2343
2344 cond_resched();
2345
2346 skb = next;
2347 } while (skb != NULL);
2348
2349 spin_lock_bh(&sk->sk_lock.slock);
2350 }
2351
2352 /*
2353 * Doing the zeroing here guarantee we can not loop forever
2354 * while a wild producer attempts to flood us.
2355 */
2356 sk->sk_backlog.len = 0;
2357 }
2358
2359 void __sk_flush_backlog(struct sock *sk)
2360 {
2361 spin_lock_bh(&sk->sk_lock.slock);
2362 __release_sock(sk);
2363 spin_unlock_bh(&sk->sk_lock.slock);
2364 }
2365
2366 /**
2367 * sk_wait_data - wait for data to arrive at sk_receive_queue
2368 * @sk: sock to wait on
2369 * @timeo: for how long
2370 * @skb: last skb seen on sk_receive_queue
2371 *
2372 * Now socket state including sk->sk_err is changed only under lock,
2373 * hence we may omit checks after joining wait queue.
2374 * We check receive queue before schedule() only as optimization;
2375 * it is very likely that release_sock() added new data.
2376 */
2377 int sk_wait_data(struct sock *sk, long *timeo, const struct sk_buff *skb)
2378 {
2379 DEFINE_WAIT_FUNC(wait, woken_wake_function);
2380 int rc;
2381
2382 add_wait_queue(sk_sleep(sk), &wait);
2383 sk_set_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2384 rc = sk_wait_event(sk, timeo, skb_peek_tail(&sk->sk_receive_queue) != skb, &wait);
2385 sk_clear_bit(SOCKWQ_ASYNC_WAITDATA, sk);
2386 remove_wait_queue(sk_sleep(sk), &wait);
2387 return rc;
2388 }
2389 EXPORT_SYMBOL(sk_wait_data);
2390
2391 /**
2392 * __sk_mem_raise_allocated - increase memory_allocated
2393 * @sk: socket
2394 * @size: memory size to allocate
2395 * @amt: pages to allocate
2396 * @kind: allocation type
2397 *
2398 * Similar to __sk_mem_schedule(), but does not update sk_forward_alloc
2399 */
2400 int __sk_mem_raise_allocated(struct sock *sk, int size, int amt, int kind)
2401 {
2402 struct proto *prot = sk->sk_prot;
2403 long allocated = sk_memory_allocated_add(sk, amt);
2404
2405 if (mem_cgroup_sockets_enabled && sk->sk_memcg &&
2406 !mem_cgroup_charge_skmem(sk->sk_memcg, amt))
2407 goto suppress_allocation;
2408
2409 /* Under limit. */
2410 if (allocated <= sk_prot_mem_limits(sk, 0)) {
2411 sk_leave_memory_pressure(sk);
2412 return 1;
2413 }
2414
2415 /* Under pressure. */
2416 if (allocated > sk_prot_mem_limits(sk, 1))
2417 sk_enter_memory_pressure(sk);
2418
2419 /* Over hard limit. */
2420 if (allocated > sk_prot_mem_limits(sk, 2))
2421 goto suppress_allocation;
2422
2423 /* guarantee minimum buffer size under pressure */
2424 if (kind == SK_MEM_RECV) {
2425 if (atomic_read(&sk->sk_rmem_alloc) < sk_get_rmem0(sk, prot))
2426 return 1;
2427
2428 } else { /* SK_MEM_SEND */
2429 int wmem0 = sk_get_wmem0(sk, prot);
2430
2431 if (sk->sk_type == SOCK_STREAM) {
2432 if (sk->sk_wmem_queued < wmem0)
2433 return 1;
2434 } else if (refcount_read(&sk->sk_wmem_alloc) < wmem0) {
2435 return 1;
2436 }
2437 }
2438
2439 if (sk_has_memory_pressure(sk)) {
2440 int alloc;
2441
2442 if (!sk_under_memory_pressure(sk))
2443 return 1;
2444 alloc = sk_sockets_allocated_read_positive(sk);
2445 if (sk_prot_mem_limits(sk, 2) > alloc *
2446 sk_mem_pages(sk->sk_wmem_queued +
2447 atomic_read(&sk->sk_rmem_alloc) +
2448 sk->sk_forward_alloc))
2449 return 1;
2450 }
2451
2452 suppress_allocation:
2453
2454 if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
2455 sk_stream_moderate_sndbuf(sk);
2456
2457 /* Fail only if socket is _under_ its sndbuf.
2458 * In this case we cannot block, so that we have to fail.
2459 */
2460 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
2461 return 1;
2462 }
2463
2464 trace_sock_exceed_buf_limit(sk, prot, allocated);
2465
2466 sk_memory_allocated_sub(sk, amt);
2467
2468 if (mem_cgroup_sockets_enabled && sk->sk_memcg)
2469 mem_cgroup_uncharge_skmem(sk->sk_memcg, amt);
2470
2471 return 0;
2472 }
2473 EXPORT_SYMBOL(__sk_mem_raise_allocated);
2474
2475 /**
2476 * __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
2477 * @sk: socket
2478 * @size: memory size to allocate
2479 * @kind: allocation type
2480 *
2481 * If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
2482 * rmem allocation. This function assumes that protocols which have
2483 * memory_pressure use sk_wmem_queued as write buffer accounting.
2484 */
2485 int __sk_mem_schedule(struct sock *sk, int size, int kind)
2486 {
2487 int ret, amt = sk_mem_pages(size);
2488
2489 sk->sk_forward_alloc += amt << SK_MEM_QUANTUM_SHIFT;
2490 ret = __sk_mem_raise_allocated(sk, size, amt, kind);
2491 if (!ret)
2492 sk->sk_forward_alloc -= amt << SK_MEM_QUANTUM_SHIFT;
2493 return ret;
2494 }
2495 EXPORT_SYMBOL(__sk_mem_schedule);
2496
2497 /**
2498 * __sk_mem_reduce_allocated - reclaim memory_allocated
2499 * @sk: socket
2500 * @amount: number of quanta
2501 *
2502 * Similar to __sk_mem_reclaim(), but does not update sk_forward_alloc
2503 */
2504 void __sk_mem_reduce_allocated(struct sock *sk, int amount)
2505 {
2506 sk_memory_allocated_sub(sk, amount);
2507
2508 if (mem_cgroup_sockets_enabled && sk->sk_memcg)
2509 mem_cgroup_uncharge_skmem(sk->sk_memcg, amount);
2510
2511 if (sk_under_memory_pressure(sk) &&
2512 (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
2513 sk_leave_memory_pressure(sk);
2514 }
2515 EXPORT_SYMBOL(__sk_mem_reduce_allocated);
2516
2517 /**
2518 * __sk_mem_reclaim - reclaim sk_forward_alloc and memory_allocated
2519 * @sk: socket
2520 * @amount: number of bytes (rounded down to a SK_MEM_QUANTUM multiple)
2521 */
2522 void __sk_mem_reclaim(struct sock *sk, int amount)
2523 {
2524 amount >>= SK_MEM_QUANTUM_SHIFT;
2525 sk->sk_forward_alloc -= amount << SK_MEM_QUANTUM_SHIFT;
2526 __sk_mem_reduce_allocated(sk, amount);
2527 }
2528 EXPORT_SYMBOL(__sk_mem_reclaim);
2529
2530 int sk_set_peek_off(struct sock *sk, int val)
2531 {
2532 sk->sk_peek_off = val;
2533 return 0;
2534 }
2535 EXPORT_SYMBOL_GPL(sk_set_peek_off);
2536
2537 /*
2538 * Set of default routines for initialising struct proto_ops when
2539 * the protocol does not support a particular function. In certain
2540 * cases where it makes no sense for a protocol to have a "do nothing"
2541 * function, some default processing is provided.
2542 */
2543
2544 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
2545 {
2546 return -EOPNOTSUPP;
2547 }
2548 EXPORT_SYMBOL(sock_no_bind);
2549
2550 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
2551 int len, int flags)
2552 {
2553 return -EOPNOTSUPP;
2554 }
2555 EXPORT_SYMBOL(sock_no_connect);
2556
2557 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
2558 {
2559 return -EOPNOTSUPP;
2560 }
2561 EXPORT_SYMBOL(sock_no_socketpair);
2562
2563 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags,
2564 bool kern)
2565 {
2566 return -EOPNOTSUPP;
2567 }
2568 EXPORT_SYMBOL(sock_no_accept);
2569
2570 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
2571 int peer)
2572 {
2573 return -EOPNOTSUPP;
2574 }
2575 EXPORT_SYMBOL(sock_no_getname);
2576
2577 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
2578 {
2579 return -EOPNOTSUPP;
2580 }
2581 EXPORT_SYMBOL(sock_no_ioctl);
2582
2583 int sock_no_listen(struct socket *sock, int backlog)
2584 {
2585 return -EOPNOTSUPP;
2586 }
2587 EXPORT_SYMBOL(sock_no_listen);
2588
2589 int sock_no_shutdown(struct socket *sock, int how)
2590 {
2591 return -EOPNOTSUPP;
2592 }
2593 EXPORT_SYMBOL(sock_no_shutdown);
2594
2595 int sock_no_setsockopt(struct socket *sock, int level, int optname,
2596 char __user *optval, unsigned int optlen)
2597 {
2598 return -EOPNOTSUPP;
2599 }
2600 EXPORT_SYMBOL(sock_no_setsockopt);
2601
2602 int sock_no_getsockopt(struct socket *sock, int level, int optname,
2603 char __user *optval, int __user *optlen)
2604 {
2605 return -EOPNOTSUPP;
2606 }
2607 EXPORT_SYMBOL(sock_no_getsockopt);
2608
2609 int sock_no_sendmsg(struct socket *sock, struct msghdr *m, size_t len)
2610 {
2611 return -EOPNOTSUPP;
2612 }
2613 EXPORT_SYMBOL(sock_no_sendmsg);
2614
2615 int sock_no_sendmsg_locked(struct sock *sk, struct msghdr *m, size_t len)
2616 {
2617 return -EOPNOTSUPP;
2618 }
2619 EXPORT_SYMBOL(sock_no_sendmsg_locked);
2620
2621 int sock_no_recvmsg(struct socket *sock, struct msghdr *m, size_t len,
2622 int flags)
2623 {
2624 return -EOPNOTSUPP;
2625 }
2626 EXPORT_SYMBOL(sock_no_recvmsg);
2627
2628 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
2629 {
2630 /* Mirror missing mmap method error code */
2631 return -ENODEV;
2632 }
2633 EXPORT_SYMBOL(sock_no_mmap);
2634
2635 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
2636 {
2637 ssize_t res;
2638 struct msghdr msg = {.msg_flags = flags};
2639 struct kvec iov;
2640 char *kaddr = kmap(page);
2641 iov.iov_base = kaddr + offset;
2642 iov.iov_len = size;
2643 res = kernel_sendmsg(sock, &msg, &iov, 1, size);
2644 kunmap(page);
2645 return res;
2646 }
2647 EXPORT_SYMBOL(sock_no_sendpage);
2648
2649 ssize_t sock_no_sendpage_locked(struct sock *sk, struct page *page,
2650 int offset, size_t size, int flags)
2651 {
2652 ssize_t res;
2653 struct msghdr msg = {.msg_flags = flags};
2654 struct kvec iov;
2655 char *kaddr = kmap(page);
2656
2657 iov.iov_base = kaddr + offset;
2658 iov.iov_len = size;
2659 res = kernel_sendmsg_locked(sk, &msg, &iov, 1, size);
2660 kunmap(page);
2661 return res;
2662 }
2663 EXPORT_SYMBOL(sock_no_sendpage_locked);
2664
2665 /*
2666 * Default Socket Callbacks
2667 */
2668
2669 static void sock_def_wakeup(struct sock *sk)
2670 {
2671 struct socket_wq *wq;
2672
2673 rcu_read_lock();
2674 wq = rcu_dereference(sk->sk_wq);
2675 if (skwq_has_sleeper(wq))
2676 wake_up_interruptible_all(&wq->wait);
2677 rcu_read_unlock();
2678 }
2679
2680 static void sock_def_error_report(struct sock *sk)
2681 {
2682 struct socket_wq *wq;
2683
2684 rcu_read_lock();
2685 wq = rcu_dereference(sk->sk_wq);
2686 if (skwq_has_sleeper(wq))
2687 wake_up_interruptible_poll(&wq->wait, EPOLLERR);
2688 sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
2689 rcu_read_unlock();
2690 }
2691
2692 static void sock_def_readable(struct sock *sk)
2693 {
2694 struct socket_wq *wq;
2695
2696 rcu_read_lock();
2697 wq = rcu_dereference(sk->sk_wq);
2698 if (skwq_has_sleeper(wq))
2699 wake_up_interruptible_sync_poll(&wq->wait, EPOLLIN | EPOLLPRI |
2700 EPOLLRDNORM | EPOLLRDBAND);
2701 sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
2702 rcu_read_unlock();
2703 }
2704
2705 static void sock_def_write_space(struct sock *sk)
2706 {
2707 struct socket_wq *wq;
2708
2709 rcu_read_lock();
2710
2711 /* Do not wake up a writer until he can make "significant"
2712 * progress. --DaveM
2713 */
2714 if ((refcount_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
2715 wq = rcu_dereference(sk->sk_wq);
2716 if (skwq_has_sleeper(wq))
2717 wake_up_interruptible_sync_poll(&wq->wait, EPOLLOUT |
2718 EPOLLWRNORM | EPOLLWRBAND);
2719
2720 /* Should agree with poll, otherwise some programs break */
2721 if (sock_writeable(sk))
2722 sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
2723 }
2724
2725 rcu_read_unlock();
2726 }
2727
2728 static void sock_def_destruct(struct sock *sk)
2729 {
2730 }
2731
2732 void sk_send_sigurg(struct sock *sk)
2733 {
2734 if (sk->sk_socket && sk->sk_socket->file)
2735 if (send_sigurg(&sk->sk_socket->file->f_owner))
2736 sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
2737 }
2738 EXPORT_SYMBOL(sk_send_sigurg);
2739
2740 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
2741 unsigned long expires)
2742 {
2743 if (!mod_timer(timer, expires))
2744 sock_hold(sk);
2745 }
2746 EXPORT_SYMBOL(sk_reset_timer);
2747
2748 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
2749 {
2750 if (del_timer(timer))
2751 __sock_put(sk);
2752 }
2753 EXPORT_SYMBOL(sk_stop_timer);
2754
2755 void sock_init_data(struct socket *sock, struct sock *sk)
2756 {
2757 sk_init_common(sk);
2758 sk->sk_send_head = NULL;
2759
2760 timer_setup(&sk->sk_timer, NULL, 0);
2761
2762 sk->sk_allocation = GFP_KERNEL;
2763 sk->sk_rcvbuf = sysctl_rmem_default;
2764 sk->sk_sndbuf = sysctl_wmem_default;
2765 sk->sk_state = TCP_CLOSE;
2766 sk_set_socket(sk, sock);
2767
2768 sock_set_flag(sk, SOCK_ZAPPED);
2769
2770 if (sock) {
2771 sk->sk_type = sock->type;
2772 sk->sk_wq = sock->wq;
2773 sock->sk = sk;
2774 sk->sk_uid = SOCK_INODE(sock)->i_uid;
2775 } else {
2776 sk->sk_wq = NULL;
2777 sk->sk_uid = make_kuid(sock_net(sk)->user_ns, 0);
2778 }
2779
2780 rwlock_init(&sk->sk_callback_lock);
2781 if (sk->sk_kern_sock)
2782 lockdep_set_class_and_name(
2783 &sk->sk_callback_lock,
2784 af_kern_callback_keys + sk->sk_family,
2785 af_family_kern_clock_key_strings[sk->sk_family]);
2786 else
2787 lockdep_set_class_and_name(
2788 &sk->sk_callback_lock,
2789 af_callback_keys + sk->sk_family,
2790 af_family_clock_key_strings[sk->sk_family]);
2791
2792 sk->sk_state_change = sock_def_wakeup;
2793 sk->sk_data_ready = sock_def_readable;
2794 sk->sk_write_space = sock_def_write_space;
2795 sk->sk_error_report = sock_def_error_report;
2796 sk->sk_destruct = sock_def_destruct;
2797
2798 sk->sk_frag.page = NULL;
2799 sk->sk_frag.offset = 0;
2800 sk->sk_peek_off = -1;
2801
2802 sk->sk_peer_pid = NULL;
2803 sk->sk_peer_cred = NULL;
2804 sk->sk_write_pending = 0;
2805 sk->sk_rcvlowat = 1;
2806 sk->sk_rcvtimeo = MAX_SCHEDULE_TIMEOUT;
2807 sk->sk_sndtimeo = MAX_SCHEDULE_TIMEOUT;
2808
2809 sk->sk_stamp = SK_DEFAULT_STAMP;
2810 atomic_set(&sk->sk_zckey, 0);
2811
2812 #ifdef CONFIG_NET_RX_BUSY_POLL
2813 sk->sk_napi_id = 0;
2814 sk->sk_ll_usec = sysctl_net_busy_read;
2815 #endif
2816
2817 sk->sk_max_pacing_rate = ~0U;
2818 sk->sk_pacing_rate = ~0U;
2819 sk->sk_pacing_shift = 10;
2820 sk->sk_incoming_cpu = -1;
2821 /*
2822 * Before updating sk_refcnt, we must commit prior changes to memory
2823 * (Documentation/RCU/rculist_nulls.txt for details)
2824 */
2825 smp_wmb();
2826 refcount_set(&sk->sk_refcnt, 1);
2827 atomic_set(&sk->sk_drops, 0);
2828 }
2829 EXPORT_SYMBOL(sock_init_data);
2830
2831 void lock_sock_nested(struct sock *sk, int subclass)
2832 {
2833 might_sleep();
2834 spin_lock_bh(&sk->sk_lock.slock);
2835 if (sk->sk_lock.owned)
2836 __lock_sock(sk);
2837 sk->sk_lock.owned = 1;
2838 spin_unlock(&sk->sk_lock.slock);
2839 /*
2840 * The sk_lock has mutex_lock() semantics here:
2841 */
2842 mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
2843 local_bh_enable();
2844 }
2845 EXPORT_SYMBOL(lock_sock_nested);
2846
2847 void release_sock(struct sock *sk)
2848 {
2849 spin_lock_bh(&sk->sk_lock.slock);
2850 if (sk->sk_backlog.tail)
2851 __release_sock(sk);
2852
2853 /* Warning : release_cb() might need to release sk ownership,
2854 * ie call sock_release_ownership(sk) before us.
2855 */
2856 if (sk->sk_prot->release_cb)
2857 sk->sk_prot->release_cb(sk);
2858
2859 sock_release_ownership(sk);
2860 if (waitqueue_active(&sk->sk_lock.wq))
2861 wake_up(&sk->sk_lock.wq);
2862 spin_unlock_bh(&sk->sk_lock.slock);
2863 }
2864 EXPORT_SYMBOL(release_sock);
2865
2866 /**
2867 * lock_sock_fast - fast version of lock_sock
2868 * @sk: socket
2869 *
2870 * This version should be used for very small section, where process wont block
2871 * return false if fast path is taken:
2872 *
2873 * sk_lock.slock locked, owned = 0, BH disabled
2874 *
2875 * return true if slow path is taken:
2876 *
2877 * sk_lock.slock unlocked, owned = 1, BH enabled
2878 */
2879 bool lock_sock_fast(struct sock *sk)
2880 {
2881 might_sleep();
2882 spin_lock_bh(&sk->sk_lock.slock);
2883
2884 if (!sk->sk_lock.owned)
2885 /*
2886 * Note : We must disable BH
2887 */
2888 return false;
2889
2890 __lock_sock(sk);
2891 sk->sk_lock.owned = 1;
2892 spin_unlock(&sk->sk_lock.slock);
2893 /*
2894 * The sk_lock has mutex_lock() semantics here:
2895 */
2896 mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
2897 local_bh_enable();
2898 return true;
2899 }
2900 EXPORT_SYMBOL(lock_sock_fast);
2901
2902 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
2903 {
2904 struct timeval tv;
2905 if (!sock_flag(sk, SOCK_TIMESTAMP))
2906 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2907 tv = ktime_to_timeval(sk->sk_stamp);
2908 if (tv.tv_sec == -1)
2909 return -ENOENT;
2910 if (tv.tv_sec == 0) {
2911 sk->sk_stamp = ktime_get_real();
2912 tv = ktime_to_timeval(sk->sk_stamp);
2913 }
2914 return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
2915 }
2916 EXPORT_SYMBOL(sock_get_timestamp);
2917
2918 int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2919 {
2920 struct timespec ts;
2921 if (!sock_flag(sk, SOCK_TIMESTAMP))
2922 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2923 ts = ktime_to_timespec(sk->sk_stamp);
2924 if (ts.tv_sec == -1)
2925 return -ENOENT;
2926 if (ts.tv_sec == 0) {
2927 sk->sk_stamp = ktime_get_real();
2928 ts = ktime_to_timespec(sk->sk_stamp);
2929 }
2930 return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2931 }
2932 EXPORT_SYMBOL(sock_get_timestampns);
2933
2934 void sock_enable_timestamp(struct sock *sk, int flag)
2935 {
2936 if (!sock_flag(sk, flag)) {
2937 unsigned long previous_flags = sk->sk_flags;
2938
2939 sock_set_flag(sk, flag);
2940 /*
2941 * we just set one of the two flags which require net
2942 * time stamping, but time stamping might have been on
2943 * already because of the other one
2944 */
2945 if (sock_needs_netstamp(sk) &&
2946 !(previous_flags & SK_FLAGS_TIMESTAMP))
2947 net_enable_timestamp();
2948 }
2949 }
2950
2951 int sock_recv_errqueue(struct sock *sk, struct msghdr *msg, int len,
2952 int level, int type)
2953 {
2954 struct sock_exterr_skb *serr;
2955 struct sk_buff *skb;
2956 int copied, err;
2957
2958 err = -EAGAIN;
2959 skb = sock_dequeue_err_skb(sk);
2960 if (skb == NULL)
2961 goto out;
2962
2963 copied = skb->len;
2964 if (copied > len) {
2965 msg->msg_flags |= MSG_TRUNC;
2966 copied = len;
2967 }
2968 err = skb_copy_datagram_msg(skb, 0, msg, copied);
2969 if (err)
2970 goto out_free_skb;
2971
2972 sock_recv_timestamp(msg, sk, skb);
2973
2974 serr = SKB_EXT_ERR(skb);
2975 put_cmsg(msg, level, type, sizeof(serr->ee), &serr->ee);
2976
2977 msg->msg_flags |= MSG_ERRQUEUE;
2978 err = copied;
2979
2980 out_free_skb:
2981 kfree_skb(skb);
2982 out:
2983 return err;
2984 }
2985 EXPORT_SYMBOL(sock_recv_errqueue);
2986
2987 /*
2988 * Get a socket option on an socket.
2989 *
2990 * FIX: POSIX 1003.1g is very ambiguous here. It states that
2991 * asynchronous errors should be reported by getsockopt. We assume
2992 * this means if you specify SO_ERROR (otherwise whats the point of it).
2993 */
2994 int sock_common_getsockopt(struct socket *sock, int level, int optname,
2995 char __user *optval, int __user *optlen)
2996 {
2997 struct sock *sk = sock->sk;
2998
2999 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
3000 }
3001 EXPORT_SYMBOL(sock_common_getsockopt);
3002
3003 #ifdef CONFIG_COMPAT
3004 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
3005 char __user *optval, int __user *optlen)
3006 {
3007 struct sock *sk = sock->sk;
3008
3009 if (sk->sk_prot->compat_getsockopt != NULL)
3010 return sk->sk_prot->compat_getsockopt(sk, level, optname,
3011 optval, optlen);
3012 return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
3013 }
3014 EXPORT_SYMBOL(compat_sock_common_getsockopt);
3015 #endif
3016
3017 int sock_common_recvmsg(struct socket *sock, struct msghdr *msg, size_t size,
3018 int flags)
3019 {
3020 struct sock *sk = sock->sk;
3021 int addr_len = 0;
3022 int err;
3023
3024 err = sk->sk_prot->recvmsg(sk, msg, size, flags & MSG_DONTWAIT,
3025 flags & ~MSG_DONTWAIT, &addr_len);
3026 if (err >= 0)
3027 msg->msg_namelen = addr_len;
3028 return err;
3029 }
3030 EXPORT_SYMBOL(sock_common_recvmsg);
3031
3032 /*
3033 * Set socket options on an inet socket.
3034 */
3035 int sock_common_setsockopt(struct socket *sock, int level, int optname,
3036 char __user *optval, unsigned int optlen)
3037 {
3038 struct sock *sk = sock->sk;
3039
3040 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
3041 }
3042 EXPORT_SYMBOL(sock_common_setsockopt);
3043
3044 #ifdef CONFIG_COMPAT
3045 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
3046 char __user *optval, unsigned int optlen)
3047 {
3048 struct sock *sk = sock->sk;
3049
3050 if (sk->sk_prot->compat_setsockopt != NULL)
3051 return sk->sk_prot->compat_setsockopt(sk, level, optname,
3052 optval, optlen);
3053 return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
3054 }
3055 EXPORT_SYMBOL(compat_sock_common_setsockopt);
3056 #endif
3057
3058 void sk_common_release(struct sock *sk)
3059 {
3060 if (sk->sk_prot->destroy)
3061 sk->sk_prot->destroy(sk);
3062
3063 /*
3064 * Observation: when sock_common_release is called, processes have
3065 * no access to socket. But net still has.
3066 * Step one, detach it from networking:
3067 *
3068 * A. Remove from hash tables.
3069 */
3070
3071 sk->sk_prot->unhash(sk);
3072
3073 /*
3074 * In this point socket cannot receive new packets, but it is possible
3075 * that some packets are in flight because some CPU runs receiver and
3076 * did hash table lookup before we unhashed socket. They will achieve
3077 * receive queue and will be purged by socket destructor.
3078 *
3079 * Also we still have packets pending on receive queue and probably,
3080 * our own packets waiting in device queues. sock_destroy will drain
3081 * receive queue, but transmitted packets will delay socket destruction
3082 * until the last reference will be released.
3083 */
3084
3085 sock_orphan(sk);
3086
3087 xfrm_sk_free_policy(sk);
3088
3089 sk_refcnt_debug_release(sk);
3090
3091 sock_put(sk);
3092 }
3093 EXPORT_SYMBOL(sk_common_release);
3094
3095 void sk_get_meminfo(const struct sock *sk, u32 *mem)
3096 {
3097 memset(mem, 0, sizeof(*mem) * SK_MEMINFO_VARS);
3098
3099 mem[SK_MEMINFO_RMEM_ALLOC] = sk_rmem_alloc_get(sk);
3100 mem[SK_MEMINFO_RCVBUF] = sk->sk_rcvbuf;
3101 mem[SK_MEMINFO_WMEM_ALLOC] = sk_wmem_alloc_get(sk);
3102 mem[SK_MEMINFO_SNDBUF] = sk->sk_sndbuf;
3103 mem[SK_MEMINFO_FWD_ALLOC] = sk->sk_forward_alloc;
3104 mem[SK_MEMINFO_WMEM_QUEUED] = sk->sk_wmem_queued;
3105 mem[SK_MEMINFO_OPTMEM] = atomic_read(&sk->sk_omem_alloc);
3106 mem[SK_MEMINFO_BACKLOG] = sk->sk_backlog.len;
3107 mem[SK_MEMINFO_DROPS] = atomic_read(&sk->sk_drops);
3108 }
3109
3110 #ifdef CONFIG_PROC_FS
3111 #define PROTO_INUSE_NR 64 /* should be enough for the first time */
3112 struct prot_inuse {
3113 int val[PROTO_INUSE_NR];
3114 };
3115
3116 static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
3117
3118 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
3119 {
3120 __this_cpu_add(net->core.prot_inuse->val[prot->inuse_idx], val);
3121 }
3122 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
3123
3124 int sock_prot_inuse_get(struct net *net, struct proto *prot)
3125 {
3126 int cpu, idx = prot->inuse_idx;
3127 int res = 0;
3128
3129 for_each_possible_cpu(cpu)
3130 res += per_cpu_ptr(net->core.prot_inuse, cpu)->val[idx];
3131
3132 return res >= 0 ? res : 0;
3133 }
3134 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
3135
3136 static void sock_inuse_add(struct net *net, int val)
3137 {
3138 this_cpu_add(*net->core.sock_inuse, val);
3139 }
3140
3141 int sock_inuse_get(struct net *net)
3142 {
3143 int cpu, res = 0;
3144
3145 for_each_possible_cpu(cpu)
3146 res += *per_cpu_ptr(net->core.sock_inuse, cpu);
3147
3148 return res;
3149 }
3150
3151 EXPORT_SYMBOL_GPL(sock_inuse_get);
3152
3153 static int __net_init sock_inuse_init_net(struct net *net)
3154 {
3155 net->core.prot_inuse = alloc_percpu(struct prot_inuse);
3156 if (net->core.prot_inuse == NULL)
3157 return -ENOMEM;
3158
3159 net->core.sock_inuse = alloc_percpu(int);
3160 if (net->core.sock_inuse == NULL)
3161 goto out;
3162
3163 return 0;
3164
3165 out:
3166 free_percpu(net->core.prot_inuse);
3167 return -ENOMEM;
3168 }
3169
3170 static void __net_exit sock_inuse_exit_net(struct net *net)
3171 {
3172 free_percpu(net->core.prot_inuse);
3173 free_percpu(net->core.sock_inuse);
3174 }
3175
3176 static struct pernet_operations net_inuse_ops = {
3177 .init = sock_inuse_init_net,
3178 .exit = sock_inuse_exit_net,
3179 };
3180
3181 static __init int net_inuse_init(void)
3182 {
3183 if (register_pernet_subsys(&net_inuse_ops))
3184 panic("Cannot initialize net inuse counters");
3185
3186 return 0;
3187 }
3188
3189 core_initcall(net_inuse_init);
3190
3191 static void assign_proto_idx(struct proto *prot)
3192 {
3193 prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
3194
3195 if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
3196 pr_err("PROTO_INUSE_NR exhausted\n");
3197 return;
3198 }
3199
3200 set_bit(prot->inuse_idx, proto_inuse_idx);
3201 }
3202
3203 static void release_proto_idx(struct proto *prot)
3204 {
3205 if (prot->inuse_idx != PROTO_INUSE_NR - 1)
3206 clear_bit(prot->inuse_idx, proto_inuse_idx);
3207 }
3208 #else
3209 static inline void assign_proto_idx(struct proto *prot)
3210 {
3211 }
3212
3213 static inline void release_proto_idx(struct proto *prot)
3214 {
3215 }
3216
3217 static void sock_inuse_add(struct net *net, int val)
3218 {
3219 }
3220 #endif
3221
3222 static void req_prot_cleanup(struct request_sock_ops *rsk_prot)
3223 {
3224 if (!rsk_prot)
3225 return;
3226 kfree(rsk_prot->slab_name);
3227 rsk_prot->slab_name = NULL;
3228 kmem_cache_destroy(rsk_prot->slab);
3229 rsk_prot->slab = NULL;
3230 }
3231
3232 static int req_prot_init(const struct proto *prot)
3233 {
3234 struct request_sock_ops *rsk_prot = prot->rsk_prot;
3235
3236 if (!rsk_prot)
3237 return 0;
3238
3239 rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s",
3240 prot->name);
3241 if (!rsk_prot->slab_name)
3242 return -ENOMEM;
3243
3244 rsk_prot->slab = kmem_cache_create(rsk_prot->slab_name,
3245 rsk_prot->obj_size, 0,
3246 prot->slab_flags, NULL);
3247
3248 if (!rsk_prot->slab) {
3249 pr_crit("%s: Can't create request sock SLAB cache!\n",
3250 prot->name);
3251 return -ENOMEM;
3252 }
3253 return 0;
3254 }
3255
3256 int proto_register(struct proto *prot, int alloc_slab)
3257 {
3258 if (alloc_slab) {
3259 prot->slab = kmem_cache_create_usercopy(prot->name,
3260 prot->obj_size, 0,
3261 SLAB_HWCACHE_ALIGN | prot->slab_flags,
3262 prot->useroffset, prot->usersize,
3263 NULL);
3264
3265 if (prot->slab == NULL) {
3266 pr_crit("%s: Can't create sock SLAB cache!\n",
3267 prot->name);
3268 goto out;
3269 }
3270
3271 if (req_prot_init(prot))
3272 goto out_free_request_sock_slab;
3273
3274 if (prot->twsk_prot != NULL) {
3275 prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
3276
3277 if (prot->twsk_prot->twsk_slab_name == NULL)
3278 goto out_free_request_sock_slab;
3279
3280 prot->twsk_prot->twsk_slab =
3281 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
3282 prot->twsk_prot->twsk_obj_size,
3283 0,
3284 prot->slab_flags,
3285 NULL);
3286 if (prot->twsk_prot->twsk_slab == NULL)
3287 goto out_free_timewait_sock_slab_name;
3288 }
3289 }
3290
3291 mutex_lock(&proto_list_mutex);
3292 list_add(&prot->node, &proto_list);
3293 assign_proto_idx(prot);
3294 mutex_unlock(&proto_list_mutex);
3295 return 0;
3296
3297 out_free_timewait_sock_slab_name:
3298 kfree(prot->twsk_prot->twsk_slab_name);
3299 out_free_request_sock_slab:
3300 req_prot_cleanup(prot->rsk_prot);
3301
3302 kmem_cache_destroy(prot->slab);
3303 prot->slab = NULL;
3304 out:
3305 return -ENOBUFS;
3306 }
3307 EXPORT_SYMBOL(proto_register);
3308
3309 void proto_unregister(struct proto *prot)
3310 {
3311 mutex_lock(&proto_list_mutex);
3312 release_proto_idx(prot);
3313 list_del(&prot->node);
3314 mutex_unlock(&proto_list_mutex);
3315
3316 kmem_cache_destroy(prot->slab);
3317 prot->slab = NULL;
3318
3319 req_prot_cleanup(prot->rsk_prot);
3320
3321 if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
3322 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
3323 kfree(prot->twsk_prot->twsk_slab_name);
3324 prot->twsk_prot->twsk_slab = NULL;
3325 }
3326 }
3327 EXPORT_SYMBOL(proto_unregister);
3328
3329 int sock_load_diag_module(int family, int protocol)
3330 {
3331 if (!protocol) {
3332 if (!sock_is_registered(family))
3333 return -ENOENT;
3334
3335 return request_module("net-pf-%d-proto-%d-type-%d", PF_NETLINK,
3336 NETLINK_SOCK_DIAG, family);
3337 }
3338
3339 #ifdef CONFIG_INET
3340 if (family == AF_INET &&
3341 !rcu_access_pointer(inet_protos[protocol]))
3342 return -ENOENT;
3343 #endif
3344
3345 return request_module("net-pf-%d-proto-%d-type-%d-%d", PF_NETLINK,
3346 NETLINK_SOCK_DIAG, family, protocol);
3347 }
3348 EXPORT_SYMBOL(sock_load_diag_module);
3349
3350 #ifdef CONFIG_PROC_FS
3351 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
3352 __acquires(proto_list_mutex)
3353 {
3354 mutex_lock(&proto_list_mutex);
3355 return seq_list_start_head(&proto_list, *pos);
3356 }
3357
3358 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
3359 {
3360 return seq_list_next(v, &proto_list, pos);
3361 }
3362
3363 static void proto_seq_stop(struct seq_file *seq, void *v)
3364 __releases(proto_list_mutex)
3365 {
3366 mutex_unlock(&proto_list_mutex);
3367 }
3368
3369 static char proto_method_implemented(const void *method)
3370 {
3371 return method == NULL ? 'n' : 'y';
3372 }
3373 static long sock_prot_memory_allocated(struct proto *proto)
3374 {
3375 return proto->memory_allocated != NULL ? proto_memory_allocated(proto) : -1L;
3376 }
3377
3378 static char *sock_prot_memory_pressure(struct proto *proto)
3379 {
3380 return proto->memory_pressure != NULL ?
3381 proto_memory_pressure(proto) ? "yes" : "no" : "NI";
3382 }
3383
3384 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
3385 {
3386
3387 seq_printf(seq, "%-9s %4u %6d %6ld %-3s %6u %-3s %-10s "
3388 "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
3389 proto->name,
3390 proto->obj_size,
3391 sock_prot_inuse_get(seq_file_net(seq), proto),
3392 sock_prot_memory_allocated(proto),
3393 sock_prot_memory_pressure(proto),
3394 proto->max_header,
3395 proto->slab == NULL ? "no" : "yes",
3396 module_name(proto->owner),
3397 proto_method_implemented(proto->close),
3398 proto_method_implemented(proto->connect),
3399 proto_method_implemented(proto->disconnect),
3400 proto_method_implemented(proto->accept),
3401 proto_method_implemented(proto->ioctl),
3402 proto_method_implemented(proto->init),
3403 proto_method_implemented(proto->destroy),
3404 proto_method_implemented(proto->shutdown),
3405 proto_method_implemented(proto->setsockopt),
3406 proto_method_implemented(proto->getsockopt),
3407 proto_method_implemented(proto->sendmsg),
3408 proto_method_implemented(proto->recvmsg),
3409 proto_method_implemented(proto->sendpage),
3410 proto_method_implemented(proto->bind),
3411 proto_method_implemented(proto->backlog_rcv),
3412 proto_method_implemented(proto->hash),
3413 proto_method_implemented(proto->unhash),
3414 proto_method_implemented(proto->get_port),
3415 proto_method_implemented(proto->enter_memory_pressure));
3416 }
3417
3418 static int proto_seq_show(struct seq_file *seq, void *v)
3419 {
3420 if (v == &proto_list)
3421 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
3422 "protocol",
3423 "size",
3424 "sockets",
3425 "memory",
3426 "press",
3427 "maxhdr",
3428 "slab",
3429 "module",
3430 "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
3431 else
3432 proto_seq_printf(seq, list_entry(v, struct proto, node));
3433 return 0;
3434 }
3435
3436 static const struct seq_operations proto_seq_ops = {
3437 .start = proto_seq_start,
3438 .next = proto_seq_next,
3439 .stop = proto_seq_stop,
3440 .show = proto_seq_show,
3441 };
3442
3443 static __net_init int proto_init_net(struct net *net)
3444 {
3445 if (!proc_create_net("protocols", 0444, net->proc_net, &proto_seq_ops,
3446 sizeof(struct seq_net_private)))
3447 return -ENOMEM;
3448
3449 return 0;
3450 }
3451
3452 static __net_exit void proto_exit_net(struct net *net)
3453 {
3454 remove_proc_entry("protocols", net->proc_net);
3455 }
3456
3457
3458 static __net_initdata struct pernet_operations proto_net_ops = {
3459 .init = proto_init_net,
3460 .exit = proto_exit_net,
3461 };
3462
3463 static int __init proto_init(void)
3464 {
3465 return register_pernet_subsys(&proto_net_ops);
3466 }
3467
3468 subsys_initcall(proto_init);
3469
3470 #endif /* PROC_FS */
3471
3472 #ifdef CONFIG_NET_RX_BUSY_POLL
3473 bool sk_busy_loop_end(void *p, unsigned long start_time)
3474 {
3475 struct sock *sk = p;
3476
3477 return !skb_queue_empty(&sk->sk_receive_queue) ||
3478 sk_busy_loop_timeout(sk, start_time);
3479 }
3480 EXPORT_SYMBOL(sk_busy_loop_end);
3481 #endif /* CONFIG_NET_RX_BUSY_POLL */
Linux with added FPC-III support