net: use a per task frag allocator

We currently use a per socket order-0 page cache for tcp_sendmsg()
operations.

This page is used to build fragments for skbs.

Its done to increase probability of coalescing small write() into
single segments in skbs still in write queue (not yet sent)

But it wastes a lot of memory for applications handling many mostly
idle sockets, since each socket holds one page in sk->sk_sndmsg_page

Its also quite inefficient to build TSO 64KB packets, because we need
about 16 pages per skb on arches where PAGE_SIZE = 4096, so we hit
page allocator more than wanted.

This patch adds a per task frag allocator and uses bigger pages,
if available. An automatic fallback is done in case of memory pressure.

(up to 32768 bytes per frag, thats order-3 pages on x86)

This increases TCP stream performance by 20% on loopback device,
but also benefits on other network devices, since 8x less frags are
mapped on transmit and unmapped on tx completion. Alexander Duyck
mentioned a probable performance win on systems with IOMMU enabled.

Its possible some SG enabled hardware cant cope with bigger fragments,
but their ndo_start_xmit() should already handle this, splitting a
fragment in sub fragments, since some arches have PAGE_SIZE=65536

Successfully tested on various ethernet devices.
(ixgbe, igb, bnx2x, tg3, mellanox mlx4)

Signed-off-by: Eric Dumazet <edumazet@google.com>
Cc: Ben Hutchings <bhutchings@solarflare.com>
Cc: Vijay Subramanian <subramanian.vijay@gmail.com>
Cc: Alexander Duyck <alexander.h.duyck@intel.com>
Tested-by: Vijay Subramanian <subramanian.vijay@gmail.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

2 files changed, 56 insertions, 30 deletions

diff --git a/net/core/skbuff.c b/net/core/skbuff.c
index fe00d1208167..2ede3cfa8ffa 100644
--- a/net/core/skbuff.c
+++ b/net/core/skbuff.c
@@ -1655,38 +1655,19 @@ static struct page *linear_to_page(struct page *page, unsigned int *len,
                                    unsigned int *offset,
                                    struct sk_buff *skb, struct sock *sk)
 {
-        struct page *p = sk->sk_sndmsg_page;
-        unsigned int off;
+        struct page_frag *pfrag = sk_page_frag(sk);
 
-        if (!p) {
-new_page:
-                p = sk->sk_sndmsg_page = alloc_pages(sk->sk_allocation, 0);
-                if (!p)
-                        return NULL;
-
-                off = sk->sk_sndmsg_off = 0;
-                /* hold one ref to this page until it's full */
-        } else {
-                unsigned int mlen;
-
-                /* If we are the only user of the page, we can reset offset */
-                if (page_count(p) == 1)
-                        sk->sk_sndmsg_off = 0;
-                off = sk->sk_sndmsg_off;
-                mlen = PAGE_SIZE - off;
-                if (mlen < 64 && mlen < *len) {
-                        put_page(p);
-                        goto new_page;
-                }
+        if (!sk_page_frag_refill(sk, pfrag))
+                return NULL;
 
-                *len = min_t(unsigned int, *len, mlen);
-        }
+        *len = min_t(unsigned int, *len, pfrag->size - pfrag->offset);
 
-        memcpy(page_address(p) + off, page_address(page) + *offset, *len);
-        sk->sk_sndmsg_off += *len;
-        *offset = off;
+        memcpy(page_address(pfrag->page) + pfrag->offset,
+               page_address(page) + *offset, *len);
+        *offset = pfrag->offset;
+        pfrag->offset += *len;
 
-        return p;
+        return pfrag->page;
 }
 
 static bool spd_can_coalesce(const struct splice_pipe_desc *spd,
diff --git a/net/core/sock.c b/net/core/sock.c
index 2693f7649222..727114cd6f7e 100644
--- a/net/core/sock.c
+++ b/net/core/sock.c
@@ -1744,6 +1744,45 @@ struct sk_buff *sock_alloc_send_skb(struct sock *sk, unsigned long size,
 }
 EXPORT_SYMBOL(sock_alloc_send_skb);
 
+/* On 32bit arches, an skb frag is limited to 2^15 */
+#define SKB_FRAG_PAGE_ORDER     get_order(32768)
+
+bool sk_page_frag_refill(struct sock *sk, struct page_frag *pfrag)
+{
+        int order;
+
+        if (pfrag->page) {
+                if (atomic_read(&pfrag->page->_count) == 1) {
+                        pfrag->offset = 0;
+                        return true;
+                }
+                if (pfrag->offset < pfrag->size)
+                        return true;
+                put_page(pfrag->page);
+        }
+
+        /* We restrict high order allocations to users that can afford to wait */
+        order = (sk->sk_allocation & __GFP_WAIT) ? SKB_FRAG_PAGE_ORDER : 0;
+
+        do {
+                gfp_t gfp = sk->sk_allocation;
+
+                if (order)
+                        gfp |= __GFP_COMP | __GFP_NOWARN;
+                pfrag->page = alloc_pages(gfp, order);
+                if (likely(pfrag->page)) {
+                        pfrag->offset = 0;
+                        pfrag->size = PAGE_SIZE << order;
+                        return true;
+                }
+        } while (--order >= 0);
+
+        sk_enter_memory_pressure(sk);
+        sk_stream_moderate_sndbuf(sk);
+        return false;
+}
+EXPORT_SYMBOL(sk_page_frag_refill);
+
 static void __lock_sock(struct sock *sk)
         __releases(&sk->sk_lock.slock)
         __acquires(&sk->sk_lock.slock)
@@ -2173,8 +2212,8 @@ void sock_init_data(struct socket *sock, struct sock *sk)
         sk->sk_error_report     =       sock_def_error_report;
         sk->sk_destruct         =       sock_def_destruct;
 
-        sk->sk_sndmsg_page      =       NULL;
-        sk->sk_sndmsg_off       =       0;
+        sk->sk_frag.page        =       NULL;
+        sk->sk_frag.offset      =       0;
         sk->sk_peek_off         =       -1;
 
         sk->sk_peer_pid         =       NULL;
@@ -2417,6 +2456,12 @@ void sk_common_release(struct sock *sk)
         xfrm_sk_free_policy(sk);
 
         sk_refcnt_debug_release(sk);
+
+        if (sk->sk_frag.page) {
+                put_page(sk->sk_frag.page);
+                sk->sk_frag.page = NULL;
+        }
+
         sock_put(sk);
 }
 EXPORT_SYMBOL(sk_common_release);