1 files changed, 88 insertions, 34 deletions

diff --git a/include/net/sock.h b/include/net/sock.h
index 7aa78440559a..7f89e4ba18d1 100644
--- a/include/net/sock.h
+++ b/include/net/sock.h
@@ -150,6 +150,10 @@ typedef __u64 __bitwise __addrpair;
  *      @skc_node: main hash linkage for various protocol lookup tables
  *      @skc_nulls_node: main hash linkage for TCP/UDP/UDP-Lite protocol
  *      @skc_tx_queue_mapping: tx queue number for this connection
+ *      @skc_flags: place holder for sk_flags
+ *              %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
+ *              %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
+ *      @skc_incoming_cpu: record/match cpu processing incoming packets
  *      @skc_refcnt: reference count
  *
  *      This is the minimal network layer representation of sockets, the header
@@ -200,6 +204,16 @@ struct sock_common {
 
         atomic64_t              skc_cookie;
 
+        /* following fields are padding to force
+         * offset(struct sock, sk_refcnt) == 128 on 64bit arches
+         * assuming IPV6 is enabled. We use this padding differently
+         * for different kind of 'sockets'
+         */
+        union {
+                unsigned long   skc_flags;
+                struct sock     *skc_listener; /* request_sock */
+                struct inet_timewait_death_row *skc_tw_dr; /* inet_timewait_sock */
+        };
         /*
          * fields between dontcopy_begin/dontcopy_end
          * are not copied in sock_copy()
@@ -212,9 +226,20 @@ struct sock_common {
                 struct hlist_nulls_node skc_nulls_node;
         };
         int                     skc_tx_queue_mapping;
+        union {
+                int             skc_incoming_cpu;
+                u32             skc_rcv_wnd;
+                u32             skc_tw_rcv_nxt; /* struct tcp_timewait_sock  */
+        };
+
         atomic_t                skc_refcnt;
         /* private: */
         int                     skc_dontcopy_end[0];
+        union {
+                u32             skc_rxhash;
+                u32             skc_window_clamp;
+                u32             skc_tw_snd_nxt; /* struct tcp_timewait_sock */
+        };
         /* public: */
 };
 
@@ -243,8 +268,6 @@ struct cg_proto;
   *     @sk_pacing_rate: Pacing rate (if supported by transport/packet scheduler)
   *     @sk_max_pacing_rate: Maximum pacing rate (%SO_MAX_PACING_RATE)
   *     @sk_sndbuf: size of send buffer in bytes
-  *     @sk_flags: %SO_LINGER (l_onoff), %SO_BROADCAST, %SO_KEEPALIVE,
-  *                %SO_OOBINLINE settings, %SO_TIMESTAMPING settings
   *     @sk_no_check_tx: %SO_NO_CHECK setting, set checksum in TX packets
   *     @sk_no_check_rx: allow zero checksum in RX packets
   *     @sk_route_caps: route capabilities (e.g. %NETIF_F_TSO)
@@ -273,8 +296,6 @@ struct cg_proto;
   *     @sk_rcvlowat: %SO_RCVLOWAT setting
   *     @sk_rcvtimeo: %SO_RCVTIMEO setting
   *     @sk_sndtimeo: %SO_SNDTIMEO setting
-  *     @sk_rxhash: flow hash received from netif layer
-  *     @sk_incoming_cpu: record cpu processing incoming packets
   *     @sk_txhash: computed flow hash for use on transmit
   *     @sk_filter: socket filtering instructions
   *     @sk_timer: sock cleanup timer
@@ -331,6 +352,9 @@ struct sock {
 #define sk_v6_daddr             __sk_common.skc_v6_daddr
 #define sk_v6_rcv_saddr __sk_common.skc_v6_rcv_saddr
 #define sk_cookie               __sk_common.skc_cookie
+#define sk_incoming_cpu         __sk_common.skc_incoming_cpu
+#define sk_flags                __sk_common.skc_flags
+#define sk_rxhash               __sk_common.skc_rxhash
 
         socket_lock_t           sk_lock;
         struct sk_buff_head     sk_receive_queue;
@@ -350,14 +374,6 @@ struct sock {
         } sk_backlog;
 #define sk_rmem_alloc sk_backlog.rmem_alloc
         int                     sk_forward_alloc;
-#ifdef CONFIG_RPS
-        __u32                   sk_rxhash;
-#endif
-        u16                     sk_incoming_cpu;
-        /* 16bit hole
-         * Warned : sk_incoming_cpu can be set from softirq,
-         * Do not use this hole without fully understanding possible issues.
-         */
 
         __u32                   sk_txhash;
 #ifdef CONFIG_NET_RX_BUSY_POLL
@@ -373,7 +389,6 @@ struct sock {
 #ifdef CONFIG_XFRM
         struct xfrm_policy      *sk_policy[2];
 #endif
-        unsigned long           sk_flags;
         struct dst_entry        *sk_rx_dst;
         struct dst_entry __rcu  *sk_dst_cache;
         spinlock_t              sk_dst_lock;
@@ -759,7 +774,7 @@ static inline int sk_memalloc_socks(void)
 
 #endif
 
-static inline gfp_t sk_gfp_atomic(struct sock *sk, gfp_t gfp_mask)
+static inline gfp_t sk_gfp_atomic(const struct sock *sk, gfp_t gfp_mask)
 {
         return GFP_ATOMIC | (sk->sk_allocation & __GFP_MEMALLOC);
 }
@@ -828,6 +843,14 @@ static inline __must_check int sk_add_backlog(struct sock *sk, struct sk_buff *s
         if (sk_rcvqueues_full(sk, limit))
                 return -ENOBUFS;
 
+        /*
+         * If the skb was allocated from pfmemalloc reserves, only
+         * allow SOCK_MEMALLOC sockets to use it as this socket is
+         * helping free memory
+         */
+        if (skb_pfmemalloc(skb) && !sock_flag(sk, SOCK_MEMALLOC))
+                return -ENOMEM;
+
         __sk_add_backlog(sk, skb);
         sk->sk_backlog.len += skb->truesize;
         return 0;
@@ -1514,6 +1537,13 @@ void sock_kfree_s(struct sock *sk, void *mem, int size);
 void sock_kzfree_s(struct sock *sk, void *mem, int size);
 void sk_send_sigurg(struct sock *sk);
 
+struct sockcm_cookie {
+        u32 mark;
+};
+
+int sock_cmsg_send(struct sock *sk, struct msghdr *msg,
+                   struct sockcm_cookie *sockc);
+
 /*
  * Functions to fill in entries in struct proto_ops when a protocol
  * does not implement a particular function.
@@ -1654,12 +1684,16 @@ static inline void sock_graft(struct sock *sk, struct socket *parent)
 kuid_t sock_i_uid(struct sock *sk);
 unsigned long sock_i_ino(struct sock *sk);
 
-static inline void sk_set_txhash(struct sock *sk)
+static inline u32 net_tx_rndhash(void)
 {
-        sk->sk_txhash = prandom_u32();
+        u32 v = prandom_u32();
 
-        if (unlikely(!sk->sk_txhash))
-                sk->sk_txhash = 1;
+        return v ?: 1;
+}
+
+static inline void sk_set_txhash(struct sock *sk)
+{
+        sk->sk_txhash = net_tx_rndhash();
 }
 
 static inline void sk_rethink_txhash(struct sock *sk)
@@ -1917,6 +1951,8 @@ static inline void skb_set_hash_from_sk(struct sk_buff *skb, struct sock *sk)
         }
 }
 
+void skb_set_owner_w(struct sk_buff *skb, struct sock *sk);
+
 /*
  *      Queue a received datagram if it will fit. Stream and sequenced
  *      protocols can't normally use this as they need to fit buffers in
@@ -1925,21 +1961,6 @@ static inline void skb_set_hash_from_sk(struct sk_buff *skb, struct sock *sk)
  *      Inlined as it's very short and called for pretty much every
  *      packet ever received.
  */
-
-static inline void skb_set_owner_w(struct sk_buff *skb, struct sock *sk)
-{
-        skb_orphan(skb);
-        skb->sk = sk;
-        skb->destructor = sock_wfree;
-        skb_set_hash_from_sk(skb, sk);
-        /*
-         * We used to take a refcount on sk, but following operation
-         * is enough to guarantee sk_free() wont free this sock until
-         * all in-flight packets are completed
-         */
-        atomic_add(skb->truesize, &sk->sk_wmem_alloc);
-}
-
 static inline void skb_set_owner_r(struct sk_buff *skb, struct sock *sk)
 {
         skb_orphan(skb);
@@ -2020,7 +2041,7 @@ struct sk_buff *sk_stream_alloc_skb(struct sock *sk, int size, gfp_t gfp,
  */
 static inline struct page_frag *sk_page_frag(struct sock *sk)
 {
-        if (sk->sk_allocation & __GFP_WAIT)
+        if (gfpflags_allow_blocking(sk->sk_allocation))
                 return &current->task_frag;
 
         return &sk->sk_frag;
@@ -2197,6 +2218,39 @@ static inline bool sk_fullsock(const struct sock *sk)
         return (1 << sk->sk_state) & ~(TCPF_TIME_WAIT | TCPF_NEW_SYN_RECV);
 }
 
+/* This helper checks if a socket is a LISTEN or NEW_SYN_RECV
+ * SYNACK messages can be attached to either ones (depending on SYNCOOKIE)
+ */
+static inline bool sk_listener(const struct sock *sk)
+{
+        return (1 << sk->sk_state) & (TCPF_LISTEN | TCPF_NEW_SYN_RECV);
+}
+
+/**
+ * sk_state_load - read sk->sk_state for lockless contexts
+ * @sk: socket pointer
+ *
+ * Paired with sk_state_store(). Used in places we do not hold socket lock :
+ * tcp_diag_get_info(), tcp_get_info(), tcp_poll(), get_tcp4_sock() ...
+ */
+static inline int sk_state_load(const struct sock *sk)
+{
+        return smp_load_acquire(&sk->sk_state);
+}
+
+/**
+ * sk_state_store - update sk->sk_state
+ * @sk: socket pointer
+ * @newstate: new state
+ *
+ * Paired with sk_state_load(). Should be used in contexts where
+ * state change might impact lockless readers.
+ */
+static inline void sk_state_store(struct sock *sk, int newstate)
+{
+        smp_store_release(&sk->sk_state, newstate);
+}
+
 void sock_enable_timestamp(struct sock *sk, int flag);
 int sock_get_timestamp(struct sock *, struct timeval __user *);
 int sock_get_timestampns(struct sock *, struct timespec __user *);