Allow huge page allocations to use GFP_HIGH_MOVABLE

Huge pages are not movable so are not allocated from ZONE_MOVABLE.  However,
as ZONE_MOVABLE will always have pages that can be migrated or reclaimed, it
can be used to satisfy hugepage allocations even when the system has been
running a long time.  This allows an administrator to resize the hugepage pool
at runtime depending on the size of ZONE_MOVABLE.

This patch adds a new sysctl called hugepages_treat_as_movable.  When a
non-zero value is written to it, future allocations for the huge page pool
will use ZONE_MOVABLE.  Despite huge pages being non-movable, we do not
introduce additional external fragmentation of note as huge pages are always
the largest contiguous block we care about.

[akpm@linux-foundation.org: various fixes]
Signed-off-by: Mel Gorman <mel@csn.ul.ie>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

1 files changed, 20 insertions, 3 deletions

diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index acc0fb3cf067..58980676b842 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -27,6 +27,9 @@ unsigned long max_huge_pages;
 static struct list_head hugepage_freelists[MAX_NUMNODES];
 static unsigned int nr_huge_pages_node[MAX_NUMNODES];
 static unsigned int free_huge_pages_node[MAX_NUMNODES];
+static gfp_t htlb_alloc_mask = GFP_HIGHUSER;
+unsigned long hugepages_treat_as_movable;
+
 /*
  * Protects updates to hugepage_freelists, nr_huge_pages, and free_huge_pages
  */
@@ -68,12 +71,13 @@ static struct page *dequeue_huge_page(struct vm_area_struct *vma,
 {
         int nid;
         struct page *page = NULL;
-        struct zonelist *zonelist = huge_zonelist(vma, address);
+        struct zonelist *zonelist = huge_zonelist(vma, address,
+                                                htlb_alloc_mask);
         struct zone **z;
 
         for (z = zonelist->zones; *z; z++) {
                 nid = zone_to_nid(*z);
-                if (cpuset_zone_allowed_softwall(*z, GFP_HIGHUSER) &&
+                if (cpuset_zone_allowed_softwall(*z, htlb_alloc_mask) &&
                     !list_empty(&hugepage_freelists[nid]))
                         break;
         }
@@ -113,7 +117,7 @@ static int alloc_fresh_huge_page(void)
         prev_nid = nid;
         spin_unlock(&nid_lock);
 
-        page = alloc_pages_node(nid, GFP_HIGHUSER|__GFP_COMP|__GFP_NOWARN,
+        page = alloc_pages_node(nid, htlb_alloc_mask|__GFP_COMP|__GFP_NOWARN,
                                         HUGETLB_PAGE_ORDER);
         if (page) {
                 set_compound_page_dtor(page, free_huge_page);
@@ -263,6 +267,19 @@ int hugetlb_sysctl_handler(struct ctl_table *table, int write,
         max_huge_pages = set_max_huge_pages(max_huge_pages);
         return 0;
 }
+
+int hugetlb_treat_movable_handler(struct ctl_table *table, int write,
+                        struct file *file, void __user *buffer,
+                        size_t *length, loff_t *ppos)
+{
+        proc_dointvec(table, write, file, buffer, length, ppos);
+        if (hugepages_treat_as_movable)
+                htlb_alloc_mask = GFP_HIGHUSER_MOVABLE;
+        else
+                htlb_alloc_mask = GFP_HIGHUSER;
+        return 0;
+}
+
 #endif /* CONFIG_SYSCTL */
 
 int hugetlb_report_meminfo(char *buf)