~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

TOMOYO Linux Cross Reference
Linux/net/core/sock.c

Version: ~ [ linux-5.1-rc5 ] ~ [ linux-5.0.7 ] ~ [ linux-4.20.17 ] ~ [ linux-4.19.34 ] ~ [ linux-4.18.20 ] ~ [ linux-4.17.19 ] ~ [ linux-4.16.18 ] ~ [ linux-4.15.18 ] ~ [ linux-4.14.111 ] ~ [ linux-4.13.16 ] ~ [ linux-4.12.14 ] ~ [ linux-4.11.12 ] ~ [ linux-4.10.17 ] ~ [ linux-4.9.168 ] ~ [ linux-4.8.17 ] ~ [ linux-4.7.10 ] ~ [ linux-4.6.7 ] ~ [ linux-4.5.7 ] ~ [ linux-4.4.178 ] ~ [ linux-4.3.6 ] ~ [ linux-4.2.8 ] ~ [ linux-4.1.52 ] ~ [ linux-4.0.9 ] ~ [ linux-3.19.8 ] ~ [ linux-3.18.138 ] ~ [ linux-3.17.8 ] ~ [ linux-3.16.65 ] ~ [ linux-3.15.10 ] ~ [ linux-3.14.79 ] ~ [ linux-3.13.11 ] ~ [ linux-3.12.74 ] ~ [ linux-3.11.10 ] ~ [ linux-3.10.108 ] ~ [ linux-3.9.11 ] ~ [ linux-3.8.13 ] ~ [ linux-3.7.10 ] ~ [ linux-3.6.11 ] ~ [ linux-3.5.7 ] ~ [ linux-3.4.113 ] ~ [ linux-3.3.8 ] ~ [ linux-3.2.102 ] ~ [ linux-3.1.10 ] ~ [ linux-3.0.101 ] ~ [ linux-2.6.39.4 ] ~ [ linux-2.6.38.8 ] ~ [ linux-2.6.37.6 ] ~ [ linux-2.6.36.4 ] ~ [ linux-2.6.35.14 ] ~ [ linux-2.6.34.15 ] ~ [ linux-2.6.33.20 ] ~ [ linux-2.6.32.71 ] ~ [ linux-2.6.0 ] ~ [ linux-2.4.37.11 ] ~ [ unix-v6-master ] ~ [ ccs-tools-1.8.5 ] ~ [ policy-sample ] ~
Architecture: ~ [ i386 ] ~ [ alpha ] ~ [ m68k ] ~ [ mips ] ~ [ ppc ] ~ [ sparc ] ~ [ sparc64 ] ~

  1 /*
  2  * INET         An implementation of the TCP/IP protocol suite for the LINUX
  3  *              operating system.  INET is implemented using the  BSD Socket
  4  *              interface as the means of communication with the user level.
  5  *
  6  *              Generic socket support routines. Memory allocators, socket lock/release
  7  *              handler for protocols to use and generic option handler.
  8  *
  9  *
 10  * Authors:     Ross Biro
 11  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
 12  *              Florian La Roche, <flla@stud.uni-sb.de>
 13  *              Alan Cox, <A.Cox@swansea.ac.uk>
 14  *
 15  * Fixes:
 16  *              Alan Cox        :       Numerous verify_area() problems
 17  *              Alan Cox        :       Connecting on a connecting socket
 18  *                                      now returns an error for tcp.
 19  *              Alan Cox        :       sock->protocol is set correctly.
 20  *                                      and is not sometimes left as 0.
 21  *              Alan Cox        :       connect handles icmp errors on a
 22  *                                      connect properly. Unfortunately there
 23  *                                      is a restart syscall nasty there. I
 24  *                                      can't match BSD without hacking the C
 25  *                                      library. Ideas urgently sought!
 26  *              Alan Cox        :       Disallow bind() to addresses that are
 27  *                                      not ours - especially broadcast ones!!
 28  *              Alan Cox        :       Socket 1024 _IS_ ok for users. (fencepost)
 29  *              Alan Cox        :       sock_wfree/sock_rfree don't destroy sockets,
 30  *                                      instead they leave that for the DESTROY timer.
 31  *              Alan Cox        :       Clean up error flag in accept
 32  *              Alan Cox        :       TCP ack handling is buggy, the DESTROY timer
 33  *                                      was buggy. Put a remove_sock() in the handler
 34  *                                      for memory when we hit 0. Also altered the timer
 35  *                                      code. The ACK stuff can wait and needs major
 36  *                                      TCP layer surgery.
 37  *              Alan Cox        :       Fixed TCP ack bug, removed remove sock
 38  *                                      and fixed timer/inet_bh race.
 39  *              Alan Cox        :       Added zapped flag for TCP
 40  *              Alan Cox        :       Move kfree_skb into skbuff.c and tidied up surplus code
 41  *              Alan Cox        :       for new sk_buff allocations wmalloc/rmalloc now call alloc_skb
 42  *              Alan Cox        :       kfree_s calls now are kfree_skbmem so we can track skb resources
 43  *              Alan Cox        :       Supports socket option broadcast now as does udp. Packet and raw need fixing.
 44  *              Alan Cox        :       Added RCVBUF,SNDBUF size setting. It suddenly occurred to me how easy it was so...
 45  *              Rick Sladkey    :       Relaxed UDP rules for matching packets.
 46  *              C.E.Hawkins     :       IFF_PROMISC/SIOCGHWADDR support
 47  *      Pauline Middelink       :       identd support
 48  *              Alan Cox        :       Fixed connect() taking signals I think.
 49  *              Alan Cox        :       SO_LINGER supported
 50  *              Alan Cox        :       Error reporting fixes
 51  *              Anonymous       :       inet_create tidied up (sk->reuse setting)
 52  *              Alan Cox        :       inet sockets don't set sk->type!
 53  *              Alan Cox        :       Split socket option code
 54  *              Alan Cox        :       Callbacks
 55  *              Alan Cox        :       Nagle flag for Charles & Johannes stuff
 56  *              Alex            :       Removed restriction on inet fioctl
 57  *              Alan Cox        :       Splitting INET from NET core
 58  *              Alan Cox        :       Fixed bogus SO_TYPE handling in getsockopt()
 59  *              Adam Caldwell   :       Missing return in SO_DONTROUTE/SO_DEBUG code
 60  *              Alan Cox        :       Split IP from generic code
 61  *              Alan Cox        :       New kfree_skbmem()
 62  *              Alan Cox        :       Make SO_DEBUG superuser only.
 63  *              Alan Cox        :       Allow anyone to clear SO_DEBUG
 64  *                                      (compatibility fix)
 65  *              Alan Cox        :       Added optimistic memory grabbing for AF_UNIX throughput.
 66  *              Alan Cox        :       Allocator for a socket is settable.
 67  *              Alan Cox        :       SO_ERROR includes soft errors.
 68  *              Alan Cox        :       Allow NULL arguments on some SO_ opts
 69  *              Alan Cox        :       Generic socket allocation to make hooks
 70  *                                      easier (suggested by Craig Metz).
 71  *              Michael Pall    :       SO_ERROR returns positive errno again
 72  *              Steve Whitehouse:       Added default destructor to free
 73  *                                      protocol private data.
 74  *              Steve Whitehouse:       Added various other default routines
 75  *                                      common to several socket families.
 76  *              Chris Evans     :       Call suser() check last on F_SETOWN
 77  *              Jay Schulist    :       Added SO_ATTACH_FILTER and SO_DETACH_FILTER.
 78  *              Andi Kleen      :       Add sock_kmalloc()/sock_kfree_s()
 79  *              Andi Kleen      :       Fix write_space callback
 80  *              Chris Evans     :       Security fixes - signedness again
 81  *              Arnaldo C. Melo :       cleanups, use skb_queue_purge
 82  *
 83  * To Fix:
 84  *
 85  *
 86  *              This program is free software; you can redistribute it and/or
 87  *              modify it under the terms of the GNU General Public License
 88  *              as published by the Free Software Foundation; either version
 89  *              2 of the License, or (at your option) any later version.
 90  */
 91 
 92 #include <linux/capability.h>
 93 #include <linux/errno.h>
 94 #include <linux/types.h>
 95 #include <linux/socket.h>
 96 #include <linux/in.h>
 97 #include <linux/kernel.h>
 98 #include <linux/module.h>
 99 #include <linux/proc_fs.h>
100 #include <linux/seq_file.h>
101 #include <linux/sched.h>
102 #include <linux/timer.h>
103 #include <linux/string.h>
104 #include <linux/sockios.h>
105 #include <linux/net.h>
106 #include <linux/mm.h>
107 #include <linux/slab.h>
108 #include <linux/interrupt.h>
109 #include <linux/poll.h>
110 #include <linux/tcp.h>
111 #include <linux/init.h>
112 #include <linux/highmem.h>
113 #include <linux/user_namespace.h>
114 #include <linux/static_key.h>
115 #include <linux/memcontrol.h>
116 
117 #include <asm/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 
131 #include <linux/filter.h>
132 
133 #include <trace/events/sock.h>
134 
135 #ifdef CONFIG_INET
136 #include <net/tcp.h>
137 #endif
138 
139 static DEFINE_MUTEX(proto_list_mutex);
140 static LIST_HEAD(proto_list);
141 
142 #ifdef CONFIG_CGROUP_MEM_RES_CTLR_KMEM
143 int mem_cgroup_sockets_init(struct cgroup *cgrp, struct cgroup_subsys *ss)
144 {
145         struct proto *proto;
146         int ret = 0;
147 
148         mutex_lock(&proto_list_mutex);
149         list_for_each_entry(proto, &proto_list, node) {
150                 if (proto->init_cgroup) {
151                         ret = proto->init_cgroup(cgrp, ss);
152                         if (ret)
153                                 goto out;
154                 }
155         }
156 
157         mutex_unlock(&proto_list_mutex);
158         return ret;
159 out:
160         list_for_each_entry_continue_reverse(proto, &proto_list, node)
161                 if (proto->destroy_cgroup)
162                         proto->destroy_cgroup(cgrp);
163         mutex_unlock(&proto_list_mutex);
164         return ret;
165 }
166 
167 void mem_cgroup_sockets_destroy(struct cgroup *cgrp)
168 {
169         struct proto *proto;
170 
171         mutex_lock(&proto_list_mutex);
172         list_for_each_entry_reverse(proto, &proto_list, node)
173                 if (proto->destroy_cgroup)
174                         proto->destroy_cgroup(cgrp);
175         mutex_unlock(&proto_list_mutex);
176 }
177 #endif
178 
179 /*
180  * Each address family might have different locking rules, so we have
181  * one slock key per address family:
182  */
183 static struct lock_class_key af_family_keys[AF_MAX];
184 static struct lock_class_key af_family_slock_keys[AF_MAX];
185 
186 struct static_key memcg_socket_limit_enabled;
187 EXPORT_SYMBOL(memcg_socket_limit_enabled);
188 
189 /*
190  * Make lock validator output more readable. (we pre-construct these
191  * strings build-time, so that runtime initialization of socket
192  * locks is fast):
193  */
194 static const char *const af_family_key_strings[AF_MAX+1] = {
195   "sk_lock-AF_UNSPEC", "sk_lock-AF_UNIX"     , "sk_lock-AF_INET"     ,
196   "sk_lock-AF_AX25"  , "sk_lock-AF_IPX"      , "sk_lock-AF_APPLETALK",
197   "sk_lock-AF_NETROM", "sk_lock-AF_BRIDGE"   , "sk_lock-AF_ATMPVC"   ,
198   "sk_lock-AF_X25"   , "sk_lock-AF_INET6"    , "sk_lock-AF_ROSE"     ,
199   "sk_lock-AF_DECnet", "sk_lock-AF_NETBEUI"  , "sk_lock-AF_SECURITY" ,
200   "sk_lock-AF_KEY"   , "sk_lock-AF_NETLINK"  , "sk_lock-AF_PACKET"   ,
201   "sk_lock-AF_ASH"   , "sk_lock-AF_ECONET"   , "sk_lock-AF_ATMSVC"   ,
202   "sk_lock-AF_RDS"   , "sk_lock-AF_SNA"      , "sk_lock-AF_IRDA"     ,
203   "sk_lock-AF_PPPOX" , "sk_lock-AF_WANPIPE"  , "sk_lock-AF_LLC"      ,
204   "sk_lock-27"       , "sk_lock-28"          , "sk_lock-AF_CAN"      ,
205   "sk_lock-AF_TIPC"  , "sk_lock-AF_BLUETOOTH", "sk_lock-IUCV"        ,
206   "sk_lock-AF_RXRPC" , "sk_lock-AF_ISDN"     , "sk_lock-AF_PHONET"   ,
207   "sk_lock-AF_IEEE802154", "sk_lock-AF_CAIF" , "sk_lock-AF_ALG"      ,
208   "sk_lock-AF_NFC"   , "sk_lock-AF_MAX"
209 };
210 static const char *const af_family_slock_key_strings[AF_MAX+1] = {
211   "slock-AF_UNSPEC", "slock-AF_UNIX"     , "slock-AF_INET"     ,
212   "slock-AF_AX25"  , "slock-AF_IPX"      , "slock-AF_APPLETALK",
213   "slock-AF_NETROM", "slock-AF_BRIDGE"   , "slock-AF_ATMPVC"   ,
214   "slock-AF_X25"   , "slock-AF_INET6"    , "slock-AF_ROSE"     ,
215   "slock-AF_DECnet", "slock-AF_NETBEUI"  , "slock-AF_SECURITY" ,
216   "slock-AF_KEY"   , "slock-AF_NETLINK"  , "slock-AF_PACKET"   ,
217   "slock-AF_ASH"   , "slock-AF_ECONET"   , "slock-AF_ATMSVC"   ,
218   "slock-AF_RDS"   , "slock-AF_SNA"      , "slock-AF_IRDA"     ,
219   "slock-AF_PPPOX" , "slock-AF_WANPIPE"  , "slock-AF_LLC"      ,
220   "slock-27"       , "slock-28"          , "slock-AF_CAN"      ,
221   "slock-AF_TIPC"  , "slock-AF_BLUETOOTH", "slock-AF_IUCV"     ,
222   "slock-AF_RXRPC" , "slock-AF_ISDN"     , "slock-AF_PHONET"   ,
223   "slock-AF_IEEE802154", "slock-AF_CAIF" , "slock-AF_ALG"      ,
224   "slock-AF_NFC"   , "slock-AF_MAX"
225 };
226 static const char *const af_family_clock_key_strings[AF_MAX+1] = {
227   "clock-AF_UNSPEC", "clock-AF_UNIX"     , "clock-AF_INET"     ,
228   "clock-AF_AX25"  , "clock-AF_IPX"      , "clock-AF_APPLETALK",
229   "clock-AF_NETROM", "clock-AF_BRIDGE"   , "clock-AF_ATMPVC"   ,
230   "clock-AF_X25"   , "clock-AF_INET6"    , "clock-AF_ROSE"     ,
231   "clock-AF_DECnet", "clock-AF_NETBEUI"  , "clock-AF_SECURITY" ,
232   "clock-AF_KEY"   , "clock-AF_NETLINK"  , "clock-AF_PACKET"   ,
233   "clock-AF_ASH"   , "clock-AF_ECONET"   , "clock-AF_ATMSVC"   ,
234   "clock-AF_RDS"   , "clock-AF_SNA"      , "clock-AF_IRDA"     ,
235   "clock-AF_PPPOX" , "clock-AF_WANPIPE"  , "clock-AF_LLC"      ,
236   "clock-27"       , "clock-28"          , "clock-AF_CAN"      ,
237   "clock-AF_TIPC"  , "clock-AF_BLUETOOTH", "clock-AF_IUCV"     ,
238   "clock-AF_RXRPC" , "clock-AF_ISDN"     , "clock-AF_PHONET"   ,
239   "clock-AF_IEEE802154", "clock-AF_CAIF" , "clock-AF_ALG"      ,
240   "clock-AF_NFC"   , "clock-AF_MAX"
241 };
242 
243 /*
244  * sk_callback_lock locking rules are per-address-family,
245  * so split the lock classes by using a per-AF key:
246  */
247 static struct lock_class_key af_callback_keys[AF_MAX];
248 
249 /* Take into consideration the size of the struct sk_buff overhead in the
250  * determination of these values, since that is non-constant across
251  * platforms.  This makes socket queueing behavior and performance
252  * not depend upon such differences.
253  */
254 #define _SK_MEM_PACKETS         256
255 #define _SK_MEM_OVERHEAD        SKB_TRUESIZE(256)
256 #define SK_WMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
257 #define SK_RMEM_MAX             (_SK_MEM_OVERHEAD * _SK_MEM_PACKETS)
258 
259 /* Run time adjustable parameters. */
260 __u32 sysctl_wmem_max __read_mostly = SK_WMEM_MAX;
261 __u32 sysctl_rmem_max __read_mostly = SK_RMEM_MAX;
262 __u32 sysctl_wmem_default __read_mostly = SK_WMEM_MAX;
263 __u32 sysctl_rmem_default __read_mostly = SK_RMEM_MAX;
264 
265 /* Maximal space eaten by iovec or ancillary data plus some space */
266 int sysctl_optmem_max __read_mostly = sizeof(unsigned long)*(2*UIO_MAXIOV+512);
267 EXPORT_SYMBOL(sysctl_optmem_max);
268 
269 #if defined(CONFIG_CGROUPS)
270 #if !defined(CONFIG_NET_CLS_CGROUP)
271 int net_cls_subsys_id = -1;
272 EXPORT_SYMBOL_GPL(net_cls_subsys_id);
273 #endif
274 #if !defined(CONFIG_NETPRIO_CGROUP)
275 int net_prio_subsys_id = -1;
276 EXPORT_SYMBOL_GPL(net_prio_subsys_id);
277 #endif
278 #endif
279 
280 static int sock_set_timeout(long *timeo_p, char __user *optval, int optlen)
281 {
282         struct timeval tv;
283 
284         if (optlen < sizeof(tv))
285                 return -EINVAL;
286         if (copy_from_user(&tv, optval, sizeof(tv)))
287                 return -EFAULT;
288         if (tv.tv_usec < 0 || tv.tv_usec >= USEC_PER_SEC)
289                 return -EDOM;
290 
291         if (tv.tv_sec < 0) {
292                 static int warned __read_mostly;
293 
294                 *timeo_p = 0;
295                 if (warned < 10 && net_ratelimit()) {
296                         warned++;
297                         printk(KERN_INFO "sock_set_timeout: `%s' (pid %d) "
298                                "tries to set negative timeout\n",
299                                 current->comm, task_pid_nr(current));
300                 }
301                 return 0;
302         }
303         *timeo_p = MAX_SCHEDULE_TIMEOUT;
304         if (tv.tv_sec == 0 && tv.tv_usec == 0)
305                 return 0;
306         if (tv.tv_sec < (MAX_SCHEDULE_TIMEOUT/HZ - 1))
307                 *timeo_p = tv.tv_sec*HZ + (tv.tv_usec+(1000000/HZ-1))/(1000000/HZ);
308         return 0;
309 }
310 
311 static void sock_warn_obsolete_bsdism(const char *name)
312 {
313         static int warned;
314         static char warncomm[TASK_COMM_LEN];
315         if (strcmp(warncomm, current->comm) && warned < 5) {
316                 strcpy(warncomm,  current->comm);
317                 printk(KERN_WARNING "process `%s' is using obsolete "
318                        "%s SO_BSDCOMPAT\n", warncomm, name);
319                 warned++;
320         }
321 }
322 
323 #define SK_FLAGS_TIMESTAMP ((1UL << SOCK_TIMESTAMP) | (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE))
324 
325 static void sock_disable_timestamp(struct sock *sk, unsigned long flags)
326 {
327         if (sk->sk_flags & flags) {
328                 sk->sk_flags &= ~flags;
329                 if (!(sk->sk_flags & SK_FLAGS_TIMESTAMP))
330                         net_disable_timestamp();
331         }
332 }
333 
334 
335 int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb)
336 {
337         int err;
338         int skb_len;
339         unsigned long flags;
340         struct sk_buff_head *list = &sk->sk_receive_queue;
341 
342         if (atomic_read(&sk->sk_rmem_alloc) >= sk->sk_rcvbuf) {
343                 atomic_inc(&sk->sk_drops);
344                 trace_sock_rcvqueue_full(sk, skb);
345                 return -ENOMEM;
346         }
347 
348         err = sk_filter(sk, skb);
349         if (err)
350                 return err;
351 
352         if (!sk_rmem_schedule(sk, skb->truesize)) {
353                 atomic_inc(&sk->sk_drops);
354                 return -ENOBUFS;
355         }
356 
357         skb->dev = NULL;
358         skb_set_owner_r(skb, sk);
359 
360         /* Cache the SKB length before we tack it onto the receive
361          * queue.  Once it is added it no longer belongs to us and
362          * may be freed by other threads of control pulling packets
363          * from the queue.
364          */
365         skb_len = skb->len;
366 
367         /* we escape from rcu protected region, make sure we dont leak
368          * a norefcounted dst
369          */
370         skb_dst_force(skb);
371 
372         spin_lock_irqsave(&list->lock, flags);
373         skb->dropcount = atomic_read(&sk->sk_drops);
374         __skb_queue_tail(list, skb);
375         spin_unlock_irqrestore(&list->lock, flags);
376 
377         if (!sock_flag(sk, SOCK_DEAD))
378                 sk->sk_data_ready(sk, skb_len);
379         return 0;
380 }
381 EXPORT_SYMBOL(sock_queue_rcv_skb);
382 
383 int sk_receive_skb(struct sock *sk, struct sk_buff *skb, const int nested)
384 {
385         int rc = NET_RX_SUCCESS;
386 
387         if (sk_filter(sk, skb))
388                 goto discard_and_relse;
389 
390         skb->dev = NULL;
391 
392         if (sk_rcvqueues_full(sk, skb)) {
393                 atomic_inc(&sk->sk_drops);
394                 goto discard_and_relse;
395         }
396         if (nested)
397                 bh_lock_sock_nested(sk);
398         else
399                 bh_lock_sock(sk);
400         if (!sock_owned_by_user(sk)) {
401                 /*
402                  * trylock + unlock semantics:
403                  */
404                 mutex_acquire(&sk->sk_lock.dep_map, 0, 1, _RET_IP_);
405 
406                 rc = sk_backlog_rcv(sk, skb);
407 
408                 mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
409         } else if (sk_add_backlog(sk, skb)) {
410                 bh_unlock_sock(sk);
411                 atomic_inc(&sk->sk_drops);
412                 goto discard_and_relse;
413         }
414 
415         bh_unlock_sock(sk);
416 out:
417         sock_put(sk);
418         return rc;
419 discard_and_relse:
420         kfree_skb(skb);
421         goto out;
422 }
423 EXPORT_SYMBOL(sk_receive_skb);
424 
425 void sk_reset_txq(struct sock *sk)
426 {
427         sk_tx_queue_clear(sk);
428 }
429 EXPORT_SYMBOL(sk_reset_txq);
430 
431 struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie)
432 {
433         struct dst_entry *dst = __sk_dst_get(sk);
434 
435         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
436                 sk_tx_queue_clear(sk);
437                 RCU_INIT_POINTER(sk->sk_dst_cache, NULL);
438                 dst_release(dst);
439                 return NULL;
440         }
441 
442         return dst;
443 }
444 EXPORT_SYMBOL(__sk_dst_check);
445 
446 struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie)
447 {
448         struct dst_entry *dst = sk_dst_get(sk);
449 
450         if (dst && dst->obsolete && dst->ops->check(dst, cookie) == NULL) {
451                 sk_dst_reset(sk);
452                 dst_release(dst);
453                 return NULL;
454         }
455 
456         return dst;
457 }
458 EXPORT_SYMBOL(sk_dst_check);
459 
460 static int sock_bindtodevice(struct sock *sk, char __user *optval, int optlen)
461 {
462         int ret = -ENOPROTOOPT;
463 #ifdef CONFIG_NETDEVICES
464         struct net *net = sock_net(sk);
465         char devname[IFNAMSIZ];
466         int index;
467 
468         /* Sorry... */
469         ret = -EPERM;
470         if (!capable(CAP_NET_RAW))
471                 goto out;
472 
473         ret = -EINVAL;
474         if (optlen < 0)
475                 goto out;
476 
477         /* Bind this socket to a particular device like "eth0",
478          * as specified in the passed interface name. If the
479          * name is "" or the option length is zero the socket
480          * is not bound.
481          */
482         if (optlen > IFNAMSIZ - 1)
483                 optlen = IFNAMSIZ - 1;
484         memset(devname, 0, sizeof(devname));
485 
486         ret = -EFAULT;
487         if (copy_from_user(devname, optval, optlen))
488                 goto out;
489 
490         index = 0;
491         if (devname[0] != '\0') {
492                 struct net_device *dev;
493 
494                 rcu_read_lock();
495                 dev = dev_get_by_name_rcu(net, devname);
496                 if (dev)
497                         index = dev->ifindex;
498                 rcu_read_unlock();
499                 ret = -ENODEV;
500                 if (!dev)
501                         goto out;
502         }
503 
504         lock_sock(sk);
505         sk->sk_bound_dev_if = index;
506         sk_dst_reset(sk);
507         release_sock(sk);
508 
509         ret = 0;
510 
511 out:
512 #endif
513 
514         return ret;
515 }
516 
517 static inline void sock_valbool_flag(struct sock *sk, int bit, int valbool)
518 {
519         if (valbool)
520                 sock_set_flag(sk, bit);
521         else
522                 sock_reset_flag(sk, bit);
523 }
524 
525 /*
526  *      This is meant for all protocols to use and covers goings on
527  *      at the socket level. Everything here is generic.
528  */
529 
530 int sock_setsockopt(struct socket *sock, int level, int optname,
531                     char __user *optval, unsigned int optlen)
532 {
533         struct sock *sk = sock->sk;
534         int val;
535         int valbool;
536         struct linger ling;
537         int ret = 0;
538 
539         /*
540          *      Options without arguments
541          */
542 
543         if (optname == SO_BINDTODEVICE)
544                 return sock_bindtodevice(sk, optval, optlen);
545 
546         if (optlen < sizeof(int))
547                 return -EINVAL;
548 
549         if (get_user(val, (int __user *)optval))
550                 return -EFAULT;
551 
552         valbool = val ? 1 : 0;
553 
554         lock_sock(sk);
555 
556         switch (optname) {
557         case SO_DEBUG:
558                 if (val && !capable(CAP_NET_ADMIN))
559                         ret = -EACCES;
560                 else
561                         sock_valbool_flag(sk, SOCK_DBG, valbool);
562                 break;
563         case SO_REUSEADDR:
564                 sk->sk_reuse = valbool;
565                 break;
566         case SO_TYPE:
567         case SO_PROTOCOL:
568         case SO_DOMAIN:
569         case SO_ERROR:
570                 ret = -ENOPROTOOPT;
571                 break;
572         case SO_DONTROUTE:
573                 sock_valbool_flag(sk, SOCK_LOCALROUTE, valbool);
574                 break;
575         case SO_BROADCAST:
576                 sock_valbool_flag(sk, SOCK_BROADCAST, valbool);
577                 break;
578         case SO_SNDBUF:
579                 /* Don't error on this BSD doesn't and if you think
580                    about it this is right. Otherwise apps have to
581                    play 'guess the biggest size' games. RCVBUF/SNDBUF
582                    are treated in BSD as hints */
583 
584                 if (val > sysctl_wmem_max)
585                         val = sysctl_wmem_max;
586 set_sndbuf:
587                 sk->sk_userlocks |= SOCK_SNDBUF_LOCK;
588                 if ((val * 2) < SOCK_MIN_SNDBUF)
589                         sk->sk_sndbuf = SOCK_MIN_SNDBUF;
590                 else
591                         sk->sk_sndbuf = val * 2;
592 
593                 /*
594                  *      Wake up sending tasks if we
595                  *      upped the value.
596                  */
597                 sk->sk_write_space(sk);
598                 break;
599 
600         case SO_SNDBUFFORCE:
601                 if (!capable(CAP_NET_ADMIN)) {
602                         ret = -EPERM;
603                         break;
604                 }
605                 goto set_sndbuf;
606 
607         case SO_RCVBUF:
608                 /* Don't error on this BSD doesn't and if you think
609                    about it this is right. Otherwise apps have to
610                    play 'guess the biggest size' games. RCVBUF/SNDBUF
611                    are treated in BSD as hints */
612 
613                 if (val > sysctl_rmem_max)
614                         val = sysctl_rmem_max;
615 set_rcvbuf:
616                 sk->sk_userlocks |= SOCK_RCVBUF_LOCK;
617                 /*
618                  * We double it on the way in to account for
619                  * "struct sk_buff" etc. overhead.   Applications
620                  * assume that the SO_RCVBUF setting they make will
621                  * allow that much actual data to be received on that
622                  * socket.
623                  *
624                  * Applications are unaware that "struct sk_buff" and
625                  * other overheads allocate from the receive buffer
626                  * during socket buffer allocation.
627                  *
628                  * And after considering the possible alternatives,
629                  * returning the value we actually used in getsockopt
630                  * is the most desirable behavior.
631                  */
632                 if ((val * 2) < SOCK_MIN_RCVBUF)
633                         sk->sk_rcvbuf = SOCK_MIN_RCVBUF;
634                 else
635                         sk->sk_rcvbuf = val * 2;
636                 break;
637 
638         case SO_RCVBUFFORCE:
639                 if (!capable(CAP_NET_ADMIN)) {
640                         ret = -EPERM;
641                         break;
642                 }
643                 goto set_rcvbuf;
644 
645         case SO_KEEPALIVE:
646 #ifdef CONFIG_INET
647                 if (sk->sk_protocol == IPPROTO_TCP &&
648                     sk->sk_type == SOCK_STREAM)
649                         tcp_set_keepalive(sk, valbool);
650 #endif
651                 sock_valbool_flag(sk, SOCK_KEEPOPEN, valbool);
652                 break;
653 
654         case SO_OOBINLINE:
655                 sock_valbool_flag(sk, SOCK_URGINLINE, valbool);
656                 break;
657 
658         case SO_NO_CHECK:
659                 sk->sk_no_check = valbool;
660                 break;
661 
662         case SO_PRIORITY:
663                 if ((val >= 0 && val <= 6) || capable(CAP_NET_ADMIN))
664                         sk->sk_priority = val;
665                 else
666                         ret = -EPERM;
667                 break;
668 
669         case SO_LINGER:
670                 if (optlen < sizeof(ling)) {
671                         ret = -EINVAL;  /* 1003.1g */
672                         break;
673                 }
674                 if (copy_from_user(&ling, optval, sizeof(ling))) {
675                         ret = -EFAULT;
676                         break;
677                 }
678                 if (!ling.l_onoff)
679                         sock_reset_flag(sk, SOCK_LINGER);
680                 else {
681 #if (BITS_PER_LONG == 32)
682                         if ((unsigned int)ling.l_linger >= MAX_SCHEDULE_TIMEOUT/HZ)
683                                 sk->sk_lingertime = MAX_SCHEDULE_TIMEOUT;
684                         else
685 #endif
686                                 sk->sk_lingertime = (unsigned int)ling.l_linger * HZ;
687                         sock_set_flag(sk, SOCK_LINGER);
688                 }
689                 break;
690 
691         case SO_BSDCOMPAT:
692                 sock_warn_obsolete_bsdism("setsockopt");
693                 break;
694 
695         case SO_PASSCRED:
696                 if (valbool)
697                         set_bit(SOCK_PASSCRED, &sock->flags);
698                 else
699                         clear_bit(SOCK_PASSCRED, &sock->flags);
700                 break;
701 
702         case SO_TIMESTAMP:
703         case SO_TIMESTAMPNS:
704                 if (valbool)  {
705                         if (optname == SO_TIMESTAMP)
706                                 sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
707                         else
708                                 sock_set_flag(sk, SOCK_RCVTSTAMPNS);
709                         sock_set_flag(sk, SOCK_RCVTSTAMP);
710                         sock_enable_timestamp(sk, SOCK_TIMESTAMP);
711                 } else {
712                         sock_reset_flag(sk, SOCK_RCVTSTAMP);
713                         sock_reset_flag(sk, SOCK_RCVTSTAMPNS);
714                 }
715                 break;
716 
717         case SO_TIMESTAMPING:
718                 if (val & ~SOF_TIMESTAMPING_MASK) {
719                         ret = -EINVAL;
720                         break;
721                 }
722                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE,
723                                   val & SOF_TIMESTAMPING_TX_HARDWARE);
724                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE,
725                                   val & SOF_TIMESTAMPING_TX_SOFTWARE);
726                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE,
727                                   val & SOF_TIMESTAMPING_RX_HARDWARE);
728                 if (val & SOF_TIMESTAMPING_RX_SOFTWARE)
729                         sock_enable_timestamp(sk,
730                                               SOCK_TIMESTAMPING_RX_SOFTWARE);
731                 else
732                         sock_disable_timestamp(sk,
733                                                (1UL << SOCK_TIMESTAMPING_RX_SOFTWARE));
734                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SOFTWARE,
735                                   val & SOF_TIMESTAMPING_SOFTWARE);
736                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE,
737                                   val & SOF_TIMESTAMPING_SYS_HARDWARE);
738                 sock_valbool_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE,
739                                   val & SOF_TIMESTAMPING_RAW_HARDWARE);
740                 break;
741 
742         case SO_RCVLOWAT:
743                 if (val < 0)
744                         val = INT_MAX;
745                 sk->sk_rcvlowat = val ? : 1;
746                 break;
747 
748         case SO_RCVTIMEO:
749                 ret = sock_set_timeout(&sk->sk_rcvtimeo, optval, optlen);
750                 break;
751 
752         case SO_SNDTIMEO:
753                 ret = sock_set_timeout(&sk->sk_sndtimeo, optval, optlen);
754                 break;
755 
756         case SO_ATTACH_FILTER:
757                 ret = -EINVAL;
758                 if (optlen == sizeof(struct sock_fprog)) {
759                         struct sock_fprog fprog;
760 
761                         ret = -EFAULT;
762                         if (copy_from_user(&fprog, optval, sizeof(fprog)))
763                                 break;
764 
765                         ret = sk_attach_filter(&fprog, sk);
766                 }
767                 break;
768 
769         case SO_DETACH_FILTER:
770                 ret = sk_detach_filter(sk);
771                 break;
772 
773         case SO_PASSSEC:
774                 if (valbool)
775                         set_bit(SOCK_PASSSEC, &sock->flags);
776                 else
777                         clear_bit(SOCK_PASSSEC, &sock->flags);
778                 break;
779         case SO_MARK:
780                 if (!capable(CAP_NET_ADMIN))
781                         ret = -EPERM;
782                 else
783                         sk->sk_mark = val;
784                 break;
785 
786                 /* We implement the SO_SNDLOWAT etc to
787                    not be settable (1003.1g 5.3) */
788         case SO_RXQ_OVFL:
789                 sock_valbool_flag(sk, SOCK_RXQ_OVFL, valbool);
790                 break;
791 
792         case SO_WIFI_STATUS:
793                 sock_valbool_flag(sk, SOCK_WIFI_STATUS, valbool);
794                 break;
795 
796         case SO_PEEK_OFF:
797                 if (sock->ops->set_peek_off)
798                         ret = sock->ops->set_peek_off(sk, val);
799                 else
800                         ret = -EOPNOTSUPP;
801                 break;
802 
803         case SO_NOFCS:
804                 sock_valbool_flag(sk, SOCK_NOFCS, valbool);
805                 break;
806 
807         default:
808                 ret = -ENOPROTOOPT;
809                 break;
810         }
811         release_sock(sk);
812         return ret;
813 }
814 EXPORT_SYMBOL(sock_setsockopt);
815 
816 
817 void cred_to_ucred(struct pid *pid, const struct cred *cred,
818                    struct ucred *ucred, bool use_effective)
819 {
820         ucred->pid = pid_vnr(pid);
821         ucred->uid = ucred->gid = -1;
822         if (cred) {
823                 struct user_namespace *current_ns = current_user_ns();
824 
825                 if (use_effective) {
826                         ucred->uid = user_ns_map_uid(current_ns, cred, cred->euid);
827                         ucred->gid = user_ns_map_gid(current_ns, cred, cred->egid);
828                 } else {
829                         ucred->uid = user_ns_map_uid(current_ns, cred, cred->uid);
830                         ucred->gid = user_ns_map_gid(current_ns, cred, cred->gid);
831                 }
832         }
833 }
834 EXPORT_SYMBOL_GPL(cred_to_ucred);
835 
836 int sock_getsockopt(struct socket *sock, int level, int optname,
837                     char __user *optval, int __user *optlen)
838 {
839         struct sock *sk = sock->sk;
840 
841         union {
842                 int val;
843                 struct linger ling;
844                 struct timeval tm;
845         } v;
846 
847         int lv = sizeof(int);
848         int len;
849 
850         if (get_user(len, optlen))
851                 return -EFAULT;
852         if (len < 0)
853                 return -EINVAL;
854 
855         memset(&v, 0, sizeof(v));
856 
857         switch (optname) {
858         case SO_DEBUG:
859                 v.val = sock_flag(sk, SOCK_DBG);
860                 break;
861 
862         case SO_DONTROUTE:
863                 v.val = sock_flag(sk, SOCK_LOCALROUTE);
864                 break;
865 
866         case SO_BROADCAST:
867                 v.val = !!sock_flag(sk, SOCK_BROADCAST);
868                 break;
869 
870         case SO_SNDBUF:
871                 v.val = sk->sk_sndbuf;
872                 break;
873 
874         case SO_RCVBUF:
875                 v.val = sk->sk_rcvbuf;
876                 break;
877 
878         case SO_REUSEADDR:
879                 v.val = sk->sk_reuse;
880                 break;
881 
882         case SO_KEEPALIVE:
883                 v.val = !!sock_flag(sk, SOCK_KEEPOPEN);
884                 break;
885 
886         case SO_TYPE:
887                 v.val = sk->sk_type;
888                 break;
889 
890         case SO_PROTOCOL:
891                 v.val = sk->sk_protocol;
892                 break;
893 
894         case SO_DOMAIN:
895                 v.val = sk->sk_family;
896                 break;
897 
898         case SO_ERROR:
899                 v.val = -sock_error(sk);
900                 if (v.val == 0)
901                         v.val = xchg(&sk->sk_err_soft, 0);
902                 break;
903 
904         case SO_OOBINLINE:
905                 v.val = !!sock_flag(sk, SOCK_URGINLINE);
906                 break;
907 
908         case SO_NO_CHECK:
909                 v.val = sk->sk_no_check;
910                 break;
911 
912         case SO_PRIORITY:
913                 v.val = sk->sk_priority;
914                 break;
915 
916         case SO_LINGER:
917                 lv              = sizeof(v.ling);
918                 v.ling.l_onoff  = !!sock_flag(sk, SOCK_LINGER);
919                 v.ling.l_linger = sk->sk_lingertime / HZ;
920                 break;
921 
922         case SO_BSDCOMPAT:
923                 sock_warn_obsolete_bsdism("getsockopt");
924                 break;
925 
926         case SO_TIMESTAMP:
927                 v.val = sock_flag(sk, SOCK_RCVTSTAMP) &&
928                                 !sock_flag(sk, SOCK_RCVTSTAMPNS);
929                 break;
930 
931         case SO_TIMESTAMPNS:
932                 v.val = sock_flag(sk, SOCK_RCVTSTAMPNS);
933                 break;
934 
935         case SO_TIMESTAMPING:
936                 v.val = 0;
937                 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_HARDWARE))
938                         v.val |= SOF_TIMESTAMPING_TX_HARDWARE;
939                 if (sock_flag(sk, SOCK_TIMESTAMPING_TX_SOFTWARE))
940                         v.val |= SOF_TIMESTAMPING_TX_SOFTWARE;
941                 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_HARDWARE))
942                         v.val |= SOF_TIMESTAMPING_RX_HARDWARE;
943                 if (sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE))
944                         v.val |= SOF_TIMESTAMPING_RX_SOFTWARE;
945                 if (sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE))
946                         v.val |= SOF_TIMESTAMPING_SOFTWARE;
947                 if (sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE))
948                         v.val |= SOF_TIMESTAMPING_SYS_HARDWARE;
949                 if (sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE))
950                         v.val |= SOF_TIMESTAMPING_RAW_HARDWARE;
951                 break;
952 
953         case SO_RCVTIMEO:
954                 lv = sizeof(struct timeval);
955                 if (sk->sk_rcvtimeo == MAX_SCHEDULE_TIMEOUT) {
956                         v.tm.tv_sec = 0;
957                         v.tm.tv_usec = 0;
958                 } else {
959                         v.tm.tv_sec = sk->sk_rcvtimeo / HZ;
960                         v.tm.tv_usec = ((sk->sk_rcvtimeo % HZ) * 1000000) / HZ;
961                 }
962                 break;
963 
964         case SO_SNDTIMEO:
965                 lv = sizeof(struct timeval);
966                 if (sk->sk_sndtimeo == MAX_SCHEDULE_TIMEOUT) {
967                         v.tm.tv_sec = 0;
968                         v.tm.tv_usec = 0;
969                 } else {
970                         v.tm.tv_sec = sk->sk_sndtimeo / HZ;
971                         v.tm.tv_usec = ((sk->sk_sndtimeo % HZ) * 1000000) / HZ;
972                 }
973                 break;
974 
975         case SO_RCVLOWAT:
976                 v.val = sk->sk_rcvlowat;
977                 break;
978 
979         case SO_SNDLOWAT:
980                 v.val = 1;
981                 break;
982 
983         case SO_PASSCRED:
984                 v.val = test_bit(SOCK_PASSCRED, &sock->flags) ? 1 : 0;
985                 break;
986 
987         case SO_PEERCRED:
988         {
989                 struct ucred peercred;
990                 if (len > sizeof(peercred))
991                         len = sizeof(peercred);
992                 cred_to_ucred(sk->sk_peer_pid, sk->sk_peer_cred,
993                               &peercred, true);
994                 if (copy_to_user(optval, &peercred, len))
995                         return -EFAULT;
996                 goto lenout;
997         }
998 
999         case SO_PEERNAME:
1000         {
1001                 char address[128];
1002 
1003                 if (sock->ops->getname(sock, (struct sockaddr *)address, &lv, 2))
1004                         return -ENOTCONN;
1005                 if (lv < len)
1006                         return -EINVAL;
1007                 if (copy_to_user(optval, address, len))
1008                         return -EFAULT;
1009                 goto lenout;
1010         }
1011 
1012         /* Dubious BSD thing... Probably nobody even uses it, but
1013          * the UNIX standard wants it for whatever reason... -DaveM
1014          */
1015         case SO_ACCEPTCONN:
1016                 v.val = sk->sk_state == TCP_LISTEN;
1017                 break;
1018 
1019         case SO_PASSSEC:
1020                 v.val = test_bit(SOCK_PASSSEC, &sock->flags) ? 1 : 0;
1021                 break;
1022 
1023         case SO_PEERSEC:
1024                 return security_socket_getpeersec_stream(sock, optval, optlen, len);
1025 
1026         case SO_MARK:
1027                 v.val = sk->sk_mark;
1028                 break;
1029 
1030         case SO_RXQ_OVFL:
1031                 v.val = !!sock_flag(sk, SOCK_RXQ_OVFL);
1032                 break;
1033 
1034         case SO_WIFI_STATUS:
1035                 v.val = !!sock_flag(sk, SOCK_WIFI_STATUS);
1036                 break;
1037 
1038         case SO_PEEK_OFF:
1039                 if (!sock->ops->set_peek_off)
1040                         return -EOPNOTSUPP;
1041 
1042                 v.val = sk->sk_peek_off;
1043                 break;
1044         case SO_NOFCS:
1045                 v.val = !!sock_flag(sk, SOCK_NOFCS);
1046                 break;
1047         default:
1048                 return -ENOPROTOOPT;
1049         }
1050 
1051         if (len > lv)
1052                 len = lv;
1053         if (copy_to_user(optval, &v, len))
1054                 return -EFAULT;
1055 lenout:
1056         if (put_user(len, optlen))
1057                 return -EFAULT;
1058         return 0;
1059 }
1060 
1061 /*
1062  * Initialize an sk_lock.
1063  *
1064  * (We also register the sk_lock with the lock validator.)
1065  */
1066 static inline void sock_lock_init(struct sock *sk)
1067 {
1068         sock_lock_init_class_and_name(sk,
1069                         af_family_slock_key_strings[sk->sk_family],
1070                         af_family_slock_keys + sk->sk_family,
1071                         af_family_key_strings[sk->sk_family],
1072                         af_family_keys + sk->sk_family);
1073 }
1074 
1075 /*
1076  * Copy all fields from osk to nsk but nsk->sk_refcnt must not change yet,
1077  * even temporarly, because of RCU lookups. sk_node should also be left as is.
1078  * We must not copy fields between sk_dontcopy_begin and sk_dontcopy_end
1079  */
1080 static void sock_copy(struct sock *nsk, const struct sock *osk)
1081 {
1082 #ifdef CONFIG_SECURITY_NETWORK
1083         void *sptr = nsk->sk_security;
1084 #endif
1085         memcpy(nsk, osk, offsetof(struct sock, sk_dontcopy_begin));
1086 
1087         memcpy(&nsk->sk_dontcopy_end, &osk->sk_dontcopy_end,
1088                osk->sk_prot->obj_size - offsetof(struct sock, sk_dontcopy_end));
1089 
1090 #ifdef CONFIG_SECURITY_NETWORK
1091         nsk->sk_security = sptr;
1092         security_sk_clone(osk, nsk);
1093 #endif
1094 }
1095 
1096 void sk_prot_clear_portaddr_nulls(struct sock *sk, int size)
1097 {
1098         unsigned long nulls1, nulls2;
1099 
1100         nulls1 = offsetof(struct sock, __sk_common.skc_node.next);
1101         nulls2 = offsetof(struct sock, __sk_common.skc_portaddr_node.next);
1102         if (nulls1 > nulls2)
1103                 swap(nulls1, nulls2);
1104 
1105         if (nulls1 != 0)
1106                 memset((char *)sk, 0, nulls1);
1107         memset((char *)sk + nulls1 + sizeof(void *), 0,
1108                nulls2 - nulls1 - sizeof(void *));
1109         memset((char *)sk + nulls2 + sizeof(void *), 0,
1110                size - nulls2 - sizeof(void *));
1111 }
1112 EXPORT_SYMBOL(sk_prot_clear_portaddr_nulls);
1113 
1114 static struct sock *sk_prot_alloc(struct proto *prot, gfp_t priority,
1115                 int family)
1116 {
1117         struct sock *sk;
1118         struct kmem_cache *slab;
1119 
1120         slab = prot->slab;
1121         if (slab != NULL) {
1122                 sk = kmem_cache_alloc(slab, priority & ~__GFP_ZERO);
1123                 if (!sk)
1124                         return sk;
1125                 if (priority & __GFP_ZERO) {
1126                         if (prot->clear_sk)
1127                                 prot->clear_sk(sk, prot->obj_size);
1128                         else
1129                                 sk_prot_clear_nulls(sk, prot->obj_size);
1130                 }
1131         } else
1132                 sk = kmalloc(prot->obj_size, priority);
1133 
1134         if (sk != NULL) {
1135                 kmemcheck_annotate_bitfield(sk, flags);
1136 
1137                 if (security_sk_alloc(sk, family, priority))
1138                         goto out_free;
1139 
1140                 if (!try_module_get(prot->owner))
1141                         goto out_free_sec;
1142                 sk_tx_queue_clear(sk);
1143         }
1144 
1145         return sk;
1146 
1147 out_free_sec:
1148         security_sk_free(sk);
1149 out_free:
1150         if (slab != NULL)
1151                 kmem_cache_free(slab, sk);
1152         else
1153                 kfree(sk);
1154         return NULL;
1155 }
1156 
1157 static void sk_prot_free(struct proto *prot, struct sock *sk)
1158 {
1159         struct kmem_cache *slab;
1160         struct module *owner;
1161 
1162         owner = prot->owner;
1163         slab = prot->slab;
1164 
1165         security_sk_free(sk);
1166         if (slab != NULL)
1167                 kmem_cache_free(slab, sk);
1168         else
1169                 kfree(sk);
1170         module_put(owner);
1171 }
1172 
1173 #ifdef CONFIG_CGROUPS
1174 void sock_update_classid(struct sock *sk)
1175 {
1176         u32 classid;
1177 
1178         rcu_read_lock();  /* doing current task, which cannot vanish. */
1179         classid = task_cls_classid(current);
1180         rcu_read_unlock();
1181         if (classid && classid != sk->sk_classid)
1182                 sk->sk_classid = classid;
1183 }
1184 EXPORT_SYMBOL(sock_update_classid);
1185 
1186 void sock_update_netprioidx(struct sock *sk)
1187 {
1188         if (in_interrupt())
1189                 return;
1190 
1191         sk->sk_cgrp_prioidx = task_netprioidx(current);
1192 }
1193 EXPORT_SYMBOL_GPL(sock_update_netprioidx);
1194 #endif
1195 
1196 /**
1197  *      sk_alloc - All socket objects are allocated here
1198  *      @net: the applicable net namespace
1199  *      @family: protocol family
1200  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1201  *      @prot: struct proto associated with this new sock instance
1202  */
1203 struct sock *sk_alloc(struct net *net, int family, gfp_t priority,
1204                       struct proto *prot)
1205 {
1206         struct sock *sk;
1207 
1208         sk = sk_prot_alloc(prot, priority | __GFP_ZERO, family);
1209         if (sk) {
1210                 sk->sk_family = family;
1211                 /*
1212                  * See comment in struct sock definition to understand
1213                  * why we need sk_prot_creator -acme
1214                  */
1215                 sk->sk_prot = sk->sk_prot_creator = prot;
1216                 sock_lock_init(sk);
1217                 sock_net_set(sk, get_net(net));
1218                 atomic_set(&sk->sk_wmem_alloc, 1);
1219 
1220                 sock_update_classid(sk);
1221                 sock_update_netprioidx(sk);
1222         }
1223 
1224         return sk;
1225 }
1226 EXPORT_SYMBOL(sk_alloc);
1227 
1228 static void __sk_free(struct sock *sk)
1229 {
1230         struct sk_filter *filter;
1231 
1232         if (sk->sk_destruct)
1233                 sk->sk_destruct(sk);
1234 
1235         filter = rcu_dereference_check(sk->sk_filter,
1236                                        atomic_read(&sk->sk_wmem_alloc) == 0);
1237         if (filter) {
1238                 sk_filter_uncharge(sk, filter);
1239                 RCU_INIT_POINTER(sk->sk_filter, NULL);
1240         }
1241 
1242         sock_disable_timestamp(sk, SK_FLAGS_TIMESTAMP);
1243 
1244         if (atomic_read(&sk->sk_omem_alloc))
1245                 printk(KERN_DEBUG "%s: optmem leakage (%d bytes) detected.\n",
1246                        __func__, atomic_read(&sk->sk_omem_alloc));
1247 
1248         if (sk->sk_peer_cred)
1249                 put_cred(sk->sk_peer_cred);
1250         put_pid(sk->sk_peer_pid);
1251         put_net(sock_net(sk));
1252         sk_prot_free(sk->sk_prot_creator, sk);
1253 }
1254 
1255 void sk_free(struct sock *sk)
1256 {
1257         /*
1258          * We subtract one from sk_wmem_alloc and can know if
1259          * some packets are still in some tx queue.
1260          * If not null, sock_wfree() will call __sk_free(sk) later
1261          */
1262         if (atomic_dec_and_test(&sk->sk_wmem_alloc))
1263                 __sk_free(sk);
1264 }
1265 EXPORT_SYMBOL(sk_free);
1266 
1267 /*
1268  * Last sock_put should drop reference to sk->sk_net. It has already
1269  * been dropped in sk_change_net. Taking reference to stopping namespace
1270  * is not an option.
1271  * Take reference to a socket to remove it from hash _alive_ and after that
1272  * destroy it in the context of init_net.
1273  */
1274 void sk_release_kernel(struct sock *sk)
1275 {
1276         if (sk == NULL || sk->sk_socket == NULL)
1277                 return;
1278 
1279         sock_hold(sk);
1280         sock_release(sk->sk_socket);
1281         release_net(sock_net(sk));
1282         sock_net_set(sk, get_net(&init_net));
1283         sock_put(sk);
1284 }
1285 EXPORT_SYMBOL(sk_release_kernel);
1286 
1287 static void sk_update_clone(const struct sock *sk, struct sock *newsk)
1288 {
1289         if (mem_cgroup_sockets_enabled && sk->sk_cgrp)
1290                 sock_update_memcg(newsk);
1291 }
1292 
1293 /**
1294  *      sk_clone_lock - clone a socket, and lock its clone
1295  *      @sk: the socket to clone
1296  *      @priority: for allocation (%GFP_KERNEL, %GFP_ATOMIC, etc)
1297  *
1298  *      Caller must unlock socket even in error path (bh_unlock_sock(newsk))
1299  */
1300 struct sock *sk_clone_lock(const struct sock *sk, const gfp_t priority)
1301 {
1302         struct sock *newsk;
1303 
1304         newsk = sk_prot_alloc(sk->sk_prot, priority, sk->sk_family);
1305         if (newsk != NULL) {
1306                 struct sk_filter *filter;
1307 
1308                 sock_copy(newsk, sk);
1309 
1310                 /* SANITY */
1311                 get_net(sock_net(newsk));
1312                 sk_node_init(&newsk->sk_node);
1313                 sock_lock_init(newsk);
1314                 bh_lock_sock(newsk);
1315                 newsk->sk_backlog.head  = newsk->sk_backlog.tail = NULL;
1316                 newsk->sk_backlog.len = 0;
1317 
1318                 atomic_set(&newsk->sk_rmem_alloc, 0);
1319                 /*
1320                  * sk_wmem_alloc set to one (see sk_free() and sock_wfree())
1321                  */
1322                 atomic_set(&newsk->sk_wmem_alloc, 1);
1323                 atomic_set(&newsk->sk_omem_alloc, 0);
1324                 skb_queue_head_init(&newsk->sk_receive_queue);
1325                 skb_queue_head_init(&newsk->sk_write_queue);
1326 #ifdef CONFIG_NET_DMA
1327                 skb_queue_head_init(&newsk->sk_async_wait_queue);
1328 #endif
1329 
1330                 spin_lock_init(&newsk->sk_dst_lock);
1331                 rwlock_init(&newsk->sk_callback_lock);
1332                 lockdep_set_class_and_name(&newsk->sk_callback_lock,
1333                                 af_callback_keys + newsk->sk_family,
1334                                 af_family_clock_key_strings[newsk->sk_family]);
1335 
1336                 newsk->sk_dst_cache     = NULL;
1337                 newsk->sk_wmem_queued   = 0;
1338                 newsk->sk_forward_alloc = 0;
1339                 newsk->sk_send_head     = NULL;
1340                 newsk->sk_userlocks     = sk->sk_userlocks & ~SOCK_BINDPORT_LOCK;
1341 
1342                 sock_reset_flag(newsk, SOCK_DONE);
1343                 skb_queue_head_init(&newsk->sk_error_queue);
1344 
1345                 filter = rcu_dereference_protected(newsk->sk_filter, 1);
1346                 if (filter != NULL)
1347                         sk_filter_charge(newsk, filter);
1348 
1349                 if (unlikely(xfrm_sk_clone_policy(newsk))) {
1350                         /* It is still raw copy of parent, so invalidate
1351                          * destructor and make plain sk_free() */
1352                         newsk->sk_destruct = NULL;
1353                         bh_unlock_sock(newsk);
1354                         sk_free(newsk);
1355                         newsk = NULL;
1356                         goto out;
1357                 }
1358 
1359                 newsk->sk_err      = 0;
1360                 newsk->sk_priority = 0;
1361                 /*
1362                  * Before updating sk_refcnt, we must commit prior changes to memory
1363                  * (Documentation/RCU/rculist_nulls.txt for details)
1364                  */
1365                 smp_wmb();
1366                 atomic_set(&newsk->sk_refcnt, 2);
1367 
1368                 /*
1369                  * Increment the counter in the same struct proto as the master
1370                  * sock (sk_refcnt_debug_inc uses newsk->sk_prot->socks, that
1371                  * is the same as sk->sk_prot->socks, as this field was copied
1372                  * with memcpy).
1373                  *
1374                  * This _changes_ the previous behaviour, where
1375                  * tcp_create_openreq_child always was incrementing the
1376                  * equivalent to tcp_prot->socks (inet_sock_nr), so this have
1377                  * to be taken into account in all callers. -acme
1378                  */
1379                 sk_refcnt_debug_inc(newsk);
1380                 sk_set_socket(newsk, NULL);
1381                 newsk->sk_wq = NULL;
1382 
1383                 sk_update_clone(sk, newsk);
1384 
1385                 if (newsk->sk_prot->sockets_allocated)
1386                         sk_sockets_allocated_inc(newsk);
1387 
1388                 if (newsk->sk_flags & SK_FLAGS_TIMESTAMP)
1389                         net_enable_timestamp();
1390         }
1391 out:
1392         return newsk;
1393 }
1394 EXPORT_SYMBOL_GPL(sk_clone_lock);
1395 
1396 void sk_setup_caps(struct sock *sk, struct dst_entry *dst)
1397 {
1398         __sk_dst_set(sk, dst);
1399         sk->sk_route_caps = dst->dev->features;
1400         if (sk->sk_route_caps & NETIF_F_GSO)
1401                 sk->sk_route_caps |= NETIF_F_GSO_SOFTWARE;
1402         sk->sk_route_caps &= ~sk->sk_route_nocaps;
1403         if (sk_can_gso(sk)) {
1404                 if (dst->header_len) {
1405                         sk->sk_route_caps &= ~NETIF_F_GSO_MASK;
1406                 } else {
1407                         sk->sk_route_caps |= NETIF_F_SG | NETIF_F_HW_CSUM;
1408                         sk->sk_gso_max_size = dst->dev->gso_max_size;
1409                         sk->sk_gso_max_segs = dst->dev->gso_max_segs;
1410                 }
1411         }
1412 }
1413 EXPORT_SYMBOL_GPL(sk_setup_caps);
1414 
1415 void __init sk_init(void)
1416 {
1417         if (totalram_pages <= 4096) {
1418                 sysctl_wmem_max = 32767;
1419                 sysctl_rmem_max = 32767;
1420                 sysctl_wmem_default = 32767;
1421                 sysctl_rmem_default = 32767;
1422         } else if (totalram_pages >= 131072) {
1423                 sysctl_wmem_max = 131071;
1424                 sysctl_rmem_max = 131071;
1425         }
1426 }
1427 
1428 /*
1429  *      Simple resource managers for sockets.
1430  */
1431 
1432 
1433 /*
1434  * Write buffer destructor automatically called from kfree_skb.
1435  */
1436 void sock_wfree(struct sk_buff *skb)
1437 {
1438         struct sock *sk = skb->sk;
1439         unsigned int len = skb->truesize;
1440 
1441         if (!sock_flag(sk, SOCK_USE_WRITE_QUEUE)) {
1442                 /*
1443                  * Keep a reference on sk_wmem_alloc, this will be released
1444                  * after sk_write_space() call
1445                  */
1446                 atomic_sub(len - 1, &sk->sk_wmem_alloc);
1447                 sk->sk_write_space(sk);
1448                 len = 1;
1449         }
1450         /*
1451          * if sk_wmem_alloc reaches 0, we must finish what sk_free()
1452          * could not do because of in-flight packets
1453          */
1454         if (atomic_sub_and_test(len, &sk->sk_wmem_alloc))
1455                 __sk_free(sk);
1456 }
1457 EXPORT_SYMBOL(sock_wfree);
1458 
1459 /*
1460  * Read buffer destructor automatically called from kfree_skb.
1461  */
1462 void sock_rfree(struct sk_buff *skb)
1463 {
1464         struct sock *sk = skb->sk;
1465         unsigned int len = skb->truesize;
1466 
1467         atomic_sub(len, &sk->sk_rmem_alloc);
1468         sk_mem_uncharge(sk, len);
1469 }
1470 EXPORT_SYMBOL(sock_rfree);
1471 
1472 
1473 int sock_i_uid(struct sock *sk)
1474 {
1475         int uid;
1476 
1477         read_lock_bh(&sk->sk_callback_lock);
1478         uid = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_uid : 0;
1479         read_unlock_bh(&sk->sk_callback_lock);
1480         return uid;
1481 }
1482 EXPORT_SYMBOL(sock_i_uid);
1483 
1484 unsigned long sock_i_ino(struct sock *sk)
1485 {
1486         unsigned long ino;
1487 
1488         read_lock_bh(&sk->sk_callback_lock);
1489         ino = sk->sk_socket ? SOCK_INODE(sk->sk_socket)->i_ino : 0;
1490         read_unlock_bh(&sk->sk_callback_lock);
1491         return ino;
1492 }
1493 EXPORT_SYMBOL(sock_i_ino);
1494 
1495 /*
1496  * Allocate a skb from the socket's send buffer.
1497  */
1498 struct sk_buff *sock_wmalloc(struct sock *sk, unsigned long size, int force,
1499                              gfp_t priority)
1500 {
1501         if (force || atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1502                 struct sk_buff *skb = alloc_skb(size, priority);
1503                 if (skb) {
1504                         skb_set_owner_w(skb, sk);
1505                         return skb;
1506                 }
1507         }
1508         return NULL;
1509 }
1510 EXPORT_SYMBOL(sock_wmalloc);
1511 
1512 /*
1513  * Allocate a skb from the socket's receive buffer.
1514  */
1515 struct sk_buff *sock_rmalloc(struct sock *sk, unsigned long size, int force,
1516                              gfp_t priority)
1517 {
1518         if (force || atomic_read(&sk->sk_rmem_alloc) < sk->sk_rcvbuf) {
1519                 struct sk_buff *skb = alloc_skb(size, priority);
1520                 if (skb) {
1521                         skb_set_owner_r(skb, sk);
1522                         return skb;
1523                 }
1524         }
1525         return NULL;
1526 }
1527 
1528 /*
1529  * Allocate a memory block from the socket's option memory buffer.
1530  */
1531 void *sock_kmalloc(struct sock *sk, int size, gfp_t priority)
1532 {
1533         if ((unsigned)size <= sysctl_optmem_max &&
1534             atomic_read(&sk->sk_omem_alloc) + size < sysctl_optmem_max) {
1535                 void *mem;
1536                 /* First do the add, to avoid the race if kmalloc
1537                  * might sleep.
1538                  */
1539                 atomic_add(size, &sk->sk_omem_alloc);
1540                 mem = kmalloc(size, priority);
1541                 if (mem)
1542                         return mem;
1543                 atomic_sub(size, &sk->sk_omem_alloc);
1544         }
1545         return NULL;
1546 }
1547 EXPORT_SYMBOL(sock_kmalloc);
1548 
1549 /*
1550  * Free an option memory block.
1551  */
1552 void sock_kfree_s(struct sock *sk, void *mem, int size)
1553 {
1554         kfree(mem);
1555         atomic_sub(size, &sk->sk_omem_alloc);
1556 }
1557 EXPORT_SYMBOL(sock_kfree_s);
1558 
1559 /* It is almost wait_for_tcp_memory minus release_sock/lock_sock.
1560    I think, these locks should be removed for datagram sockets.
1561  */
1562 static long sock_wait_for_wmem(struct sock *sk, long timeo)
1563 {
1564         DEFINE_WAIT(wait);
1565 
1566         clear_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1567         for (;;) {
1568                 if (!timeo)
1569                         break;
1570                 if (signal_pending(current))
1571                         break;
1572                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1573                 prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1574                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf)
1575                         break;
1576                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1577                         break;
1578                 if (sk->sk_err)
1579                         break;
1580                 timeo = schedule_timeout(timeo);
1581         }
1582         finish_wait(sk_sleep(sk), &wait);
1583         return timeo;
1584 }
1585 
1586 
1587 /*
1588  *      Generic send/receive buffer handlers
1589  */
1590 
1591 struct sk_buff *sock_alloc_send_pskb(struct sock *sk, unsigned long header_len,
1592                                      unsigned long data_len, int noblock,
1593                                      int *errcode)
1594 {
1595         struct sk_buff *skb;
1596         gfp_t gfp_mask;
1597         long timeo;
1598         int err;
1599         int npages = (data_len + (PAGE_SIZE - 1)) >> PAGE_SHIFT;
1600 
1601         err = -EMSGSIZE;
1602         if (npages > MAX_SKB_FRAGS)
1603                 goto failure;
1604 
1605         gfp_mask = sk->sk_allocation;
1606         if (gfp_mask & __GFP_WAIT)
1607                 gfp_mask |= __GFP_REPEAT;
1608 
1609         timeo = sock_sndtimeo(sk, noblock);
1610         while (1) {
1611                 err = sock_error(sk);
1612                 if (err != 0)
1613                         goto failure;
1614 
1615                 err = -EPIPE;
1616                 if (sk->sk_shutdown & SEND_SHUTDOWN)
1617                         goto failure;
1618 
1619                 if (atomic_read(&sk->sk_wmem_alloc) < sk->sk_sndbuf) {
1620                         skb = alloc_skb(header_len, gfp_mask);
1621                         if (skb) {
1622                                 int i;
1623 
1624                                 /* No pages, we're done... */
1625                                 if (!data_len)
1626                                         break;
1627 
1628                                 skb->truesize += data_len;
1629                                 skb_shinfo(skb)->nr_frags = npages;
1630                                 for (i = 0; i < npages; i++) {
1631                                         struct page *page;
1632 
1633                                         page = alloc_pages(sk->sk_allocation, 0);
1634                                         if (!page) {
1635                                                 err = -ENOBUFS;
1636                                                 skb_shinfo(skb)->nr_frags = i;
1637                                                 kfree_skb(skb);
1638                                                 goto failure;
1639                                         }
1640 
1641                                         __skb_fill_page_desc(skb, i,
1642                                                         page, 0,
1643                                                         (data_len >= PAGE_SIZE ?
1644                                                          PAGE_SIZE :
1645                                                          data_len));
1646                                         data_len -= PAGE_SIZE;
1647                                 }
1648 
1649                                 /* Full success... */
1650                                 break;
1651                         }
1652                         err = -ENOBUFS;
1653                         goto failure;
1654                 }
1655                 set_bit(SOCK_ASYNC_NOSPACE, &sk->sk_socket->flags);
1656                 set_bit(SOCK_NOSPACE, &sk->sk_socket->flags);
1657                 err = -EAGAIN;
1658                 if (!timeo)
1659                         goto failure;
1660                 if (signal_pending(current))
1661                         goto interrupted;
1662                 timeo = sock_wait_for_wmem(sk, timeo);
1663         }
1664 
1665         skb_set_owner_w(skb, sk);
1666         return skb;
1667 
1668 interrupted:
1669         err = sock_intr_errno(timeo);
1670 failure:
1671         *errcode = err;
1672         return NULL;
1673 }
1674 EXPORT_SYMBOL(sock_alloc_send_pskb);
1675 
1676 struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
1677                                     int noblock, int *errcode)
1678 {
1679         return sock_alloc_send_pskb(sk, size, 0, noblock, errcode);
1680 }
1681 EXPORT_SYMBOL(sock_alloc_send_skb);
1682 
1683 static void __lock_sock(struct sock *sk)
1684         __releases(&sk->sk_lock.slock)
1685         __acquires(&sk->sk_lock.slock)
1686 {
1687         DEFINE_WAIT(wait);
1688 
1689         for (;;) {
1690                 prepare_to_wait_exclusive(&sk->sk_lock.wq, &wait,
1691                                         TASK_UNINTERRUPTIBLE);
1692                 spin_unlock_bh(&sk->sk_lock.slock);
1693                 schedule();
1694                 spin_lock_bh(&sk->sk_lock.slock);
1695                 if (!sock_owned_by_user(sk))
1696                         break;
1697         }
1698         finish_wait(&sk->sk_lock.wq, &wait);
1699 }
1700 
1701 static void __release_sock(struct sock *sk)
1702         __releases(&sk->sk_lock.slock)
1703         __acquires(&sk->sk_lock.slock)
1704 {
1705         struct sk_buff *skb = sk->sk_backlog.head;
1706 
1707         do {
1708                 sk->sk_backlog.head = sk->sk_backlog.tail = NULL;
1709                 bh_unlock_sock(sk);
1710 
1711                 do {
1712                         struct sk_buff *next = skb->next;
1713 
1714                         WARN_ON_ONCE(skb_dst_is_noref(skb));
1715                         skb->next = NULL;
1716                         sk_backlog_rcv(sk, skb);
1717 
1718                         /*
1719                          * We are in process context here with softirqs
1720                          * disabled, use cond_resched_softirq() to preempt.
1721                          * This is safe to do because we've taken the backlog
1722                          * queue private:
1723                          */
1724                         cond_resched_softirq();
1725 
1726                         skb = next;
1727                 } while (skb != NULL);
1728 
1729                 bh_lock_sock(sk);
1730         } while ((skb = sk->sk_backlog.head) != NULL);
1731 
1732         /*
1733          * Doing the zeroing here guarantee we can not loop forever
1734          * while a wild producer attempts to flood us.
1735          */
1736         sk->sk_backlog.len = 0;
1737 }
1738 
1739 /**
1740  * sk_wait_data - wait for data to arrive at sk_receive_queue
1741  * @sk:    sock to wait on
1742  * @timeo: for how long
1743  *
1744  * Now socket state including sk->sk_err is changed only under lock,
1745  * hence we may omit checks after joining wait queue.
1746  * We check receive queue before schedule() only as optimization;
1747  * it is very likely that release_sock() added new data.
1748  */
1749 int sk_wait_data(struct sock *sk, long *timeo)
1750 {
1751         int rc;
1752         DEFINE_WAIT(wait);
1753 
1754         prepare_to_wait(sk_sleep(sk), &wait, TASK_INTERRUPTIBLE);
1755         set_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1756         rc = sk_wait_event(sk, timeo, !skb_queue_empty(&sk->sk_receive_queue));
1757         clear_bit(SOCK_ASYNC_WAITDATA, &sk->sk_socket->flags);
1758         finish_wait(sk_sleep(sk), &wait);
1759         return rc;
1760 }
1761 EXPORT_SYMBOL(sk_wait_data);
1762 
1763 /**
1764  *      __sk_mem_schedule - increase sk_forward_alloc and memory_allocated
1765  *      @sk: socket
1766  *      @size: memory size to allocate
1767  *      @kind: allocation type
1768  *
1769  *      If kind is SK_MEM_SEND, it means wmem allocation. Otherwise it means
1770  *      rmem allocation. This function assumes that protocols which have
1771  *      memory_pressure use sk_wmem_queued as write buffer accounting.
1772  */
1773 int __sk_mem_schedule(struct sock *sk, int size, int kind)
1774 {
1775         struct proto *prot = sk->sk_prot;
1776         int amt = sk_mem_pages(size);
1777         long allocated;
1778         int parent_status = UNDER_LIMIT;
1779 
1780         sk->sk_forward_alloc += amt * SK_MEM_QUANTUM;
1781 
1782         allocated = sk_memory_allocated_add(sk, amt, &parent_status);
1783 
1784         /* Under limit. */
1785         if (parent_status == UNDER_LIMIT &&
1786                         allocated <= sk_prot_mem_limits(sk, 0)) {
1787                 sk_leave_memory_pressure(sk);
1788                 return 1;
1789         }
1790 
1791         /* Under pressure. (we or our parents) */
1792         if ((parent_status > SOFT_LIMIT) ||
1793                         allocated > sk_prot_mem_limits(sk, 1))
1794                 sk_enter_memory_pressure(sk);
1795 
1796         /* Over hard limit (we or our parents) */
1797         if ((parent_status == OVER_LIMIT) ||
1798                         (allocated > sk_prot_mem_limits(sk, 2)))
1799                 goto suppress_allocation;
1800 
1801         /* guarantee minimum buffer size under pressure */
1802         if (kind == SK_MEM_RECV) {
1803                 if (atomic_read(&sk->sk_rmem_alloc) < prot->sysctl_rmem[0])
1804                         return 1;
1805 
1806         } else { /* SK_MEM_SEND */
1807                 if (sk->sk_type == SOCK_STREAM) {
1808                         if (sk->sk_wmem_queued < prot->sysctl_wmem[0])
1809                                 return 1;
1810                 } else if (atomic_read(&sk->sk_wmem_alloc) <
1811                            prot->sysctl_wmem[0])
1812                                 return 1;
1813         }
1814 
1815         if (sk_has_memory_pressure(sk)) {
1816                 int alloc;
1817 
1818                 if (!sk_under_memory_pressure(sk))
1819                         return 1;
1820                 alloc = sk_sockets_allocated_read_positive(sk);
1821                 if (sk_prot_mem_limits(sk, 2) > alloc *
1822                     sk_mem_pages(sk->sk_wmem_queued +
1823                                  atomic_read(&sk->sk_rmem_alloc) +
1824                                  sk->sk_forward_alloc))
1825                         return 1;
1826         }
1827 
1828 suppress_allocation:
1829 
1830         if (kind == SK_MEM_SEND && sk->sk_type == SOCK_STREAM) {
1831                 sk_stream_moderate_sndbuf(sk);
1832 
1833                 /* Fail only if socket is _under_ its sndbuf.
1834                  * In this case we cannot block, so that we have to fail.
1835                  */
1836                 if (sk->sk_wmem_queued + size >= sk->sk_sndbuf)
1837                         return 1;
1838         }
1839 
1840         trace_sock_exceed_buf_limit(sk, prot, allocated);
1841 
1842         /* Alas. Undo changes. */
1843         sk->sk_forward_alloc -= amt * SK_MEM_QUANTUM;
1844 
1845         sk_memory_allocated_sub(sk, amt);
1846 
1847         return 0;
1848 }
1849 EXPORT_SYMBOL(__sk_mem_schedule);
1850 
1851 /**
1852  *      __sk_reclaim - reclaim memory_allocated
1853  *      @sk: socket
1854  */
1855 void __sk_mem_reclaim(struct sock *sk)
1856 {
1857         sk_memory_allocated_sub(sk,
1858                                 sk->sk_forward_alloc >> SK_MEM_QUANTUM_SHIFT);
1859         sk->sk_forward_alloc &= SK_MEM_QUANTUM - 1;
1860 
1861         if (sk_under_memory_pressure(sk) &&
1862             (sk_memory_allocated(sk) < sk_prot_mem_limits(sk, 0)))
1863                 sk_leave_memory_pressure(sk);
1864 }
1865 EXPORT_SYMBOL(__sk_mem_reclaim);
1866 
1867 
1868 /*
1869  * Set of default routines for initialising struct proto_ops when
1870  * the protocol does not support a particular function. In certain
1871  * cases where it makes no sense for a protocol to have a "do nothing"
1872  * function, some default processing is provided.
1873  */
1874 
1875 int sock_no_bind(struct socket *sock, struct sockaddr *saddr, int len)
1876 {
1877         return -EOPNOTSUPP;
1878 }
1879 EXPORT_SYMBOL(sock_no_bind);
1880 
1881 int sock_no_connect(struct socket *sock, struct sockaddr *saddr,
1882                     int len, int flags)
1883 {
1884         return -EOPNOTSUPP;
1885 }
1886 EXPORT_SYMBOL(sock_no_connect);
1887 
1888 int sock_no_socketpair(struct socket *sock1, struct socket *sock2)
1889 {
1890         return -EOPNOTSUPP;
1891 }
1892 EXPORT_SYMBOL(sock_no_socketpair);
1893 
1894 int sock_no_accept(struct socket *sock, struct socket *newsock, int flags)
1895 {
1896         return -EOPNOTSUPP;
1897 }
1898 EXPORT_SYMBOL(sock_no_accept);
1899 
1900 int sock_no_getname(struct socket *sock, struct sockaddr *saddr,
1901                     int *len, int peer)
1902 {
1903         return -EOPNOTSUPP;
1904 }
1905 EXPORT_SYMBOL(sock_no_getname);
1906 
1907 unsigned int sock_no_poll(struct file *file, struct socket *sock, poll_table *pt)
1908 {
1909         return 0;
1910 }
1911 EXPORT_SYMBOL(sock_no_poll);
1912 
1913 int sock_no_ioctl(struct socket *sock, unsigned int cmd, unsigned long arg)
1914 {
1915         return -EOPNOTSUPP;
1916 }
1917 EXPORT_SYMBOL(sock_no_ioctl);
1918 
1919 int sock_no_listen(struct socket *sock, int backlog)
1920 {
1921         return -EOPNOTSUPP;
1922 }
1923 EXPORT_SYMBOL(sock_no_listen);
1924 
1925 int sock_no_shutdown(struct socket *sock, int how)
1926 {
1927         return -EOPNOTSUPP;
1928 }
1929 EXPORT_SYMBOL(sock_no_shutdown);
1930 
1931 int sock_no_setsockopt(struct socket *sock, int level, int optname,
1932                     char __user *optval, unsigned int optlen)
1933 {
1934         return -EOPNOTSUPP;
1935 }
1936 EXPORT_SYMBOL(sock_no_setsockopt);
1937 
1938 int sock_no_getsockopt(struct socket *sock, int level, int optname,
1939                     char __user *optval, int __user *optlen)
1940 {
1941         return -EOPNOTSUPP;
1942 }
1943 EXPORT_SYMBOL(sock_no_getsockopt);
1944 
1945 int sock_no_sendmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1946                     size_t len)
1947 {
1948         return -EOPNOTSUPP;
1949 }
1950 EXPORT_SYMBOL(sock_no_sendmsg);
1951 
1952 int sock_no_recvmsg(struct kiocb *iocb, struct socket *sock, struct msghdr *m,
1953                     size_t len, int flags)
1954 {
1955         return -EOPNOTSUPP;
1956 }
1957 EXPORT_SYMBOL(sock_no_recvmsg);
1958 
1959 int sock_no_mmap(struct file *file, struct socket *sock, struct vm_area_struct *vma)
1960 {
1961         /* Mirror missing mmap method error code */
1962         return -ENODEV;
1963 }
1964 EXPORT_SYMBOL(sock_no_mmap);
1965 
1966 ssize_t sock_no_sendpage(struct socket *sock, struct page *page, int offset, size_t size, int flags)
1967 {
1968         ssize_t res;
1969         struct msghdr msg = {.msg_flags = flags};
1970         struct kvec iov;
1971         char *kaddr = kmap(page);
1972         iov.iov_base = kaddr + offset;
1973         iov.iov_len = size;
1974         res = kernel_sendmsg(sock, &msg, &iov, 1, size);
1975         kunmap(page);
1976         return res;
1977 }
1978 EXPORT_SYMBOL(sock_no_sendpage);
1979 
1980 /*
1981  *      Default Socket Callbacks
1982  */
1983 
1984 static void sock_def_wakeup(struct sock *sk)
1985 {
1986         struct socket_wq *wq;
1987 
1988         rcu_read_lock();
1989         wq = rcu_dereference(sk->sk_wq);
1990         if (wq_has_sleeper(wq))
1991                 wake_up_interruptible_all(&wq->wait);
1992         rcu_read_unlock();
1993 }
1994 
1995 static void sock_def_error_report(struct sock *sk)
1996 {
1997         struct socket_wq *wq;
1998 
1999         rcu_read_lock();
2000         wq = rcu_dereference(sk->sk_wq);
2001         if (wq_has_sleeper(wq))
2002                 wake_up_interruptible_poll(&wq->wait, POLLERR);
2003         sk_wake_async(sk, SOCK_WAKE_IO, POLL_ERR);
2004         rcu_read_unlock();
2005 }
2006 
2007 static void sock_def_readable(struct sock *sk, int len)
2008 {
2009         struct socket_wq *wq;
2010 
2011         rcu_read_lock();
2012         wq = rcu_dereference(sk->sk_wq);
2013         if (wq_has_sleeper(wq))
2014                 wake_up_interruptible_sync_poll(&wq->wait, POLLIN | POLLPRI |
2015                                                 POLLRDNORM | POLLRDBAND);
2016         sk_wake_async(sk, SOCK_WAKE_WAITD, POLL_IN);
2017         rcu_read_unlock();
2018 }
2019 
2020 static void sock_def_write_space(struct sock *sk)
2021 {
2022         struct socket_wq *wq;
2023 
2024         rcu_read_lock();
2025 
2026         /* Do not wake up a writer until he can make "significant"
2027          * progress.  --DaveM
2028          */
2029         if ((atomic_read(&sk->sk_wmem_alloc) << 1) <= sk->sk_sndbuf) {
2030                 wq = rcu_dereference(sk->sk_wq);
2031                 if (wq_has_sleeper(wq))
2032                         wake_up_interruptible_sync_poll(&wq->wait, POLLOUT |
2033                                                 POLLWRNORM | POLLWRBAND);
2034 
2035                 /* Should agree with poll, otherwise some programs break */
2036                 if (sock_writeable(sk))
2037                         sk_wake_async(sk, SOCK_WAKE_SPACE, POLL_OUT);
2038         }
2039 
2040         rcu_read_unlock();
2041 }
2042 
2043 static void sock_def_destruct(struct sock *sk)
2044 {
2045         kfree(sk->sk_protinfo);
2046 }
2047 
2048 void sk_send_sigurg(struct sock *sk)
2049 {
2050         if (sk->sk_socket && sk->sk_socket->file)
2051                 if (send_sigurg(&sk->sk_socket->file->f_owner))
2052                         sk_wake_async(sk, SOCK_WAKE_URG, POLL_PRI);
2053 }
2054 EXPORT_SYMBOL(sk_send_sigurg);
2055 
2056 void sk_reset_timer(struct sock *sk, struct timer_list* timer,
2057                     unsigned long expires)
2058 {
2059         if (!mod_timer(timer, expires))
2060                 sock_hold(sk);
2061 }
2062 EXPORT_SYMBOL(sk_reset_timer);
2063 
2064 void sk_stop_timer(struct sock *sk, struct timer_list* timer)
2065 {
2066         if (timer_pending(timer) && del_timer(timer))
2067                 __sock_put(sk);
2068 }
2069 EXPORT_SYMBOL(sk_stop_timer);
2070 
2071 void sock_init_data(struct socket *sock, struct sock *sk)
2072 {
2073         skb_queue_head_init(&sk->sk_receive_queue);
2074         skb_queue_head_init(&sk->sk_write_queue);
2075         skb_queue_head_init(&sk->sk_error_queue);
2076 #ifdef CONFIG_NET_DMA
2077         skb_queue_head_init(&sk->sk_async_wait_queue);
2078 #endif
2079 
2080         sk->sk_send_head        =       NULL;
2081 
2082         init_timer(&sk->sk_timer);
2083 
2084         sk->sk_allocation       =       GFP_KERNEL;
2085         sk->sk_rcvbuf           =       sysctl_rmem_default;
2086         sk->sk_sndbuf           =       sysctl_wmem_default;
2087         sk->sk_state            =       TCP_CLOSE;
2088         sk_set_socket(sk, sock);
2089 
2090         sock_set_flag(sk, SOCK_ZAPPED);
2091 
2092         if (sock) {
2093                 sk->sk_type     =       sock->type;
2094                 sk->sk_wq       =       sock->wq;
2095                 sock->sk        =       sk;
2096         } else
2097                 sk->sk_wq       =       NULL;
2098 
2099         spin_lock_init(&sk->sk_dst_lock);
2100         rwlock_init(&sk->sk_callback_lock);
2101         lockdep_set_class_and_name(&sk->sk_callback_lock,
2102                         af_callback_keys + sk->sk_family,
2103                         af_family_clock_key_strings[sk->sk_family]);
2104 
2105         sk->sk_state_change     =       sock_def_wakeup;
2106         sk->sk_data_ready       =       sock_def_readable;
2107         sk->sk_write_space      =       sock_def_write_space;
2108         sk->sk_error_report     =       sock_def_error_report;
2109         sk->sk_destruct         =       sock_def_destruct;
2110 
2111         sk->sk_sndmsg_page      =       NULL;
2112         sk->sk_sndmsg_off       =       0;
2113         sk->sk_peek_off         =       -1;
2114 
2115         sk->sk_peer_pid         =       NULL;
2116         sk->sk_peer_cred        =       NULL;
2117         sk->sk_write_pending    =       0;
2118         sk->sk_rcvlowat         =       1;
2119         sk->sk_rcvtimeo         =       MAX_SCHEDULE_TIMEOUT;
2120         sk->sk_sndtimeo         =       MAX_SCHEDULE_TIMEOUT;
2121 
2122         sk->sk_stamp = ktime_set(-1L, 0);
2123 
2124         /*
2125          * Before updating sk_refcnt, we must commit prior changes to memory
2126          * (Documentation/RCU/rculist_nulls.txt for details)
2127          */
2128         smp_wmb();
2129         atomic_set(&sk->sk_refcnt, 1);
2130         atomic_set(&sk->sk_drops, 0);
2131 }
2132 EXPORT_SYMBOL(sock_init_data);
2133 
2134 void lock_sock_nested(struct sock *sk, int subclass)
2135 {
2136         might_sleep();
2137         spin_lock_bh(&sk->sk_lock.slock);
2138         if (sk->sk_lock.owned)
2139                 __lock_sock(sk);
2140         sk->sk_lock.owned = 1;
2141         spin_unlock(&sk->sk_lock.slock);
2142         /*
2143          * The sk_lock has mutex_lock() semantics here:
2144          */
2145         mutex_acquire(&sk->sk_lock.dep_map, subclass, 0, _RET_IP_);
2146         local_bh_enable();
2147 }
2148 EXPORT_SYMBOL(lock_sock_nested);
2149 
2150 void release_sock(struct sock *sk)
2151 {
2152         /*
2153          * The sk_lock has mutex_unlock() semantics:
2154          */
2155         mutex_release(&sk->sk_lock.dep_map, 1, _RET_IP_);
2156 
2157         spin_lock_bh(&sk->sk_lock.slock);
2158         if (sk->sk_backlog.tail)
2159                 __release_sock(sk);
2160         sk->sk_lock.owned = 0;
2161         if (waitqueue_active(&sk->sk_lock.wq))
2162                 wake_up(&sk->sk_lock.wq);
2163         spin_unlock_bh(&sk->sk_lock.slock);
2164 }
2165 EXPORT_SYMBOL(release_sock);
2166 
2167 /**
2168  * lock_sock_fast - fast version of lock_sock
2169  * @sk: socket
2170  *
2171  * This version should be used for very small section, where process wont block
2172  * return false if fast path is taken
2173  *   sk_lock.slock locked, owned = 0, BH disabled
2174  * return true if slow path is taken
2175  *   sk_lock.slock unlocked, owned = 1, BH enabled
2176  */
2177 bool lock_sock_fast(struct sock *sk)
2178 {
2179         might_sleep();
2180         spin_lock_bh(&sk->sk_lock.slock);
2181 
2182         if (!sk->sk_lock.owned)
2183                 /*
2184                  * Note : We must disable BH
2185                  */
2186                 return false;
2187 
2188         __lock_sock(sk);
2189         sk->sk_lock.owned = 1;
2190         spin_unlock(&sk->sk_lock.slock);
2191         /*
2192          * The sk_lock has mutex_lock() semantics here:
2193          */
2194         mutex_acquire(&sk->sk_lock.dep_map, 0, 0, _RET_IP_);
2195         local_bh_enable();
2196         return true;
2197 }
2198 EXPORT_SYMBOL(lock_sock_fast);
2199 
2200 int sock_get_timestamp(struct sock *sk, struct timeval __user *userstamp)
2201 {
2202         struct timeval tv;
2203         if (!sock_flag(sk, SOCK_TIMESTAMP))
2204                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2205         tv = ktime_to_timeval(sk->sk_stamp);
2206         if (tv.tv_sec == -1)
2207                 return -ENOENT;
2208         if (tv.tv_sec == 0) {
2209                 sk->sk_stamp = ktime_get_real();
2210                 tv = ktime_to_timeval(sk->sk_stamp);
2211         }
2212         return copy_to_user(userstamp, &tv, sizeof(tv)) ? -EFAULT : 0;
2213 }
2214 EXPORT_SYMBOL(sock_get_timestamp);
2215 
2216 int sock_get_timestampns(struct sock *sk, struct timespec __user *userstamp)
2217 {
2218         struct timespec ts;
2219         if (!sock_flag(sk, SOCK_TIMESTAMP))
2220                 sock_enable_timestamp(sk, SOCK_TIMESTAMP);
2221         ts = ktime_to_timespec(sk->sk_stamp);
2222         if (ts.tv_sec == -1)
2223                 return -ENOENT;
2224         if (ts.tv_sec == 0) {
2225                 sk->sk_stamp = ktime_get_real();
2226                 ts = ktime_to_timespec(sk->sk_stamp);
2227         }
2228         return copy_to_user(userstamp, &ts, sizeof(ts)) ? -EFAULT : 0;
2229 }
2230 EXPORT_SYMBOL(sock_get_timestampns);
2231 
2232 void sock_enable_timestamp(struct sock *sk, int flag)
2233 {
2234         if (!sock_flag(sk, flag)) {
2235                 unsigned long previous_flags = sk->sk_flags;
2236 
2237                 sock_set_flag(sk, flag);
2238                 /*
2239                  * we just set one of the two flags which require net
2240                  * time stamping, but time stamping might have been on
2241                  * already because of the other one
2242                  */
2243                 if (!(previous_flags & SK_FLAGS_TIMESTAMP))
2244                         net_enable_timestamp();
2245         }
2246 }
2247 
2248 /*
2249  *      Get a socket option on an socket.
2250  *
2251  *      FIX: POSIX 1003.1g is very ambiguous here. It states that
2252  *      asynchronous errors should be reported by getsockopt. We assume
2253  *      this means if you specify SO_ERROR (otherwise whats the point of it).
2254  */
2255 int sock_common_getsockopt(struct socket *sock, int level, int optname,
2256                            char __user *optval, int __user *optlen)
2257 {
2258         struct sock *sk = sock->sk;
2259 
2260         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2261 }
2262 EXPORT_SYMBOL(sock_common_getsockopt);
2263 
2264 #ifdef CONFIG_COMPAT
2265 int compat_sock_common_getsockopt(struct socket *sock, int level, int optname,
2266                                   char __user *optval, int __user *optlen)
2267 {
2268         struct sock *sk = sock->sk;
2269 
2270         if (sk->sk_prot->compat_getsockopt != NULL)
2271                 return sk->sk_prot->compat_getsockopt(sk, level, optname,
2272                                                       optval, optlen);
2273         return sk->sk_prot->getsockopt(sk, level, optname, optval, optlen);
2274 }
2275 EXPORT_SYMBOL(compat_sock_common_getsockopt);
2276 #endif
2277 
2278 int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
2279                         struct msghdr *msg, size_t size, int flags)
2280 {
2281         struct sock *sk = sock->sk;
2282         int addr_len = 0;
2283         int err;
2284 
2285         err = sk->sk_prot->recvmsg(iocb, sk, msg, size, flags & MSG_DONTWAIT,
2286                                    flags & ~MSG_DONTWAIT, &addr_len);
2287         if (err >= 0)
2288                 msg->msg_namelen = addr_len;
2289         return err;
2290 }
2291 EXPORT_SYMBOL(sock_common_recvmsg);
2292 
2293 /*
2294  *      Set socket options on an inet socket.
2295  */
2296 int sock_common_setsockopt(struct socket *sock, int level, int optname,
2297                            char __user *optval, unsigned int optlen)
2298 {
2299         struct sock *sk = sock->sk;
2300 
2301         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2302 }
2303 EXPORT_SYMBOL(sock_common_setsockopt);
2304 
2305 #ifdef CONFIG_COMPAT
2306 int compat_sock_common_setsockopt(struct socket *sock, int level, int optname,
2307                                   char __user *optval, unsigned int optlen)
2308 {
2309         struct sock *sk = sock->sk;
2310 
2311         if (sk->sk_prot->compat_setsockopt != NULL)
2312                 return sk->sk_prot->compat_setsockopt(sk, level, optname,
2313                                                       optval, optlen);
2314         return sk->sk_prot->setsockopt(sk, level, optname, optval, optlen);
2315 }
2316 EXPORT_SYMBOL(compat_sock_common_setsockopt);
2317 #endif
2318 
2319 void sk_common_release(struct sock *sk)
2320 {
2321         if (sk->sk_prot->destroy)
2322                 sk->sk_prot->destroy(sk);
2323 
2324         /*
2325          * Observation: when sock_common_release is called, processes have
2326          * no access to socket. But net still has.
2327          * Step one, detach it from networking:
2328          *
2329          * A. Remove from hash tables.
2330          */
2331 
2332         sk->sk_prot->unhash(sk);
2333 
2334         /*
2335          * In this point socket cannot receive new packets, but it is possible
2336          * that some packets are in flight because some CPU runs receiver and
2337          * did hash table lookup before we unhashed socket. They will achieve
2338          * receive queue and will be purged by socket destructor.
2339          *
2340          * Also we still have packets pending on receive queue and probably,
2341          * our own packets waiting in device queues. sock_destroy will drain
2342          * receive queue, but transmitted packets will delay socket destruction
2343          * until the last reference will be released.
2344          */
2345 
2346         sock_orphan(sk);
2347 
2348         xfrm_sk_free_policy(sk);
2349 
2350         sk_refcnt_debug_release(sk);
2351         sock_put(sk);
2352 }
2353 EXPORT_SYMBOL(sk_common_release);
2354 
2355 #ifdef CONFIG_PROC_FS
2356 #define PROTO_INUSE_NR  64      /* should be enough for the first time */
2357 struct prot_inuse {
2358         int val[PROTO_INUSE_NR];
2359 };
2360 
2361 static DECLARE_BITMAP(proto_inuse_idx, PROTO_INUSE_NR);
2362 
2363 #ifdef CONFIG_NET_NS
2364 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2365 {
2366         __this_cpu_add(net->core.inuse->val[prot->inuse_idx], val);
2367 }
2368 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2369 
2370 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2371 {
2372         int cpu, idx = prot->inuse_idx;
2373         int res = 0;
2374 
2375         for_each_possible_cpu(cpu)
2376                 res += per_cpu_ptr(net->core.inuse, cpu)->val[idx];
2377 
2378         return res >= 0 ? res : 0;
2379 }
2380 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2381 
2382 static int __net_init sock_inuse_init_net(struct net *net)
2383 {
2384         net->core.inuse = alloc_percpu(struct prot_inuse);
2385         return net->core.inuse ? 0 : -ENOMEM;
2386 }
2387 
2388 static void __net_exit sock_inuse_exit_net(struct net *net)
2389 {
2390         free_percpu(net->core.inuse);
2391 }
2392 
2393 static struct pernet_operations net_inuse_ops = {
2394         .init = sock_inuse_init_net,
2395         .exit = sock_inuse_exit_net,
2396 };
2397 
2398 static __init int net_inuse_init(void)
2399 {
2400         if (register_pernet_subsys(&net_inuse_ops))
2401                 panic("Cannot initialize net inuse counters");
2402 
2403         return 0;
2404 }
2405 
2406 core_initcall(net_inuse_init);
2407 #else
2408 static DEFINE_PER_CPU(struct prot_inuse, prot_inuse);
2409 
2410 void sock_prot_inuse_add(struct net *net, struct proto *prot, int val)
2411 {
2412         __this_cpu_add(prot_inuse.val[prot->inuse_idx], val);
2413 }
2414 EXPORT_SYMBOL_GPL(sock_prot_inuse_add);
2415 
2416 int sock_prot_inuse_get(struct net *net, struct proto *prot)
2417 {
2418         int cpu, idx = prot->inuse_idx;
2419         int res = 0;
2420 
2421         for_each_possible_cpu(cpu)
2422                 res += per_cpu(prot_inuse, cpu).val[idx];
2423 
2424         return res >= 0 ? res : 0;
2425 }
2426 EXPORT_SYMBOL_GPL(sock_prot_inuse_get);
2427 #endif
2428 
2429 static void assign_proto_idx(struct proto *prot)
2430 {
2431         prot->inuse_idx = find_first_zero_bit(proto_inuse_idx, PROTO_INUSE_NR);
2432 
2433         if (unlikely(prot->inuse_idx == PROTO_INUSE_NR - 1)) {
2434                 printk(KERN_ERR "PROTO_INUSE_NR exhausted\n");
2435                 return;
2436         }
2437 
2438         set_bit(prot->inuse_idx, proto_inuse_idx);
2439 }
2440 
2441 static void release_proto_idx(struct proto *prot)
2442 {
2443         if (prot->inuse_idx != PROTO_INUSE_NR - 1)
2444                 clear_bit(prot->inuse_idx, proto_inuse_idx);
2445 }
2446 #else
2447 static inline void assign_proto_idx(struct proto *prot)
2448 {
2449 }
2450 
2451 static inline void release_proto_idx(struct proto *prot)
2452 {
2453 }
2454 #endif
2455 
2456 int proto_register(struct proto *prot, int alloc_slab)
2457 {
2458         if (alloc_slab) {
2459                 prot->slab = kmem_cache_create(prot->name, prot->obj_size, 0,
2460                                         SLAB_HWCACHE_ALIGN | prot->slab_flags,
2461                                         NULL);
2462 
2463                 if (prot->slab == NULL) {
2464                         printk(KERN_CRIT "%s: Can't create sock SLAB cache!\n",
2465                                prot->name);
2466                         goto out;
2467                 }
2468 
2469                 if (prot->rsk_prot != NULL) {
2470                         prot->rsk_prot->slab_name = kasprintf(GFP_KERNEL, "request_sock_%s", prot->name);
2471                         if (prot->rsk_prot->slab_name == NULL)
2472                                 goto out_free_sock_slab;
2473 
2474                         prot->rsk_prot->slab = kmem_cache_create(prot->rsk_prot->slab_name,
2475                                                                  prot->rsk_prot->obj_size, 0,
2476                                                                  SLAB_HWCACHE_ALIGN, NULL);
2477 
2478                         if (prot->rsk_prot->slab == NULL) {
2479                                 printk(KERN_CRIT "%s: Can't create request sock SLAB cache!\n",
2480                                        prot->name);
2481                                 goto out_free_request_sock_slab_name;
2482                         }
2483                 }
2484 
2485                 if (prot->twsk_prot != NULL) {
2486                         prot->twsk_prot->twsk_slab_name = kasprintf(GFP_KERNEL, "tw_sock_%s", prot->name);
2487 
2488                         if (prot->twsk_prot->twsk_slab_name == NULL)
2489                                 goto out_free_request_sock_slab;
2490 
2491                         prot->twsk_prot->twsk_slab =
2492                                 kmem_cache_create(prot->twsk_prot->twsk_slab_name,
2493                                                   prot->twsk_prot->twsk_obj_size,
2494                                                   0,
2495                                                   SLAB_HWCACHE_ALIGN |
2496                                                         prot->slab_flags,
2497                                                   NULL);
2498                         if (prot->twsk_prot->twsk_slab == NULL)
2499                                 goto out_free_timewait_sock_slab_name;
2500                 }
2501         }
2502 
2503         mutex_lock(&proto_list_mutex);
2504         list_add(&prot->node, &proto_list);
2505         assign_proto_idx(prot);
2506         mutex_unlock(&proto_list_mutex);
2507         return 0;
2508 
2509 out_free_timewait_sock_slab_name:
2510         kfree(prot->twsk_prot->twsk_slab_name);
2511 out_free_request_sock_slab:
2512         if (prot->rsk_prot && prot->rsk_prot->slab) {
2513                 kmem_cache_destroy(prot->rsk_prot->slab);
2514                 prot->rsk_prot->slab = NULL;
2515         }
2516 out_free_request_sock_slab_name:
2517         if (prot->rsk_prot)
2518                 kfree(prot->rsk_prot->slab_name);
2519 out_free_sock_slab:
2520         kmem_cache_destroy(prot->slab);
2521         prot->slab = NULL;
2522 out:
2523         return -ENOBUFS;
2524 }
2525 EXPORT_SYMBOL(proto_register);
2526 
2527 void proto_unregister(struct proto *prot)
2528 {
2529         mutex_lock(&proto_list_mutex);
2530         release_proto_idx(prot);
2531         list_del(&prot->node);
2532         mutex_unlock(&proto_list_mutex);
2533 
2534         if (prot->slab != NULL) {
2535                 kmem_cache_destroy(prot->slab);
2536                 prot->slab = NULL;
2537         }
2538 
2539         if (prot->rsk_prot != NULL && prot->rsk_prot->slab != NULL) {
2540                 kmem_cache_destroy(prot->rsk_prot->slab);
2541                 kfree(prot->rsk_prot->slab_name);
2542                 prot->rsk_prot->slab = NULL;
2543         }
2544 
2545         if (prot->twsk_prot != NULL && prot->twsk_prot->twsk_slab != NULL) {
2546                 kmem_cache_destroy(prot->twsk_prot->twsk_slab);
2547                 kfree(prot->twsk_prot->twsk_slab_name);
2548                 prot->twsk_prot->twsk_slab = NULL;
2549         }
2550 }
2551 EXPORT_SYMBOL(proto_unregister);
2552 
2553 #ifdef CONFIG_PROC_FS
2554 static void *proto_seq_start(struct seq_file *seq, loff_t *pos)
2555         __acquires(proto_list_mutex)
2556 {
2557         mutex_lock(&proto_list_mutex);
2558         return seq_list_start_head(&proto_list, *pos);
2559 }
2560 
2561 static void *proto_seq_next(struct seq_file *seq, void *v, loff_t *pos)
2562 {
2563         return seq_list_next(v, &proto_list, pos);
2564 }
2565 
2566 static void proto_seq_stop(struct seq_file *seq, void *v)
2567         __releases(proto_list_mutex)
2568 {
2569         mutex_unlock(&proto_list_mutex);
2570 }
2571 
2572 static char proto_method_implemented(const void *method)
2573 {
2574         return method == NULL ? 'n' : 'y';
2575 }
2576 static long sock_prot_memory_allocated(struct proto *proto)
2577 {
2578         return proto->memory_allocated != NULL ? proto_memory_allocated(proto): -1L;
2579 }
2580 
2581 static char *sock_prot_memory_pressure(struct proto *proto)
2582 {
2583         return proto->memory_pressure != NULL ?
2584         proto_memory_pressure(proto) ? "yes" : "no" : "NI";
2585 }
2586 
2587 static void proto_seq_printf(struct seq_file *seq, struct proto *proto)
2588 {
2589 
2590         seq_printf(seq, "%-9s %4u %6d  %6ld   %-3s %6u   %-3s  %-10s "
2591                         "%2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c %2c\n",
2592                    proto->name,
2593                    proto->obj_size,
2594                    sock_prot_inuse_get(seq_file_net(seq), proto),
2595                    sock_prot_memory_allocated(proto),
2596                    sock_prot_memory_pressure(proto),
2597                    proto->max_header,
2598                    proto->slab == NULL ? "no" : "yes",
2599                    module_name(proto->owner),
2600                    proto_method_implemented(proto->close),
2601                    proto_method_implemented(proto->connect),
2602                    proto_method_implemented(proto->disconnect),
2603                    proto_method_implemented(proto->accept),
2604                    proto_method_implemented(proto->ioctl),
2605                    proto_method_implemented(proto->init),
2606                    proto_method_implemented(proto->destroy),
2607                    proto_method_implemented(proto->shutdown),
2608                    proto_method_implemented(proto->setsockopt),
2609                    proto_method_implemented(proto->getsockopt),
2610                    proto_method_implemented(proto->sendmsg),
2611                    proto_method_implemented(proto->recvmsg),
2612                    proto_method_implemented(proto->sendpage),
2613                    proto_method_implemented(proto->bind),
2614                    proto_method_implemented(proto->backlog_rcv),
2615                    proto_method_implemented(proto->hash),
2616                    proto_method_implemented(proto->unhash),
2617                    proto_method_implemented(proto->get_port),
2618                    proto_method_implemented(proto->enter_memory_pressure));
2619 }
2620 
2621 static int proto_seq_show(struct seq_file *seq, void *v)
2622 {
2623         if (v == &proto_list)
2624                 seq_printf(seq, "%-9s %-4s %-8s %-6s %-5s %-7s %-4s %-10s %s",
2625                            "protocol",
2626                            "size",
2627                            "sockets",
2628                            "memory",
2629                            "press",
2630                            "maxhdr",
2631                            "slab",
2632                            "module",
2633                            "cl co di ac io in de sh ss gs se re sp bi br ha uh gp em\n");
2634         else
2635                 proto_seq_printf(seq, list_entry(v, struct proto, node));
2636         return 0;
2637 }
2638 
2639 static const struct seq_operations proto_seq_ops = {
2640         .start  = proto_seq_start,
2641         .next   = proto_seq_next,
2642         .stop   = proto_seq_stop,
2643         .show   = proto_seq_show,
2644 };
2645 
2646 static int proto_seq_open(struct inode *inode, struct file *file)
2647 {
2648         return seq_open_net(inode, file, &proto_seq_ops,
2649                             sizeof(struct seq_net_private));
2650 }
2651 
2652 static const struct file_operations proto_seq_fops = {
2653         .owner          = THIS_MODULE,
2654         .open           = proto_seq_open,
2655         .read           = seq_read,
2656         .llseek         = seq_lseek,
2657         .release        = seq_release_net,
2658 };
2659 
2660 static __net_init int proto_init_net(struct net *net)
2661 {
2662         if (!proc_net_fops_create(net, "protocols", S_IRUGO, &proto_seq_fops))
2663                 return -ENOMEM;
2664 
2665         return 0;
2666 }
2667 
2668 static __net_exit void proto_exit_net(struct net *net)
2669 {
2670         proc_net_remove(net, "protocols");
2671 }
2672 
2673 
2674 static __net_initdata struct pernet_operations proto_net_ops = {
2675         .init = proto_init_net,
2676         .exit = proto_exit_net,
2677 };
2678 
2679 static int __init proto_init(void)
2680 {
2681         return register_pernet_subsys(&proto_net_ops);
2682 }
2683 
2684 subsys_initcall(proto_init);
2685 
2686 #endif /* PROC_FS */
2687 

~ [ source navigation ] ~ [ diff markup ] ~ [ identifier search ] ~

kernel.org | git.kernel.org | LWN.net | Project Home | Wiki (Japanese) | Wiki (English) | SVN repository | Mail admin

Linux® is a registered trademark of Linus Torvalds in the United States and other countries.
TOMOYO® is a registered trademark of NTT DATA CORPORATION.

osdn.jp