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