mm/net: Rename and move page fragment handling from net/ to mm/

This change moves the __alloc_page_frag functionality out of the networking
stack and into the page allocation portion of mm.  The idea it so help make
this maintainable by placing it with other page allocation functions.

Since we are moving it from skbuff.c to page_alloc.c I have also renamed
the basic defines and structure from netdev_alloc_cache to page_frag_cache
to reflect that this is now part of a different kernel subsystem.

I have also added a simple __free_page_frag function which can handle
freeing the frags based on the skb->head pointer.  The model for this is
based off of __free_pages since we don't actually need to deal with all of
the cases that put_page handles.  I incorporated the virt_to_head_page call
and compound_order into the function as it actually allows for a signficant
size reduction by reducing code duplication.

Signed-off-by: Alexander Duyck <alexander.h.duyck@redhat.com>
Signed-off-by: David S. Miller <davem@davemloft.net>

1 files changed, 98 insertions, 0 deletions

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index ebffa0e4a9c0..2fd31aebef30 100644
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -2967,6 +2967,104 @@ void free_pages(unsigned long addr, unsigned int order)
 EXPORT_SYMBOL(free_pages);
 
 /*
+ * Page Fragment:
+ *  An arbitrary-length arbitrary-offset area of memory which resides
+ *  within a 0 or higher order page.  Multiple fragments within that page
+ *  are individually refcounted, in the page's reference counter.
+ *
+ * The page_frag functions below provide a simple allocation framework for
+ * page fragments.  This is used by the network stack and network device
+ * drivers to provide a backing region of memory for use as either an
+ * sk_buff->head, or to be used in the "frags" portion of skb_shared_info.
+ */
+static struct page *__page_frag_refill(struct page_frag_cache *nc,
+                                       gfp_t gfp_mask)
+{
+        struct page *page = NULL;
+        gfp_t gfp = gfp_mask;
+
+#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
+        gfp_mask |= __GFP_COMP | __GFP_NOWARN | __GFP_NORETRY |
+                    __GFP_NOMEMALLOC;
+        page = alloc_pages_node(NUMA_NO_NODE, gfp_mask,
+                                PAGE_FRAG_CACHE_MAX_ORDER);
+        nc->size = page ? PAGE_FRAG_CACHE_MAX_SIZE : PAGE_SIZE;
+#endif
+        if (unlikely(!page))
+                page = alloc_pages_node(NUMA_NO_NODE, gfp, 0);
+
+        nc->va = page ? page_address(page) : NULL;
+
+        return page;
+}
+
+void *__alloc_page_frag(struct page_frag_cache *nc,
+                        unsigned int fragsz, gfp_t gfp_mask)
+{
+        unsigned int size = PAGE_SIZE;
+        struct page *page;
+        int offset;
+
+        if (unlikely(!nc->va)) {
+refill:
+                page = __page_frag_refill(nc, gfp_mask);
+                if (!page)
+                        return NULL;
+
+#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
+                /* if size can vary use size else just use PAGE_SIZE */
+                size = nc->size;
+#endif
+                /* Even if we own the page, we do not use atomic_set().
+                 * This would break get_page_unless_zero() users.
+                 */
+                atomic_add(size - 1, &page->_count);
+
+                /* reset page count bias and offset to start of new frag */
+                nc->pfmemalloc = page->pfmemalloc;
+                nc->pagecnt_bias = size;
+                nc->offset = size;
+        }
+
+        offset = nc->offset - fragsz;
+        if (unlikely(offset < 0)) {
+                page = virt_to_page(nc->va);
+
+                if (!atomic_sub_and_test(nc->pagecnt_bias, &page->_count))
+                        goto refill;
+
+#if (PAGE_SIZE < PAGE_FRAG_CACHE_MAX_SIZE)
+                /* if size can vary use size else just use PAGE_SIZE */
+                size = nc->size;
+#endif
+                /* OK, page count is 0, we can safely set it */
+                atomic_set(&page->_count, size);
+
+                /* reset page count bias and offset to start of new frag */
+                nc->pagecnt_bias = size;
+                offset = size - fragsz;
+        }
+
+        nc->pagecnt_bias--;
+        nc->offset = offset;
+
+        return nc->va + offset;
+}
+EXPORT_SYMBOL(__alloc_page_frag);
+
+/*
+ * Frees a page fragment allocated out of either a compound or order 0 page.
+ */
+void __free_page_frag(void *addr)
+{
+        struct page *page = virt_to_head_page(addr);
+
+        if (unlikely(put_page_testzero(page)))
+                __free_pages_ok(page, compound_order(page));
+}
+EXPORT_SYMBOL(__free_page_frag);
+
+/*
  * alloc_kmem_pages charges newly allocated pages to the kmem resource counter
  * of the current memory cgroup.
  *