LCOV - code coverage report
Current view: top level - include/net - sock.h (source / functions) Hit Total Coverage
Test: coverage.info Lines: 16 93 17.2 %
Date: 2017-01-25 Functions: 3 32 9.4 %

          Line data    Source code
       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             :  *              Definitions for the AF_INET socket handler.
       7             :  *
       8             :  * Version:     @(#)sock.h      1.0.4   05/13/93
       9             :  *
      10             :  * Authors:     Ross Biro
      11             :  *              Fred N. van Kempen, <waltje@uWalt.NL.Mugnet.ORG>
      12             :  *              Corey Minyard <wf-rch!minyard@relay.EU.net>
      13             :  *              Florian La Roche <flla@stud.uni-sb.de>
      14             :  *
      15             :  * Fixes:
      16             :  *              Alan Cox        :       Volatiles in skbuff pointers. See
      17             :  *                                      skbuff comments. May be overdone,
      18             :  *                                      better to prove they can be removed
      19             :  *                                      than the reverse.
      20             :  *              Alan Cox        :       Added a zapped field for tcp to note
      21             :  *                                      a socket is reset and must stay shut up
      22             :  *              Alan Cox        :       New fields for options
      23             :  *      Pauline Middelink       :       identd support
      24             :  *              Alan Cox        :       Eliminate low level recv/recvfrom
      25             :  *              David S. Miller :       New socket lookup architecture.
      26             :  *              Steve Whitehouse:       Default routines for sock_ops
      27             :  *              Arnaldo C. Melo :       removed net_pinfo, tp_pinfo and made
      28             :  *                                      protinfo be just a void pointer, as the
      29             :  *                                      protocol specific parts were moved to
      30             :  *                                      respective headers and ipv4/v6, etc now
      31             :  *                                      use private slabcaches for its socks
      32             :  *              Pedro Hortas    :       New flags field for socket options
      33             :  *
      34             :  *
      35             :  *              This program is free software; you can redistribute it and/or
      36             :  *              modify it under the terms of the GNU General Public License
      37             :  *              as published by the Free Software Foundation; either version
      38             :  *              2 of the License, or (at your option) any later version.
      39             :  */
      40             : #ifndef _SOCK_H
      41             : #define _SOCK_H
      42             : 
      43             : #include <linux/kernel.h>
      44             : #include <linux/list.h>
      45             : #include <linux/list_nulls.h>
      46             : #include <linux/timer.h>
      47             : #include <linux/cache.h>
      48             : #include <linux/module.h>
      49             : #include <linux/lockdep.h>
      50             : #include <linux/netdevice.h>
      51             : #include <linux/skbuff.h> /* struct sk_buff */
      52             : #include <linux/mm.h>
      53             : #include <linux/security.h>
      54             : 
      55             : #include <linux/filter.h>
      56             : #include <linux/rculist_nulls.h>
      57             : #include <linux/poll.h>
      58             : 
      59             : #include <asm/atomic.h>
      60             : #include <net/dst.h>
      61             : #include <net/checksum.h>
      62             : 
      63             : /*
      64             :  * This structure really needs to be cleaned up.
      65             :  * Most of it is for TCP, and not used by any of
      66             :  * the other protocols.
      67             :  */
      68             : 
      69             : /* Define this to get the SOCK_DBG debugging facility. */
      70             : #define SOCK_DEBUGGING
      71             : #ifdef SOCK_DEBUGGING
      72             : #define SOCK_DEBUG(sk, msg...) do { if ((sk) && sock_flag((sk), SOCK_DBG)) \
      73             :                                         printk(KERN_DEBUG msg); } while (0)
      74             : #else
      75             : /* Validate arguments and do nothing */
      76             : static void inline int __attribute__ ((format (printf, 2, 3)))
      77             : SOCK_DEBUG(struct sock *sk, const char *msg, ...)
      78             : {
      79             : }
      80             : #endif
      81             : 
      82             : /* This is the per-socket lock.  The spinlock provides a synchronization
      83             :  * between user contexts and software interrupt processing, whereas the
      84             :  * mini-semaphore synchronizes multiple users amongst themselves.
      85             :  */
      86             : typedef struct {
      87             :         spinlock_t              slock;
      88             :         int                     owned;
      89             :         wait_queue_head_t       wq;
      90             :         /*
      91           1 :          * We express the mutex-alike socket_lock semantics
      92           4 :          * to the lock validator by explicitly managing
      93             :          * the slock as a lock variant (in addition to
      94             :          * the slock itself):
      95             :          */
      96             : #ifdef CONFIG_DEBUG_LOCK_ALLOC
      97             :         struct lockdep_map dep_map;
      98             : #endif
      99           2 : } socket_lock_t;
     100             : 
     101             : struct sock;
     102             : struct proto;
     103             : struct net;
     104             : 
     105             : /**
     106             :  *      struct sock_common - minimal network layer representation of sockets
     107             :  *      @skc_node: main hash linkage for various protocol lookup tables
     108             :  *      @skc_nulls_node: main hash linkage for TCP/UDP/UDP-Lite protocol
     109             :  *      @skc_refcnt: reference count
     110             :  *      @skc_tx_queue_mapping: tx queue number for this connection
     111             :  *      @skc_hash: hash value used with various protocol lookup tables
     112             :  *      @skc_u16hashes: two u16 hash values used by UDP lookup tables
     113             :  *      @skc_family: network address family
     114             :  *      @skc_state: Connection state
     115             :  *      @skc_reuse: %SO_REUSEADDR setting
     116             :  *      @skc_bound_dev_if: bound device index if != 0
     117             :  *      @skc_bind_node: bind hash linkage for various protocol lookup tables
     118             :  *      @skc_portaddr_node: second hash linkage for UDP/UDP-Lite protocol
     119             :  *      @skc_prot: protocol handlers inside a network family
     120             :  *      @skc_net: reference to the network namespace of this socket
     121             :  *
     122             :  *      This is the minimal network layer representation of sockets, the header
     123             :  *      for struct sock and struct inet_timewait_sock.
     124             :  */
     125             : struct sock_common {
     126             :         /*
     127             :          * first fields are not copied in sock_copy()
     128             :          */
     129             :         union {
     130             :                 struct hlist_node       skc_node;
     131             :                 struct hlist_nulls_node skc_nulls_node;
     132             :         };
     133             :         atomic_t                skc_refcnt;
     134             :         int                     skc_tx_queue_mapping;
     135             : 
     136             :         union  {
     137             :                 unsigned int    skc_hash;
     138             :                 __u16           skc_u16hashes[2];
     139             :         };
     140             :         unsigned short          skc_family;
     141             :         volatile unsigned char  skc_state;
     142             :         unsigned char           skc_reuse;
     143             :         int                     skc_bound_dev_if;
     144             :         union {
     145             :                 struct hlist_node       skc_bind_node;
     146             :                 struct hlist_nulls_node skc_portaddr_node;
     147             :         };
     148             :         struct proto            *skc_prot;
     149             : #ifdef CONFIG_NET_NS
     150           2 :         struct net              *skc_net;
     151             : #endif
     152             : };
     153             : 
     154             : /**
     155             :   *     struct sock - network layer representation of sockets
     156             :   *     @__sk_common: shared layout with inet_timewait_sock
     157             :   *     @sk_shutdown: mask of %SEND_SHUTDOWN and/or %RCV_SHUTDOWN
     158             :   *     @sk_userlocks: %SO_SNDBUF and %SO_RCVBUF settings
     159             :   *     @sk_lock:       synchronizer
     160             :   *     @sk_rcvbuf: size of receive buffer in bytes
     161             :   *     @sk_sleep: sock wait queue
     162             :   *     @sk_dst_cache: destination cache
     163             :   *     @sk_dst_lock: destination cache lock
     164             :   *     @sk_policy: flow policy
     165             :   *     @sk_rmem_alloc: receive queue bytes committed
     166             :   *     @sk_receive_queue: incoming packets
     167             :   *     @sk_wmem_alloc: transmit queue bytes committed
     168             :   *     @sk_write_queue: Packet sending queue
     169             :   *     @sk_async_wait_queue: DMA copied packets
     170             :   *     @sk_omem_alloc: "o" is "option" or "other"
     171             :   *     @sk_wmem_queued: persistent queue size
     172             :   *     @sk_forward_alloc: space allocated forward
     173             :   *     @sk_allocation: allocation mode
     174             :   *     @sk_sndbuf: size of send buffer in bytes
     175             :   *     @sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
     176             :   *                %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
     177             :   *     @sk_no_check: %SO_NO_CHECK setting, wether or not checkup packets
     178             :   *     @sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
     179             :   *     @sk_gso_type: GSO type (e.g. %SKB_GSO_TCPV4)
     180             :   *     @sk_gso_max_size: Maximum GSO segment size to build
     181             :   *     @sk_lingertime: %SO_LINGER l_linger setting
     182             :   *     @sk_backlog: always used with the per-socket spinlock held
     183             :   *     @sk_callback_lock: used with the callbacks in the end of this struct
     184             :   *     @sk_error_queue: rarely used
     185             :   *     @sk_prot_creator: sk_prot of original sock creator (see ipv6_setsockopt,
     186             :   *                       IPV6_ADDRFORM for instance)
     187             :   *     @sk_err: last error
     188             :   *     @sk_err_soft: errors that don't cause failure but are the cause of a
     189             :   *                   persistent failure not just 'timed out'
     190             :   *     @sk_drops: raw/udp drops counter
     191             :   *     @sk_ack_backlog: current listen backlog
     192             :   *     @sk_max_ack_backlog: listen backlog set in listen()
     193             :   *     @sk_priority: %SO_PRIORITY setting
     194             :   *     @sk_type: socket type (%SOCK_STREAM, etc)
     195             :   *     @sk_protocol: which protocol this socket belongs in this network family
     196             :   *     @sk_peercred: %SO_PEERCRED setting
     197             :   *     @sk_rcvlowat: %SO_RCVLOWAT setting
     198             :   *     @sk_rcvtimeo: %SO_RCVTIMEO setting
     199             :   *     @sk_sndtimeo: %SO_SNDTIMEO setting
     200             :   *     @sk_filter: socket filtering instructions
     201             :   *     @sk_protinfo: private area, net family specific, when not using slab
     202             :   *     @sk_timer: sock cleanup timer
     203             :   *     @sk_stamp: time stamp of last packet received
     204             :   *     @sk_socket: Identd and reporting IO signals
     205             :   *     @sk_user_data: RPC layer private data
     206             :   *     @sk_sndmsg_page: cached page for sendmsg
     207             :   *     @sk_sndmsg_off: cached offset for sendmsg
     208             :   *     @sk_send_head: front of stuff to transmit
     209             :   *     @sk_security: used by security modules
     210             :   *     @sk_mark: generic packet mark
     211             :   *     @sk_write_pending: a write to stream socket waits to start
     212             :   *     @sk_state_change: callback to indicate change in the state of the sock
     213             :   *     @sk_data_ready: callback to indicate there is data to be processed
     214             :   *     @sk_write_space: callback to indicate there is bf sending space available
     215             :   *     @sk_error_report: callback to indicate errors (e.g. %MSG_ERRQUEUE)
     216             :   *     @sk_backlog_rcv: callback to process the backlog
     217             :   *     @sk_destruct: called at sock freeing time, i.e. when all refcnt == 0
     218             :  */
     219             : struct sock {
     220             :         /*
     221             :          * Now struct inet_timewait_sock also uses sock_common, so please just
     222             :          * don't add nothing before this first member (__sk_common) --acme
     223             :          */
     224             :         struct sock_common      __sk_common;
     225             : #define sk_node                 __sk_common.skc_node
     226             : #define sk_nulls_node           __sk_common.skc_nulls_node
     227             : #define sk_refcnt               __sk_common.skc_refcnt
     228             : #define sk_tx_queue_mapping     __sk_common.skc_tx_queue_mapping
     229             : 
     230             : #define sk_copy_start           __sk_common.skc_hash
     231             : #define sk_hash                 __sk_common.skc_hash
     232             : #define sk_family               __sk_common.skc_family
     233             : #define sk_state                __sk_common.skc_state
     234             : #define sk_reuse                __sk_common.skc_reuse
     235             : #define sk_bound_dev_if         __sk_common.skc_bound_dev_if
     236             : #define sk_bind_node            __sk_common.skc_bind_node
     237             : #define sk_prot                 __sk_common.skc_prot
     238             : #define sk_net                  __sk_common.skc_net
     239             :         kmemcheck_bitfield_begin(flags);
     240             :         unsigned int            sk_shutdown  : 2,
     241             :                                 sk_no_check  : 2,
     242             :                                 sk_userlocks : 4,
     243             :                                 sk_protocol  : 8,
     244             :                                 sk_type      : 16;
     245             :         kmemcheck_bitfield_end(flags);
     246             :         int                     sk_rcvbuf;
     247             :         socket_lock_t           sk_lock;
     248             :         /*
     249             :          * The backlog queue is special, it is always used with
     250             :          * the per-socket spinlock held and requires low latency
     251             :          * access. Therefore we special case it's implementation.
     252             :          */
     253             :         struct {
     254             :                 struct sk_buff *head;
     255             :                 struct sk_buff *tail;
     256             :                 int len;
     257             :                 int limit;
     258             :         } sk_backlog;
     259             :         wait_queue_head_t       *sk_sleep;
     260             :         struct dst_entry        *sk_dst_cache;
     261             : #ifdef CONFIG_XFRM
     262             :         struct xfrm_policy      *sk_policy[2];
     263             : #endif
     264             :         rwlock_t                sk_dst_lock;
     265             :         atomic_t                sk_rmem_alloc;
     266             :         atomic_t                sk_wmem_alloc;
     267             :         atomic_t                sk_omem_alloc;
     268             :         int                     sk_sndbuf;
     269             :         struct sk_buff_head     sk_receive_queue;
     270             :         struct sk_buff_head     sk_write_queue;
     271             : #ifdef CONFIG_NET_DMA
     272             :         struct sk_buff_head     sk_async_wait_queue;
     273             : #endif
     274             :         int                     sk_wmem_queued;
     275             :         int                     sk_forward_alloc;
     276             :         gfp_t                   sk_allocation;
     277             :         int                     sk_route_caps;
     278             :         int                     sk_gso_type;
     279             :         unsigned int            sk_gso_max_size;
     280             :         int                     sk_rcvlowat;
     281             :         unsigned long           sk_flags;
     282             :         unsigned long           sk_lingertime;
     283             :         struct sk_buff_head     sk_error_queue;
     284             :         struct proto            *sk_prot_creator;
     285             :         rwlock_t                sk_callback_lock;
     286             :         int                     sk_err,
     287             :                                 sk_err_soft;
     288             :         atomic_t                sk_drops;
     289             :         unsigned short          sk_ack_backlog;
     290             :         unsigned short          sk_max_ack_backlog;
     291             :         __u32                   sk_priority;
     292             :         struct ucred            sk_peercred;
     293             :         long                    sk_rcvtimeo;
     294             :         long                    sk_sndtimeo;
     295             :         struct sk_filter        *sk_filter;
     296             :         void                    *sk_protinfo;
     297             :         struct timer_list       sk_timer;
     298             :         ktime_t                 sk_stamp;
     299             :         struct socket           *sk_socket;
     300             :         void                    *sk_user_data;
     301             :         struct page             *sk_sndmsg_page;
     302             :         struct sk_buff          *sk_send_head;
     303             :         __u32                   sk_sndmsg_off;
     304             :         int                     sk_write_pending;
     305             : #ifdef CONFIG_SECURITY
     306             :         void                    *sk_security;
     307             : #endif
     308             :         __u32                   sk_mark;
     309             :         /* XXX 4 bytes hole on 64 bit */
     310             :         void                    (*sk_state_change)(struct sock *sk);
     311             :         void                    (*sk_data_ready)(struct sock *sk, int bytes);
     312             :         void                    (*sk_write_space)(struct sock *sk);
     313             :         void                    (*sk_error_report)(struct sock *sk);
     314             :         int                     (*sk_backlog_rcv)(struct sock *sk,
     315             :                                                   struct sk_buff *skb);  
     316             :         void                    (*sk_destruct)(struct sock *sk);
     317             : };
     318             : 
     319             : /*
     320             :  * Hashed lists helper routines
     321             :  */
     322             : static inline struct sock *__sk_head(const struct hlist_head *head)
     323             : {
     324          20 :         return hlist_entry(head->first, struct sock, sk_node);
     325             : }
     326             : 
     327             : static inline struct sock *sk_head(const struct hlist_head *head)
     328             : {
     329             :         return hlist_empty(head) ? NULL : __sk_head(head);
     330             : }
     331             : 
     332             : static inline struct sock *__sk_nulls_head(const struct hlist_nulls_head *head)
     333             : {
     334             :         return hlist_nulls_entry(head->first, struct sock, sk_nulls_node);
     335             : }
     336             : 
     337             : static inline struct sock *sk_nulls_head(const struct hlist_nulls_head *head)
     338             : {
     339             :         return hlist_nulls_empty(head) ? NULL : __sk_nulls_head(head);
     340             : }
     341             : 
     342             : static inline struct sock *sk_next(const struct sock *sk)
     343             : {
     344           6 :         return sk->sk_node.next ?
     345          18 :                 hlist_entry(sk->sk_node.next, struct sock, sk_node) : NULL;
     346             : }
     347             : 
     348             : static inline struct sock *sk_nulls_next(const struct sock *sk)
     349             : {
     350             :         return (!is_a_nulls(sk->sk_nulls_node.next)) ?
     351             :                 hlist_nulls_entry(sk->sk_nulls_node.next,
     352             :                                   struct sock, sk_nulls_node) :
     353             :                 NULL;
     354             : }
     355             : 
     356             : static inline int sk_unhashed(const struct sock *sk)
     357             : {
     358           0 :         return hlist_unhashed(&sk->sk_node);
     359             : }
     360             : 
     361             : static inline int sk_hashed(const struct sock *sk)
     362             : {
     363           0 :         return !sk_unhashed(sk);
     364             : }
     365             : 
     366             : static __inline__ void sk_node_init(struct hlist_node *node)
     367             : {
     368           0 :         node->pprev = NULL;
     369           0 : }
     370             : 
     371             : static __inline__ void sk_nulls_node_init(struct hlist_nulls_node *node)
     372             : {
     373             :         node->pprev = NULL;
     374             : }
     375             : 
     376             : static __inline__ void __sk_del_node(struct sock *sk)
     377             : {
     378           0 :         __hlist_del(&sk->sk_node);
     379           0 : }
     380             : 
     381             : static __inline__ int __sk_del_node_init(struct sock *sk)
     382             : {
     383           0 :         if (sk_hashed(sk)) {
     384           0 :                 __sk_del_node(sk);
     385           0 :                 sk_node_init(&sk->sk_node);
     386           0 :                 return 1;
     387             :         }
     388           0 :         return 0;
     389             : }
     390             : 
     391             : /* Grab socket reference count. This operation is valid only
     392             :    when sk is ALREADY grabbed f.e. it is found in hash table
     393             :    or a list and the lookup is made under lock preventing hash table
     394             :    modifications.
     395             :  */
     396             : 
     397             : static inline void sock_hold(struct sock *sk)
     398             : {
     399           0 :         atomic_inc(&sk->sk_refcnt);
     400           0 : }
     401             : 
     402             : /* Ungrab socket in the context, which assumes that socket refcnt
     403             :    cannot hit zero, f.e. it is true in context of any socketcall.
     404             :  */
     405             : static inline void __sock_put(struct sock *sk)
     406             : {
     407           0 :         atomic_dec(&sk->sk_refcnt);
     408           0 : }
     409             : 
     410             : static __inline__ int sk_del_node_init(struct sock *sk)
     411             : {
     412           0 :         int rc = __sk_del_node_init(sk);
     413           0 : 
     414           0 :         if (rc) {
     415           0 :                 /* paranoid for a while -acme */
     416           0 :                 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
     417           0 :                 __sock_put(sk);
     418             :         }
     419           0 :         return rc;
     420             : }
     421             : 
     422             : static __inline__ int __sk_nulls_del_node_init_rcu(struct sock *sk)
     423             : {
     424             :         if (sk_hashed(sk)) {
     425             :                 hlist_nulls_del_init_rcu(&sk->sk_nulls_node);
     426             :                 return 1;
     427             :         }
     428             :         return 0;
     429             : }
     430             : 
     431             : static __inline__ int sk_nulls_del_node_init_rcu(struct sock *sk)
     432             : {
     433             :         int rc = __sk_nulls_del_node_init_rcu(sk);
     434             : 
     435             :         if (rc) {
     436             :                 /* paranoid for a while -acme */
     437             :                 WARN_ON(atomic_read(&sk->sk_refcnt) == 1);
     438             :                 __sock_put(sk);
     439             :         }
     440             :         return rc;
     441             : }
     442             : 
     443             : static __inline__ void __sk_add_node(struct sock *sk, struct hlist_head *list)
     444             : {
     445           0 :         hlist_add_head(&sk->sk_node, list);
     446           0 : }
     447             : 
     448             : static __inline__ void sk_add_node(struct sock *sk, struct hlist_head *list)
     449             : {
     450           0 :         sock_hold(sk);
     451           0 :         __sk_add_node(sk, list);
     452           0 : }
     453             : 
     454             : static __inline__ void __sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
     455             : {
     456             :         hlist_nulls_add_head_rcu(&sk->sk_nulls_node, list);
     457             : }
     458             : 
     459             : static __inline__ void sk_nulls_add_node_rcu(struct sock *sk, struct hlist_nulls_head *list)
     460             : {
     461             :         sock_hold(sk);
     462             :         __sk_nulls_add_node_rcu(sk, list);
     463             : }
     464             : 
     465             : static __inline__ void __sk_del_bind_node(struct sock *sk)
     466             : {
     467             :         __hlist_del(&sk->sk_bind_node);
     468             : }
     469             : 
     470             : static __inline__ void sk_add_bind_node(struct sock *sk,
     471             :                                         struct hlist_head *list)
     472             : {
     473             :         hlist_add_head(&sk->sk_bind_node, list);
     474             : }
     475           1 : 
     476             : #define sk_for_each(__sk, node, list) \
     477             :         hlist_for_each_entry(__sk, node, list, sk_node)
     478             : #define sk_nulls_for_each(__sk, node, list) \
     479             :         hlist_nulls_for_each_entry(__sk, node, list, sk_nulls_node)
     480             : #define sk_nulls_for_each_rcu(__sk, node, list) \
     481             :         hlist_nulls_for_each_entry_rcu(__sk, node, list, sk_nulls_node)
     482             : #define sk_for_each_from(__sk, node) \
     483             :         if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
     484             :                 hlist_for_each_entry_from(__sk, node, sk_node)
     485             : #define sk_nulls_for_each_from(__sk, node) \
     486             :         if (__sk && ({ node = &(__sk)->sk_nulls_node; 1; })) \
     487             :                 hlist_nulls_for_each_entry_from(__sk, node, sk_nulls_node)
     488             : #define sk_for_each_continue(__sk, node) \
     489             :         if (__sk && ({ node = &(__sk)->sk_node; 1; })) \
     490             :                 hlist_for_each_entry_continue(__sk, node, sk_node)
     491             : #define sk_for_each_safe(__sk, node, tmp, list) \
     492             :         hlist_for_each_entry_safe(__sk, node, tmp, list, sk_node)
     493             : #define sk_for_each_bound(__sk, node, list) \
     494             :         hlist_for_each_entry(__sk, node, list, sk_bind_node)
     495             : 
     496             : /* Sock flags */
     497             : enum sock_flags {
     498             :         SOCK_DEAD,
     499             :         SOCK_DONE,
     500             :         SOCK_URGINLINE,
     501             :         SOCK_KEEPOPEN,
     502             :         SOCK_LINGER,
     503             :         SOCK_DESTROY,
     504             :         SOCK_BROADCAST,
     505             :         SOCK_TIMESTAMP,
     506             :         SOCK_ZAPPED,
     507             :         SOCK_USE_WRITE_QUEUE, /* whether to call sk->sk_write_space in sock_wfree */
     508             :         SOCK_DBG, /* %SO_DEBUG setting */
     509             :         SOCK_RCVTSTAMP, /* %SO_TIMESTAMP setting */
     510             :         SOCK_RCVTSTAMPNS, /* %SO_TIMESTAMPNS setting */
     511             :         SOCK_LOCALROUTE, /* route locally only, %SO_DONTROUTE setting */
     512             :         SOCK_QUEUE_SHRUNK, /* write queue has been shrunk recently */
     513             :         SOCK_TIMESTAMPING_TX_HARDWARE,  /* %SOF_TIMESTAMPING_TX_HARDWARE */
     514             :         SOCK_TIMESTAMPING_TX_SOFTWARE,  /* %SOF_TIMESTAMPING_TX_SOFTWARE */
     515             :         SOCK_TIMESTAMPING_RX_HARDWARE,  /* %SOF_TIMESTAMPING_RX_HARDWARE */
     516             :         SOCK_TIMESTAMPING_RX_SOFTWARE,  /* %SOF_TIMESTAMPING_RX_SOFTWARE */
     517             :         SOCK_TIMESTAMPING_SOFTWARE,     /* %SOF_TIMESTAMPING_SOFTWARE */
     518             :         SOCK_TIMESTAMPING_RAW_HARDWARE, /* %SOF_TIMESTAMPING_RAW_HARDWARE */
     519             :         SOCK_TIMESTAMPING_SYS_HARDWARE, /* %SOF_TIMESTAMPING_SYS_HARDWARE */
     520             :         SOCK_FASYNC, /* fasync() active */
     521             :         SOCK_RXQ_OVFL,
     522             : };
     523             : 
     524             : static inline void sock_copy_flags(struct sock *nsk, struct sock *osk)
     525             : {
     526             :         nsk->sk_flags = osk->sk_flags;
     527             : }
     528             : 
     529             : static inline void sock_set_flag(struct sock *sk, enum sock_flags flag)
     530             : {
     531           0 :         __set_bit(flag, &sk->sk_flags);
     532           0 : }
     533             : 
     534             : static inline void sock_reset_flag(struct sock *sk, enum sock_flags flag)
     535             : {
     536             :         __clear_bit(flag, &sk->sk_flags);
     537             : }
     538             : 
     539             : static inline int sock_flag(struct sock *sk, enum sock_flags flag)
     540             : {
     541           0 :         return test_bit(flag, &sk->sk_flags);
     542             : }
     543             : 
     544             : static inline void sk_acceptq_removed(struct sock *sk)
     545             : {
     546             :         sk->sk_ack_backlog--;
     547             : }
     548             : 
     549             : static inline void sk_acceptq_added(struct sock *sk)
     550             : {
     551             :         sk->sk_ack_backlog++;
     552             : }
     553             : 
     554             : static inline int sk_acceptq_is_full(struct sock *sk)
     555             : {
     556             :         return sk->sk_ack_backlog > sk->sk_max_ack_backlog;
     557             : }
     558             : 
     559             : /*
     560             :  * Compute minimal free write space needed to queue new packets.
     561             :  */
     562             : static inline int sk_stream_min_wspace(struct sock *sk)
     563             : {
     564             :         return sk->sk_wmem_queued >> 1;
     565             : }
     566             : 
     567             : static inline int sk_stream_wspace(struct sock *sk)
     568             : {
     569             :         return sk->sk_sndbuf - sk->sk_wmem_queued;
     570             : }
     571             : 
     572             : extern void sk_stream_write_space(struct sock *sk);
     573             : 
     574             : static inline int sk_stream_memory_free(struct sock *sk)
     575             : {
     576             :         return sk->sk_wmem_queued < sk->sk_sndbuf;
     577             : }
     578             : 
     579             : /* OOB backlog add */
     580             : static inline void __sk_add_backlog(struct sock *sk, struct sk_buff *skb)
     581             : {
     582             :         if (!sk->sk_backlog.tail) {
     583             :                 sk->sk_backlog.head = sk->sk_backlog.tail = skb;
     584             :         } else {
     585             :                 sk->sk_backlog.tail->next = skb;
     586             :                 sk->sk_backlog.tail = skb;
     587             :         }
     588             :         skb->next = NULL;
     589             : }
     590             : 
     591             : /* The per-socket spinlock must be held here. */
     592             : static inline __must_check int sk_add_backlog(struct sock *sk, struct sk_buff *skb)
     593             : {
     594             :         if (sk->sk_backlog.len >= max(sk->sk_backlog.limit, sk->sk_rcvbuf << 1))
     595             :                 return -ENOBUFS;
     596             : 
     597             :         __sk_add_backlog(sk, skb);
     598             :         sk->sk_backlog.len += skb->truesize;
     599             :         return 0;
     600             : }
     601             : 
     602             : static inline int sk_backlog_rcv(struct sock *sk, struct sk_buff *skb)
     603             : {
     604             :         return sk->sk_backlog_rcv(sk, skb);
     605             : }
     606             : 
     607             : #define sk_wait_event(__sk, __timeo, __condition)                       \
     608             :         ({      int __rc;                                               \
     609             :                 release_sock(__sk);                                     \
     610             :                 __rc = __condition;                                     \
     611             :                 if (!__rc) {                                            \
     612             :                         *(__timeo) = schedule_timeout(*(__timeo));      \
     613             :                 }                                                       \
     614             :                 lock_sock(__sk);                                        \
     615             :                 __rc = __condition;                                     \
     616             :                 __rc;                                                   \
     617             :         })
     618             : 
     619             : extern int sk_stream_wait_connect(struct sock *sk, long *timeo_p);
     620             : extern int sk_stream_wait_memory(struct sock *sk, long *timeo_p);
     621             : extern void sk_stream_wait_close(struct sock *sk, long timeo_p);
     622             : extern int sk_stream_error(struct sock *sk, int flags, int err);
     623             : extern void sk_stream_kill_queues(struct sock *sk);
     624             : 
     625             : extern int sk_wait_data(struct sock *sk, long *timeo);
     626           1 : 
     627           1 : struct request_sock_ops;
     628           1 : struct timewait_sock_ops;
     629           1 : struct inet_hashinfo;
     630           3 : struct raw_hashinfo;
     631             : 
     632             : /* Networking protocol blocks we attach to sockets.
     633             :  * socket layer -> transport layer interface
     634             :  * transport -> network interface is defined by struct inet_proto
     635             :  */
     636             : struct proto {
     637             :         void                    (*close)(struct sock *sk, 
     638             :                                         long timeout);
     639             :         int                     (*connect)(struct sock *sk,
     640             :                                         struct sockaddr *uaddr, 
     641             :                                         int addr_len);
     642             :         int                     (*disconnect)(struct sock *sk, int flags);
     643             : 
     644             :         struct sock *           (*accept) (struct sock *sk, int flags, int *err);
     645             : 
     646             :         int                     (*ioctl)(struct sock *sk, int cmd,
     647             :                                          unsigned long arg);
     648             :         int                     (*init)(struct sock *sk);
     649             :         void                    (*destroy)(struct sock *sk);
     650             :         void                    (*shutdown)(struct sock *sk, int how);
     651             :         int                     (*setsockopt)(struct sock *sk, int level, 
     652             :                                         int optname, char __user *optval,
     653             :                                         unsigned int optlen);
     654             :         int                     (*getsockopt)(struct sock *sk, int level, 
     655             :                                         int optname, char __user *optval, 
     656             :                                         int __user *option);     
     657             : #ifdef CONFIG_COMPAT
     658             :         int                     (*compat_setsockopt)(struct sock *sk,
     659             :                                         int level,
     660             :                                         int optname, char __user *optval,
     661             :                                         unsigned int optlen);
     662             :         int                     (*compat_getsockopt)(struct sock *sk,
     663             :                                         int level,
     664             :                                         int optname, char __user *optval,
     665             :                                         int __user *option);
     666             : #endif
     667             :         int                     (*sendmsg)(struct kiocb *iocb, struct sock *sk,
     668             :                                            struct msghdr *msg, size_t len);
     669             :         int                     (*recvmsg)(struct kiocb *iocb, struct sock *sk,
     670             :                                            struct msghdr *msg,
     671             :                                         size_t len, int noblock, int flags, 
     672             :                                         int *addr_len);
     673             :         int                     (*sendpage)(struct sock *sk, struct page *page,
     674             :                                         int offset, size_t size, int flags);
     675             :         int                     (*bind)(struct sock *sk, 
     676             :                                         struct sockaddr *uaddr, int addr_len);
     677             : 
     678             :         int                     (*backlog_rcv) (struct sock *sk, 
     679             :                                                 struct sk_buff *skb);
     680             : 
     681             :         /* Keeping track of sk's, looking them up, and port selection methods. */
     682             :         void                    (*hash)(struct sock *sk);
     683             :         void                    (*unhash)(struct sock *sk);
     684             :         void                    (*rehash)(struct sock *sk);
     685             :         int                     (*get_port)(struct sock *sk, unsigned short snum);
     686             : 
     687             :         /* Keeping track of sockets in use */
     688             : #ifdef CONFIG_PROC_FS
     689             :         unsigned int            inuse_idx;
     690             : #endif
     691             : 
     692             :         /* Memory pressure */
     693             :         void                    (*enter_memory_pressure)(struct sock *sk);
     694             :         atomic_t                *memory_allocated;      /* Current allocated memory. */
     695             :         struct percpu_counter   *sockets_allocated;     /* Current number of sockets. */
     696             :         /*
     697             :          * Pressure flag: try to collapse.
     698             :          * Technical note: it is used by multiple contexts non atomically.
     699             :          * All the __sk_mem_schedule() is of this nature: accounting
     700             :          * is strict, actions are advisory and have some latency.
     701             :          */
     702             :         int                     *memory_pressure;
     703             :         int                     *sysctl_mem;
     704             :         int                     *sysctl_wmem;
     705             :         int                     *sysctl_rmem;
     706             :         int                     max_header;
     707             : 
     708             :         struct kmem_cache       *slab;
     709             :         unsigned int            obj_size;
     710             :         int                     slab_flags;
     711             : 
     712             :         struct percpu_counter   *orphan_count;
     713             : 
     714             :         struct request_sock_ops *rsk_prot;
     715             :         struct timewait_sock_ops *twsk_prot;
     716             : 
     717             :         union {
     718             :                 struct inet_hashinfo    *hashinfo;
     719             :                 struct udp_table        *udp_table;
     720             :                 struct raw_hashinfo     *raw_hash;
     721             :         } h;
     722             : 
     723             :         struct module           *owner;
     724             : 
     725             :         char                    name[32];
     726             : 
     727             :         struct list_head        node;
     728             : #ifdef SOCK_REFCNT_DEBUG
     729             :         atomic_t                socks;
     730             : #endif
     731             : };
     732             : 
     733             : extern int proto_register(struct proto *prot, int alloc_slab);
     734             : extern void proto_unregister(struct proto *prot);
     735             : 
     736             : #ifdef SOCK_REFCNT_DEBUG
     737             : static inline void sk_refcnt_debug_inc(struct sock *sk)
     738             : {
     739             :         atomic_inc(&sk->sk_prot->socks);
     740             : }
     741             : 
     742             : static inline void sk_refcnt_debug_dec(struct sock *sk)
     743             : {
     744             :         atomic_dec(&sk->sk_prot->socks);
     745             :         printk(KERN_DEBUG "%s socket %p released, %d are still alive\n",
     746             :                sk->sk_prot->name, sk, atomic_read(&sk->sk_prot->socks));
     747             : }
     748             : 
     749             : static inline void sk_refcnt_debug_release(const struct sock *sk)
     750             : {
     751             :         if (atomic_read(&sk->sk_refcnt) != 1)
     752             :                 printk(KERN_DEBUG "Destruction of the %s socket %p delayed, refcnt=%d\n",
     753             :                        sk->sk_prot->name, sk, atomic_read(&sk->sk_refcnt));
     754             : }
     755             : #else /* SOCK_REFCNT_DEBUG */
     756             : #define sk_refcnt_debug_inc(sk) do { } while (0)
     757             : #define sk_refcnt_debug_dec(sk) do { } while (0)
     758             : #define sk_refcnt_debug_release(sk) do { } while (0)
     759             : #endif /* SOCK_REFCNT_DEBUG */
     760             : 
     761             : 
     762             : #ifdef CONFIG_PROC_FS
     763             : /* Called with local bh disabled */
     764             : extern void sock_prot_inuse_add(struct net *net, struct proto *prot, int inc);
     765             : extern int sock_prot_inuse_get(struct net *net, struct proto *proto);
     766             : #else
     767             : static void inline sock_prot_inuse_add(struct net *net, struct proto *prot,
     768             :                 int inc)
     769             : {
     770             : }
     771             : #endif
     772             : 
     773             : 
     774             : /* With per-bucket locks this operation is not-atomic, so that
     775             :  * this version is not worse.
     776             :  */
     777             : static inline void __sk_prot_rehash(struct sock *sk)
     778             : {
     779             :         sk->sk_prot->unhash(sk);
     780             :         sk->sk_prot->hash(sk);
     781             : }
     782           2 : 
     783             : /* About 10 seconds */
     784             : #define SOCK_DESTROY_TIME (10*HZ)
     785             : 
     786             : /* Sockets 0-1023 can't be bound to unless you are superuser */
     787             : #define PROT_SOCK       1024
     788             : 
     789             : #define SHUTDOWN_MASK   3
     790             : #define RCV_SHUTDOWN    1
     791             : #define SEND_SHUTDOWN   2
     792             : 
     793             : #define SOCK_SNDBUF_LOCK        1
     794             : #define SOCK_RCVBUF_LOCK        2
     795             : #define SOCK_BINDADDR_LOCK      4
     796             : #define SOCK_BINDPORT_LOCK      8
     797             : 
     798             : /* sock_iocb: used to kick off async processing of socket ios */
     799             : struct sock_iocb {
     800             :         struct list_head        list;
     801             : 
     802             :         int                     flags;
     803             :         int                     size;
     804             :         struct socket           *sock;
     805             :         struct sock             *sk;
     806             :         struct scm_cookie       *scm;
     807             :         struct msghdr           *msg, async_msg;
     808             :         struct kiocb            *kiocb;
     809             : };
     810             : 
     811             : static inline struct sock_iocb *kiocb_to_siocb(struct kiocb *iocb)
     812             : {
     813           0 :         return (struct sock_iocb *)iocb->private;
     814             : }
     815             : 
     816             : static inline struct kiocb *siocb_to_kiocb(struct sock_iocb *si)
     817             : {
     818             :         return si->kiocb;
     819             : }
     820           1 : 
     821             : struct socket_alloc {
     822             :         struct socket socket;
     823             :         struct inode vfs_inode;
     824             : };
     825             : 
     826             : static inline struct socket *SOCKET_I(struct inode *inode)
     827             : {
     828           0 :         return &container_of(inode, struct socket_alloc, vfs_inode)->socket;
     829             : }
     830             : 
     831             : static inline struct inode *SOCK_INODE(struct socket *socket)
     832             : {
     833           0 :         return &container_of(socket, struct socket_alloc, socket)->vfs_inode;
     834             : }
     835             : 
     836             : /*
     837             :  * Functions for memory accounting
     838             :  */
     839             : extern int __sk_mem_schedule(struct sock *sk, int size, int kind);
     840             : extern void __sk_mem_reclaim(struct sock *sk);
     841             : 
     842             : #define SK_MEM_QUANTUM ((int)PAGE_SIZE)
     843             : #define SK_MEM_QUANTUM_SHIFT ilog2(SK_MEM_QUANTUM)
     844             : #define SK_MEM_SEND     0
     845             : #define SK_MEM_RECV     1
     846             : 
     847             : static inline int sk_mem_pages(int amt)
     848             : {
     849             :         return (amt + SK_MEM_QUANTUM - 1) >> SK_MEM_QUANTUM_SHIFT;
     850             : }
     851             : 
     852             : static inline int sk_has_account(struct sock *sk)
     853             : {
     854             :         /* return true if protocol supports memory accounting */
     855             :         return !!sk->sk_prot->memory_allocated;
     856             : }
     857             : 
     858             : static inline int sk_wmem_schedule(struct sock *sk, int size)
     859             : {
     860             :         if (!sk_has_account(sk))
     861             :                 return 1;
     862             :         return size <= sk->sk_forward_alloc ||
     863             :                 __sk_mem_schedule(sk, size, SK_MEM_SEND);
     864             : }
     865             : 
     866             : static inline int sk_rmem_schedule(struct sock *sk, int size)
     867             : {
     868             :         if (!sk_has_account(sk))
     869             :                 return 1;
     870             :         return size <= sk->sk_forward_alloc ||
     871             :                 __sk_mem_schedule(sk, size, SK_MEM_RECV);
     872             : }
     873             : 
     874             : static inline void sk_mem_reclaim(struct sock *sk)
     875             : {
     876             :         if (!sk_has_account(sk))
     877             :                 return;
     878             :         if (sk->sk_forward_alloc >= SK_MEM_QUANTUM)
     879             :                 __sk_mem_reclaim(sk);
     880             : }
     881             : 
     882             : static inline void sk_mem_reclaim_partial(struct sock *sk)
     883             : {
     884             :         if (!sk_has_account(sk))
     885             :                 return;
     886             :         if (sk->sk_forward_alloc > SK_MEM_QUANTUM)
     887             :                 __sk_mem_reclaim(sk);
     888             : }
     889             : 
     890             : static inline void sk_mem_charge(struct sock *sk, int size)
     891             : {
     892             :         if (!sk_has_account(sk))
     893             :                 return;
     894             :         sk->sk_forward_alloc -= size;
     895             : }
     896             : 
     897             : static inline void sk_mem_uncharge(struct sock *sk, int size)
     898             : {
     899             :         if (!sk_has_account(sk))
     900             :                 return;
     901             :         sk->sk_forward_alloc += size;
     902             : }
     903             : 
     904             : static inline void sk_wmem_free_skb(struct sock *sk, struct sk_buff *skb)
     905             : {
     906             :         sock_set_flag(sk, SOCK_QUEUE_SHRUNK);
     907             :         sk->sk_wmem_queued -= skb->truesize;
     908             :         sk_mem_uncharge(sk, skb->truesize);
     909             :         __kfree_skb(skb);
     910             : }
     911             : 
     912             : /* Used by processes to "lock" a socket state, so that
     913             :  * interrupts and bottom half handlers won't change it
     914             :  * from under us. It essentially blocks any incoming
     915             :  * packets, so that we won't get any new data or any
     916             :  * packets that change the state of the socket.
     917             :  *
     918             :  * While locked, BH processing will add new packets to
     919             :  * the backlog queue.  This queue is processed by the
     920             :  * owner of the socket lock right before it is released.
     921             :  *
     922             :  * Since ~2.3.5 it is also exclusive sleep lock serializing
     923             :  * accesses from user process context.
     924             :  */
     925             : #define sock_owned_by_user(sk)  ((sk)->sk_lock.owned)
     926             : 
     927             : /*
     928             :  * Macro so as to not evaluate some arguments when
     929             :  * lockdep is not enabled.
     930             :  *
     931             :  * Mark both the sk_lock and the sk_lock.slock as a
     932             :  * per-address-family lock class.
     933             :  */
     934             : #define sock_lock_init_class_and_name(sk, sname, skey, name, key)       \
     935             : do {                                                                    \
     936             :         sk->sk_lock.owned = 0;                                               \
     937             :         init_waitqueue_head(&sk->sk_lock.wq);                            \
     938             :         spin_lock_init(&(sk)->sk_lock.slock);                            \
     939             :         debug_check_no_locks_freed((void *)&(sk)->sk_lock,               \
     940             :                         sizeof((sk)->sk_lock));                              \
     941             :         lockdep_set_class_and_name(&(sk)->sk_lock.slock,         \
     942             :                         (skey), (sname));                               \
     943             :         lockdep_init_map(&(sk)->sk_lock.dep_map, (name), (key), 0);      \
     944             : } while (0)
     945             : 
     946             : extern void lock_sock_nested(struct sock *sk, int subclass);
     947             : 
     948             : static inline void lock_sock(struct sock *sk)
     949             : {
     950             :         lock_sock_nested(sk, 0);
     951             : }
     952             : 
     953             : extern void release_sock(struct sock *sk);
     954             : 
     955             : /* BH context may only use the following locking interface. */
     956             : #define bh_lock_sock(__sk)      spin_lock(&((__sk)->sk_lock.slock))
     957             : #define bh_lock_sock_nested(__sk) \
     958             :                                 spin_lock_nested(&((__sk)->sk_lock.slock), \
     959             :                                 SINGLE_DEPTH_NESTING)
     960             : #define bh_unlock_sock(__sk)    spin_unlock(&((__sk)->sk_lock.slock))
     961             : 
     962             : extern struct sock              *sk_alloc(struct net *net, int family,
     963             :                                           gfp_t priority,
     964             :                                           struct proto *prot);
     965             : extern void                     sk_free(struct sock *sk);
     966             : extern void                     sk_release_kernel(struct sock *sk);
     967             : extern struct sock              *sk_clone(const struct sock *sk,
     968             :                                           const gfp_t priority);
     969             : 
     970             : extern struct sk_buff           *sock_wmalloc(struct sock *sk,
     971             :                                               unsigned long size, int force,
     972             :                                               gfp_t priority);
     973             : extern struct sk_buff           *sock_rmalloc(struct sock *sk,
     974             :                                               unsigned long size, int force,
     975             :                                               gfp_t priority);
     976             : extern void                     sock_wfree(struct sk_buff *skb);
     977             : extern void                     sock_rfree(struct sk_buff *skb);
     978             : 
     979             : extern int                      sock_setsockopt(struct socket *sock, int level,
     980             :                                                 int op, char __user *optval,
     981             :                                                 unsigned int optlen);
     982             : 
     983             : extern int                      sock_getsockopt(struct socket *sock, int level,
     984             :                                                 int op, char __user *optval, 
     985             :                                                 int __user *optlen);
     986             : extern struct sk_buff           *sock_alloc_send_skb(struct sock *sk,
     987             :                                                      unsigned long size,
     988             :                                                      int noblock,
     989             :                                                      int *errcode);
     990             : extern struct sk_buff           *sock_alloc_send_pskb(struct sock *sk,
     991             :                                                       unsigned long header_len,
     992             :                                                       unsigned long data_len,
     993             :                                                       int noblock,
     994             :                                                       int *errcode);
     995             : extern void *sock_kmalloc(struct sock *sk, int size,
     996             :                           gfp_t priority);
     997             : extern void sock_kfree_s(struct sock *sk, void *mem, int size);
     998             : extern void sk_send_sigurg(struct sock *sk);
     999             : 
    1000             : /*
    1001             :  * Functions to fill in entries in struct proto_ops when a protocol
    1002             :  * does not implement a particular function.
    1003             :  */
    1004             : extern int                      sock_no_bind(struct socket *, 
    1005             :                                              struct sockaddr *, int);
    1006             : extern int                      sock_no_connect(struct socket *,
    1007             :                                                 struct sockaddr *, int, int);
    1008             : extern int                      sock_no_socketpair(struct socket *,
    1009             :                                                    struct socket *);
    1010             : extern int                      sock_no_accept(struct socket *,
    1011             :                                                struct socket *, int);
    1012             : extern int                      sock_no_getname(struct socket *,
    1013             :                                                 struct sockaddr *, int *, int);
    1014             : extern unsigned int             sock_no_poll(struct file *, struct socket *,
    1015             :                                              struct poll_table_struct *);
    1016             : extern int                      sock_no_ioctl(struct socket *, unsigned int,
    1017             :                                               unsigned long);
    1018             : extern int                      sock_no_listen(struct socket *, int);
    1019             : extern int                      sock_no_shutdown(struct socket *, int);
    1020             : extern int                      sock_no_getsockopt(struct socket *, int , int,
    1021             :                                                    char __user *, int __user *);
    1022             : extern int                      sock_no_setsockopt(struct socket *, int, int,
    1023             :                                                    char __user *, unsigned int);
    1024             : extern int                      sock_no_sendmsg(struct kiocb *, struct socket *,
    1025             :                                                 struct msghdr *, size_t);
    1026             : extern int                      sock_no_recvmsg(struct kiocb *, struct socket *,
    1027             :                                                 struct msghdr *, size_t, int);
    1028             : extern int                      sock_no_mmap(struct file *file,
    1029             :                                              struct socket *sock,
    1030             :                                              struct vm_area_struct *vma);
    1031             : extern ssize_t                  sock_no_sendpage(struct socket *sock,
    1032             :                                                 struct page *page,
    1033             :                                                 int offset, size_t size, 
    1034             :                                                 int flags);
    1035             : 
    1036             : /*
    1037             :  * Functions to fill in entries in struct proto_ops when a protocol
    1038             :  * uses the inet style.
    1039             :  */
    1040             : extern int sock_common_getsockopt(struct socket *sock, int level, int optname,
    1041             :                                   char __user *optval, int __user *optlen);
    1042             : extern int sock_common_recvmsg(struct kiocb *iocb, struct socket *sock,
    1043             :                                struct msghdr *msg, size_t size, int flags);
    1044             : extern int sock_common_setsockopt(struct socket *sock, int level, int optname,
    1045             :                                   char __user *optval, unsigned int optlen);
    1046             : extern int compat_sock_common_getsockopt(struct socket *sock, int level,
    1047             :                 int optname, char __user *optval, int __user *optlen);
    1048             : extern int compat_sock_common_setsockopt(struct socket *sock, int level,
    1049             :                 int optname, char __user *optval, unsigned int optlen);
    1050             : 
    1051             : extern void sk_common_release(struct sock *sk);
    1052             : 
    1053             : /*
    1054             :  *      Default socket callbacks and setup code
    1055             :  */
    1056             :  
    1057             : /* Initialise core socket variables */
    1058             : extern void sock_init_data(struct socket *sock, struct sock *sk);
    1059             : 
    1060             : /**
    1061             :  *      sk_filter_release: Release a socket filter
    1062             :  *      @fp: filter to remove
    1063             :  *
    1064             :  *      Remove a filter from a socket and release its resources.
    1065             :  */
    1066             : 
    1067             : static inline void sk_filter_release(struct sk_filter *fp)
    1068             : {
    1069             :         if (atomic_dec_and_test(&fp->refcnt))
    1070             :                 kfree(fp);
    1071             : }
    1072             : 
    1073             : static inline void sk_filter_uncharge(struct sock *sk, struct sk_filter *fp)
    1074             : {
    1075             :         unsigned int size = sk_filter_len(fp);
    1076             : 
    1077             :         atomic_sub(size, &sk->sk_omem_alloc);
    1078             :         sk_filter_release(fp);
    1079             : }
    1080             : 
    1081             : static inline void sk_filter_charge(struct sock *sk, struct sk_filter *fp)
    1082             : {
    1083             :         atomic_inc(&fp->refcnt);
    1084             :         atomic_add(sk_filter_len(fp), &sk->sk_omem_alloc);
    1085             : }
    1086             : 
    1087             : /*
    1088             :  * Socket reference counting postulates.
    1089             :  *
    1090             :  * * Each user of socket SHOULD hold a reference count.
    1091             :  * * Each access point to socket (an hash table bucket, reference from a list,
    1092             :  *   running timer, skb in flight MUST hold a reference count.
    1093             :  * * When reference count hits 0, it means it will never increase back.
    1094             :  * * When reference count hits 0, it means that no references from
    1095             :  *   outside exist to this socket and current process on current CPU
    1096             :  *   is last user and may/should destroy this socket.
    1097             :  * * sk_free is called from any context: process, BH, IRQ. When
    1098             :  *   it is called, socket has no references from outside -> sk_free
    1099             :  *   may release descendant resources allocated by the socket, but
    1100             :  *   to the time when it is called, socket is NOT referenced by any
    1101             :  *   hash tables, lists etc.
    1102             :  * * Packets, delivered from outside (from network or from another process)
    1103             :  *   and enqueued on receive/error queues SHOULD NOT grab reference count,
    1104             :  *   when they sit in queue. Otherwise, packets will leak to hole, when
    1105             :  *   socket is looked up by one cpu and unhasing is made by another CPU.
    1106             :  *   It is true for udp/raw, netlink (leak to receive and error queues), tcp
    1107             :  *   (leak to backlog). Packet socket does all the processing inside
    1108             :  *   BR_NETPROTO_LOCK, so that it has not this race condition. UNIX sockets
    1109             :  *   use separate SMP lock, so that they are prone too.
    1110             :  */
    1111             : 
    1112             : /* Ungrab socket and destroy it, if it was the last reference. */
    1113             : static inline void sock_put(struct sock *sk)
    1114             : {
    1115           0 :         if (atomic_dec_and_test(&sk->sk_refcnt))
    1116           0 :                 sk_free(sk);
    1117           0 : }
    1118             : 
    1119             : extern int sk_receive_skb(struct sock *sk, struct sk_buff *skb,
    1120             :                           const int nested);
    1121             : 
    1122             : static inline void sk_tx_queue_set(struct sock *sk, int tx_queue)
    1123             : {
    1124             :         sk->sk_tx_queue_mapping = tx_queue;
    1125             : }
    1126             : 
    1127             : static inline void sk_tx_queue_clear(struct sock *sk)
    1128             : {
    1129           0 :         sk->sk_tx_queue_mapping = -1;
    1130           0 : }
    1131             : 
    1132             : static inline int sk_tx_queue_get(const struct sock *sk)
    1133             : {
    1134             :         return sk ? sk->sk_tx_queue_mapping : -1;
    1135             : }
    1136             : 
    1137             : static inline void sk_set_socket(struct sock *sk, struct socket *sock)
    1138             : {
    1139           0 :         sk_tx_queue_clear(sk);
    1140           0 :         sk->sk_socket = sock;
    1141           0 : }
    1142             : 
    1143             : /* Detach socket from process context.
    1144             :  * Announce socket dead, detach it from wait queue and inode.
    1145             :  * Note that parent inode held reference count on this struct sock,
    1146             :  * we do not release it in this function, because protocol
    1147             :  * probably wants some additional cleanups or even continuing
    1148             :  * to work with this socket (TCP).
    1149             :  */
    1150             : static inline void sock_orphan(struct sock *sk)
    1151             : {
    1152           0 :         write_lock_bh(&sk->sk_callback_lock);
    1153           0 :         sock_set_flag(sk, SOCK_DEAD);
    1154           0 :         sk_set_socket(sk, NULL);
    1155           0 :         sk->sk_sleep  = NULL;
    1156           0 :         write_unlock_bh(&sk->sk_callback_lock);
    1157           0 : }
    1158             : 
    1159             : static inline void sock_graft(struct sock *sk, struct socket *parent)
    1160             : {
    1161           0 :         write_lock_bh(&sk->sk_callback_lock);
    1162           0 :         sk->sk_sleep = &parent->wait;
    1163           0 :         parent->sk = sk;
    1164           0 :         sk_set_socket(sk, parent);
    1165           0 :         security_sock_graft(sk, parent);
    1166           0 :         write_unlock_bh(&sk->sk_callback_lock);
    1167           0 : }
    1168             : 
    1169             : extern int sock_i_uid(struct sock *sk);
    1170             : extern unsigned long sock_i_ino(struct sock *sk);
    1171             : 
    1172             : static inline struct dst_entry *
    1173             : __sk_dst_get(struct sock *sk)
    1174             : {
    1175             :         return sk->sk_dst_cache;
    1176             : }
    1177             : 
    1178             : static inline struct dst_entry *
    1179             : sk_dst_get(struct sock *sk)
    1180             : {
    1181             :         struct dst_entry *dst;
    1182             : 
    1183             :         read_lock(&sk->sk_dst_lock);
    1184             :         dst = sk->sk_dst_cache;
    1185             :         if (dst)
    1186             :                 dst_hold(dst);
    1187             :         read_unlock(&sk->sk_dst_lock);
    1188             :         return dst;
    1189             : }
    1190             : 
    1191             : static inline void
    1192             : __sk_dst_set(struct sock *sk, struct dst_entry *dst)
    1193             : {
    1194             :         struct dst_entry *old_dst;
    1195             : 
    1196             :         sk_tx_queue_clear(sk);
    1197             :         old_dst = sk->sk_dst_cache;
    1198             :         sk->sk_dst_cache = dst;
    1199             :         dst_release(old_dst);
    1200             : }
    1201             : 
    1202             : static inline void
    1203             : sk_dst_set(struct sock *sk, struct dst_entry *dst)
    1204             : {
    1205             :         write_lock(&sk->sk_dst_lock);
    1206             :         __sk_dst_set(sk, dst);
    1207             :         write_unlock(&sk->sk_dst_lock);
    1208             : }
    1209             : 
    1210             : static inline void
    1211             : __sk_dst_reset(struct sock *sk)
    1212             : {
    1213             :         struct dst_entry *old_dst;
    1214             : 
    1215             :         sk_tx_queue_clear(sk);
    1216             :         old_dst = sk->sk_dst_cache;
    1217             :         sk->sk_dst_cache = NULL;
    1218             :         dst_release(old_dst);
    1219             : }
    1220             : 
    1221             : static inline void
    1222             : sk_dst_reset(struct sock *sk)
    1223             : {
    1224             :         write_lock(&sk->sk_dst_lock);
    1225             :         __sk_dst_reset(sk);
    1226             :         write_unlock(&sk->sk_dst_lock);
    1227             : }
    1228             : 
    1229             : extern struct dst_entry *__sk_dst_check(struct sock *sk, u32 cookie);
    1230             : 
    1231             : extern struct dst_entry *sk_dst_check(struct sock *sk, u32 cookie);
    1232             : 
    1233             : static inline int sk_can_gso(const struct sock *sk)
    1234             : {
    1235             :         return net_gso_ok(sk->sk_route_caps, sk->sk_gso_type);
    1236             : }
    1237             : 
    1238             : extern void sk_setup_caps(struct sock *sk, struct dst_entry *dst);
    1239             : 
    1240             : static inline int skb_copy_to_page(struct sock *sk, char __user *from,
    1241             :                                    struct sk_buff *skb, struct page *page,
    1242             :                                    int off, int copy)
    1243             : {
    1244             :         if (skb->ip_summed == CHECKSUM_NONE) {
    1245             :                 int err = 0;
    1246             :                 __wsum csum = csum_and_copy_from_user(from,
    1247             :                                                      page_address(page) + off,
    1248             :                                                             copy, 0, &err);
    1249             :                 if (err)
    1250             :                         return err;
    1251             :                 skb->csum = csum_block_add(skb->csum, csum, skb->len);
    1252             :         } else if (copy_from_user(page_address(page) + off, from, copy))
    1253             :                 return -EFAULT;
    1254             : 
    1255             :         skb->len          += copy;
    1256             :         skb->data_len             += copy;
    1257             :         skb->truesize             += copy;
    1258             :         sk->sk_wmem_queued   += copy;
    1259             :         sk_mem_charge(sk, copy);
    1260             :         return 0;
    1261             : }
    1262             : 
    1263             : /**
    1264             :  * sk_wmem_alloc_get - returns write allocations
    1265             :  * @sk: socket
    1266             :  *
    1267             :  * Returns sk_wmem_alloc minus initial offset of one
    1268             :  */
    1269             : static inline int sk_wmem_alloc_get(const struct sock *sk)
    1270             : {
    1271           0 :         return atomic_read(&sk->sk_wmem_alloc) - 1;
    1272             : }
    1273             : 
    1274             : /**
    1275             :  * sk_rmem_alloc_get - returns read allocations
    1276             :  * @sk: socket
    1277             :  *
    1278             :  * Returns sk_rmem_alloc
    1279             :  */
    1280             : static inline int sk_rmem_alloc_get(const struct sock *sk)
    1281             : {
    1282             :         return atomic_read(&sk->sk_rmem_alloc);
    1283             : }
    1284             : 
    1285             : /**
    1286             :  * sk_has_allocations - check if allocations are outstanding
    1287             :  * @sk: socket
    1288             :  *
    1289             :  * Returns true if socket has write or read allocations
    1290             :  */
    1291             : static inline int sk_has_allocations(const struct sock *sk)
    1292             : {
    1293             :         return sk_wmem_alloc_get(sk) || sk_rmem_alloc_get(sk);
    1294             : }
    1295             : 
    1296             : /**
    1297             :  * sk_has_sleeper - check if there are any waiting processes
    1298             :  * @sk: socket
    1299             :  *
    1300             :  * Returns true if socket has waiting processes
    1301             :  *
    1302             :  * The purpose of the sk_has_sleeper and sock_poll_wait is to wrap the memory
    1303             :  * barrier call. They were added due to the race found within the tcp code.
    1304             :  *
    1305             :  * Consider following tcp code paths:
    1306             :  *
    1307             :  * CPU1                  CPU2
    1308             :  *
    1309             :  * sys_select            receive packet
    1310             :  *   ...                 ...
    1311             :  *   __add_wait_queue    update tp->rcv_nxt
    1312             :  *   ...                 ...
    1313             :  *   tp->rcv_nxt check   sock_def_readable
    1314             :  *   ...                 {
    1315             :  *   schedule               ...
    1316             :  *                          if (sk->sk_sleep && waitqueue_active(sk->sk_sleep))
    1317             :  *                              wake_up_interruptible(sk->sk_sleep)
    1318             :  *                          ...
    1319             :  *                       }
    1320             :  *
    1321             :  * The race for tcp fires when the __add_wait_queue changes done by CPU1 stay
    1322             :  * in its cache, and so does the tp->rcv_nxt update on CPU2 side.  The CPU1
    1323             :  * could then endup calling schedule and sleep forever if there are no more
    1324             :  * data on the socket.
    1325             :  *
    1326             :  * The sk_has_sleeper is always called right after a call to read_lock, so we
    1327             :  * can use smp_mb__after_lock barrier.
    1328             :  */
    1329             : static inline int sk_has_sleeper(struct sock *sk)
    1330             : {
    1331           0 :         /*
    1332           0 :          * We need to be sure we are in sync with the
    1333             :          * add_wait_queue modifications to the wait queue.
    1334             :          *
    1335             :          * This memory barrier is paired in the sock_poll_wait.
    1336             :          */
    1337           0 :         smp_mb__after_lock();
    1338           0 :         return sk->sk_sleep && waitqueue_active(sk->sk_sleep);
    1339             : }
    1340             : 
    1341             : /**
    1342             :  * sock_poll_wait - place memory barrier behind the poll_wait call.
    1343             :  * @filp:           file
    1344             :  * @wait_address:   socket wait queue
    1345             :  * @p:              poll_table
    1346             :  *
    1347             :  * See the comments in the sk_has_sleeper function.
    1348             :  */
    1349             : static inline void sock_poll_wait(struct file *filp,
    1350             :                 wait_queue_head_t *wait_address, poll_table *p)
    1351             : {
    1352           0 :         if (p && wait_address) {
    1353           0 :                 poll_wait(filp, wait_address, p);
    1354             :                 /*
    1355             :                  * We need to be sure we are in sync with the
    1356             :                  * socket flags modification.
    1357             :                  *
    1358             :                  * This memory barrier is paired in the sk_has_sleeper.
    1359             :                 */
    1360           0 :                 smp_mb();
    1361             :         }
    1362           0 : }
    1363             : 
    1364             : /*
    1365             :  *      Queue a received datagram if it will fit. Stream and sequenced
    1366             :  *      protocols can't normally use this as they need to fit buffers in
    1367             :  *      and play with them.
    1368             :  *
    1369             :  *      Inlined as it's very short and called for pretty much every
    1370             :  *      packet ever received.
    1371             :  */
    1372             : 
    1373             : static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
    1374             : {
    1375             :         skb_orphan(skb);
    1376             :         skb->sk = sk;
    1377             :         skb->destructor = sock_wfree;
    1378             :         /*
    1379             :          * We used to take a refcount on sk, but following operation
    1380             :          * is enough to guarantee sk_free() wont free this sock until
    1381             :          * all in-flight packets are completed
    1382             :          */
    1383             :         atomic_add(skb->truesize, &sk->sk_wmem_alloc);
    1384             : }
    1385             : 
    1386             : static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
    1387             : {
    1388             :         skb_orphan(skb);
    1389             :         skb->sk = sk;
    1390             :         skb->destructor = sock_rfree;
    1391             :         atomic_add(skb->truesize, &sk->sk_rmem_alloc);
    1392             :         sk_mem_charge(sk, skb->truesize);
    1393             : }
    1394             : 
    1395             : extern void sk_reset_timer(struct sock *sk, struct timer_list* timer,
    1396             :                            unsigned long expires);
    1397             : 
    1398             : extern void sk_stop_timer(struct sock *sk, struct timer_list* timer);
    1399             : 
    1400             : extern int sock_queue_rcv_skb(struct sock *sk, struct sk_buff *skb);
    1401             : 
    1402             : static inline int sock_queue_err_skb(struct sock *sk, struct sk_buff *skb)
    1403             : {
    1404             :         /* Cast skb->rcvbuf to unsigned... It's pointless, but reduces
    1405             :            number of warnings when compiling with -W --ANK
    1406             :          */
    1407             :         if (atomic_read(&sk->sk_rmem_alloc) + skb->truesize >=
    1408             :             (unsigned)sk->sk_rcvbuf)
    1409             :                 return -ENOMEM;
    1410             :         skb_set_owner_r(skb, sk);
    1411             :         skb_queue_tail(&sk->sk_error_queue, skb);
    1412             :         if (!sock_flag(sk, SOCK_DEAD))
    1413             :                 sk->sk_data_ready(sk, skb->len);
    1414             :         return 0;
    1415             : }
    1416             : 
    1417             : /*
    1418             :  *      Recover an error report and clear atomically
    1419             :  */
    1420             :  
    1421             : static inline int sock_error(struct sock *sk)
    1422             : {
    1423           0 :         int err;
    1424           0 :         if (likely(!sk->sk_err))
    1425           0 :                 return 0;
    1426           0 :         err = xchg(&sk->sk_err, 0);
    1427           0 :         return -err;
    1428             : }
    1429             : 
    1430             : static inline unsigned long sock_wspace(struct sock *sk)
    1431             : {
    1432             :         int amt = 0;
    1433             : 
    1434             :         if (!(sk->sk_shutdown & SEND_SHUTDOWN)) {
    1435             :                 amt = sk->sk_sndbuf - atomic_read(&sk->sk_wmem_alloc);
    1436             :                 if (amt < 0) 
    1437             :                         amt = 0;
    1438             :         }
    1439             :         return amt;
    1440             : }
    1441             : 
    1442             : static inline void sk_wake_async(struct sock *sk, int how, int band)
    1443             : {
    1444           0 :         if (sock_flag(sk, SOCK_FASYNC))
    1445           0 :                 sock_wake_async(sk->sk_socket, how, band);
    1446           0 : }
    1447             : 
    1448             : #define SOCK_MIN_SNDBUF 2048
    1449             : #define SOCK_MIN_RCVBUF 256
    1450             : 
    1451             : static inline void sk_stream_moderate_sndbuf(struct sock *sk)
    1452             : {
    1453             :         if (!(sk->sk_userlocks & SOCK_SNDBUF_LOCK)) {
    1454             :                 sk->sk_sndbuf = min(sk->sk_sndbuf, sk->sk_wmem_queued >> 1);
    1455             :                 sk->sk_sndbuf = max(sk->sk_sndbuf, SOCK_MIN_SNDBUF);
    1456             :         }
    1457             : }
    1458             : 
    1459             : struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp);
    1460             : 
    1461             : static inline struct page *sk_stream_alloc_page(struct sock *sk)
    1462             : {
    1463             :         struct page *page = NULL;
    1464             : 
    1465             :         page = alloc_pages(sk->sk_allocation, 0);
    1466             :         if (!page) {
    1467             :                 sk->sk_prot->enter_memory_pressure(sk);
    1468             :                 sk_stream_moderate_sndbuf(sk);
    1469             :         }
    1470             :         return page;
    1471             : }
    1472             : 
    1473             : /*
    1474             :  *      Default write policy as shown to user space via poll/select/SIGIO
    1475             :  */
    1476             : static inline int sock_writeable(const struct sock *sk) 
    1477             : {
    1478             :         return atomic_read(&sk->sk_wmem_alloc) < (sk->sk_sndbuf >> 1);
    1479             : }
    1480             : 
    1481             : static inline gfp_t gfp_any(void)
    1482             : {
    1483             :         return in_softirq() ? GFP_ATOMIC : GFP_KERNEL;
    1484             : }
    1485             : 
    1486             : static inline long sock_rcvtimeo(const struct sock *sk, int noblock)
    1487             : {
    1488           0 :         return noblock ? 0 : sk->sk_rcvtimeo;
    1489             : }
    1490             : 
    1491             : static inline long sock_sndtimeo(const struct sock *sk, int noblock)
    1492             : {
    1493           0 :         return noblock ? 0 : sk->sk_sndtimeo;
    1494             : }
    1495             : 
    1496             : static inline int sock_rcvlowat(const struct sock *sk, int waitall, int len)
    1497             : {
    1498           0 :         return (waitall ? len : min_t(int, sk->sk_rcvlowat, len)) ? : 1;
    1499           0 : }
    1500           0 : 
    1501             : /* Alas, with timeout socket operations are not restartable.
    1502             :  * Compare this to poll().
    1503             :  */
    1504             : static inline int sock_intr_errno(long timeo)
    1505             : {
    1506           0 :         return timeo == MAX_SCHEDULE_TIMEOUT ? -ERESTARTSYS : -EINTR;
    1507             : }
    1508             : 
    1509             : extern void __sock_recv_timestamp(struct msghdr *msg, struct sock *sk,
    1510             :         struct sk_buff *skb);
    1511             : 
    1512             : static __inline__ void
    1513             : sock_recv_timestamp(struct msghdr *msg, struct sock *sk, struct sk_buff *skb)
    1514             : {
    1515             :         ktime_t kt = skb->tstamp;
    1516             :         struct skb_shared_hwtstamps *hwtstamps = skb_hwtstamps(skb);
    1517             : 
    1518             :         /*
    1519             :          * generate control messages if
    1520             :          * - receive time stamping in software requested (SOCK_RCVTSTAMP
    1521             :          *   or SOCK_TIMESTAMPING_RX_SOFTWARE)
    1522             :          * - software time stamp available and wanted
    1523             :          *   (SOCK_TIMESTAMPING_SOFTWARE)
    1524             :          * - hardware time stamps available and wanted
    1525             :          *   (SOCK_TIMESTAMPING_SYS_HARDWARE or
    1526             :          *   SOCK_TIMESTAMPING_RAW_HARDWARE)
    1527             :          */
    1528             :         if (sock_flag(sk, SOCK_RCVTSTAMP) ||
    1529             :             sock_flag(sk, SOCK_TIMESTAMPING_RX_SOFTWARE) ||
    1530             :             (kt.tv64 && sock_flag(sk, SOCK_TIMESTAMPING_SOFTWARE)) ||
    1531             :             (hwtstamps->hwtstamp.tv64 &&
    1532             :              sock_flag(sk, SOCK_TIMESTAMPING_RAW_HARDWARE)) ||
    1533             :             (hwtstamps->syststamp.tv64 &&
    1534             :              sock_flag(sk, SOCK_TIMESTAMPING_SYS_HARDWARE)))
    1535             :                 __sock_recv_timestamp(msg, sk, skb);
    1536             :         else
    1537             :                 sk->sk_stamp = kt;
    1538             : }
    1539             : 
    1540             : extern void sock_recv_ts_and_drops(struct msghdr *msg, struct sock *sk, struct sk_buff *skb);
    1541             : 
    1542             : /**
    1543             :  * sock_tx_timestamp - checks whether the outgoing packet is to be time stamped
    1544             :  * @msg:        outgoing packet
    1545             :  * @sk:         socket sending this packet
    1546             :  * @shtx:       filled with instructions for time stamping
    1547             :  *
    1548             :  * Currently only depends on SOCK_TIMESTAMPING* flags. Returns error code if
    1549             :  * parameters are invalid.
    1550             :  */
    1551             : extern int sock_tx_timestamp(struct msghdr *msg,
    1552             :                              struct sock *sk,
    1553             :                              union skb_shared_tx *shtx);
    1554             : 
    1555             : 
    1556             : /**
    1557             :  * sk_eat_skb - Release a skb if it is no longer needed
    1558             :  * @sk: socket to eat this skb from
    1559             :  * @skb: socket buffer to eat
    1560             :  * @copied_early: flag indicating whether DMA operations copied this data early
    1561             :  *
    1562             :  * This routine must be called with interrupts disabled or with the socket
    1563             :  * locked so that the sk_buff queue operation is ok.
    1564             : */
    1565             : #ifdef CONFIG_NET_DMA
    1566             : static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
    1567             : {
    1568             :         __skb_unlink(skb, &sk->sk_receive_queue);
    1569             :         if (!copied_early)
    1570             :                 __kfree_skb(skb);
    1571             :         else
    1572             :                 __skb_queue_tail(&sk->sk_async_wait_queue, skb);
    1573             : }
    1574             : #else
    1575             : static inline void sk_eat_skb(struct sock *sk, struct sk_buff *skb, int copied_early)
    1576             : {
    1577             :         __skb_unlink(skb, &sk->sk_receive_queue);
    1578             :         __kfree_skb(skb);
    1579             : }
    1580             : #endif
    1581             : 
    1582             : static inline
    1583             : struct net *sock_net(const struct sock *sk)
    1584             : {
    1585             : #ifdef CONFIG_NET_NS
    1586             :         return sk->sk_net;
    1587             : #else
    1588           2 :         return &init_net;
    1589             : #endif
    1590             : }
    1591             : 
    1592             : static inline
    1593             : void sock_net_set(struct sock *sk, struct net *net)
    1594             : {
    1595             : #ifdef CONFIG_NET_NS
    1596             :         sk->sk_net = net;
    1597             : #endif
    1598             : }
    1599             : 
    1600             : /*
    1601             :  * Kernel sockets, f.e. rtnl or icmp_socket, are a part of a namespace.
    1602             :  * They should not hold a referrence to a namespace in order to allow
    1603             :  * to stop it.
    1604             :  * Sockets after sk_change_net should be released using sk_release_kernel
    1605             :  */
    1606             : static inline void sk_change_net(struct sock *sk, struct net *net)
    1607             : {
    1608             :         put_net(sock_net(sk));
    1609             :         sock_net_set(sk, hold_net(net));
    1610             : }
    1611             : 
    1612             : static inline struct sock *skb_steal_sock(struct sk_buff *skb)
    1613             : {
    1614             :         if (unlikely(skb->sk)) {
    1615             :                 struct sock *sk = skb->sk;
    1616             : 
    1617             :                 skb->destructor = NULL;
    1618             :                 skb->sk = NULL;
    1619             :                 return sk;
    1620             :         }
    1621             :         return NULL;
    1622             : }
    1623             : 
    1624             : extern void sock_enable_timestamp(struct sock *sk, int flag);
    1625             : extern int sock_get_timestamp(struct sock *, struct timeval __user *);
    1626             : extern int sock_get_timestampns(struct sock *, struct timespec __user *);
    1627             : 
    1628             : /* 
    1629             :  *      Enable debug/info messages 
    1630             :  */
    1631             : extern int net_msg_warn;
    1632             : #define NETDEBUG(fmt, args...) \
    1633             :         do { if (net_msg_warn) printk(fmt,##args); } while (0)
    1634             : 
    1635             : #define LIMIT_NETDEBUG(fmt, args...) \
    1636             :         do { if (net_msg_warn && net_ratelimit()) printk(fmt,##args); } while(0)
    1637             : 
    1638             : extern __u32 sysctl_wmem_max;
    1639             : extern __u32 sysctl_rmem_max;
    1640             : 
    1641             : extern void sk_init(void);
    1642             : 
    1643             : extern int sysctl_optmem_max;
    1644             : 
    1645             : extern __u32 sysctl_wmem_default;
    1646             : extern __u32 sysctl_rmem_default;
    1647             : 
    1648             : #endif  /* _SOCK_H */

Generated by: LCOV version 1.10