mm/page_alloc: add alloc_contig_pages()

HugeTLB helper alloc_gigantic_page() implements fairly generic
allocation method where it scans over various zones looking for a large
contiguous pfn range before trying to allocate it with
alloc_contig_range().

Other than deriving the requested order from 'struct hstate', there is
nothing HugeTLB specific in there.  This can be made available for
general use to allocate contiguous memory which could not have been
allocated through the buddy allocator.

alloc_gigantic_page() has been split carving out actual allocation
method which is then made available via new alloc_contig_pages() helper
wrapped under CONFIG_CONTIG_ALLOC.  All references to 'gigantic' have
been replaced with more generic term 'contig'.  Allocated pages here
should be freed with free_contig_range() or by calling __free_page() on
each allocated page.

Link: http://lkml.kernel.org/r/1571300646-32240-1-git-send-email-anshuman.khandual@arm.com
Signed-off-by: Anshuman Khandual <anshuman.khandual@arm.com>
Acked-by: David Hildenbrand <david@redhat.com>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Mike Kravetz <mike.kravetz@oracle.com>
Cc: Vlastimil Babka <vbabka@suse.cz>
Cc: Michal Hocko <mhocko@suse.com>
Cc: David Rientjes <rientjes@google.com>
Cc: Andrea Arcangeli <aarcange@redhat.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Mike Rapoport <rppt@linux.ibm.com>
Cc: Dan Williams <dan.j.williams@intel.com>
Cc: Pavel Tatashin <pavel.tatashin@microsoft.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: David Hildenbrand <david@redhat.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Signed-off-by: Linus Torvalds <torvalds@linux-foundation.org>

diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index 61f2f6ff94673b0a74d2d7705d87373bfba74fe5..e5b817cb86e7eada6a37233118f29f34bd751cdf 100644 (file)
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -612,6 +612,8 @@ static inline bool pm_suspended_storage(void)
 /* The below functions must be run on a range from a single zone. */
 extern int alloc_contig_range(unsigned long start, unsigned long end,
                              unsigned migratetype, gfp_t gfp_mask);
+extern struct page *alloc_contig_pages(unsigned long nr_pages, gfp_t gfp_mask,
+                                      int nid, nodemask_t *nodemask);
 #endif
 void free_contig_range(unsigned long pfn, unsigned int nr_pages);
 

diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index b45a95363a844a12f54eb904437f3fd562057b50..26b722faf740a438e83b2ad8efee5e7a1c444793 100644 (file)
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1069,85 +1069,12 @@ static void free_gigantic_page(struct page *page, unsigned int order)
 }
 
 #ifdef CONFIG_CONTIG_ALLOC
-static int __alloc_gigantic_page(unsigned long start_pfn,
-                               unsigned long nr_pages, gfp_t gfp_mask)
-{
-       unsigned long end_pfn = start_pfn + nr_pages;
-       return alloc_contig_range(start_pfn, end_pfn, MIGRATE_MOVABLE,
-                                 gfp_mask);
-}
-
-static bool pfn_range_valid_gigantic(struct zone *z,
-                       unsigned long start_pfn, unsigned long nr_pages)
-{
-       unsigned long i, end_pfn = start_pfn + nr_pages;
-       struct page *page;
-
-       for (i = start_pfn; i < end_pfn; i++) {
-               page = pfn_to_online_page(i);
-               if (!page)
-                       return false;
-
-               if (page_zone(page) != z)
-                       return false;
-
-               if (PageReserved(page))
-                       return false;
-
-               if (page_count(page) > 0)
-                       return false;
-
-               if (PageHuge(page))
-                       return false;
-       }
-
-       return true;
-}
-
-static bool zone_spans_last_pfn(const struct zone *zone,
-                       unsigned long start_pfn, unsigned long nr_pages)
-{
-       unsigned long last_pfn = start_pfn + nr_pages - 1;
-       return zone_spans_pfn(zone, last_pfn);
-}
-
 static struct page *alloc_gigantic_page(struct hstate *h, gfp_t gfp_mask,
                int nid, nodemask_t *nodemask)
 {
-       unsigned int order = huge_page_order(h);
-       unsigned long nr_pages = 1 << order;
-       unsigned long ret, pfn, flags;
-       struct zonelist *zonelist;
-       struct zone *zone;
-       struct zoneref *z;
-
-       zonelist = node_zonelist(nid, gfp_mask);
-       for_each_zone_zonelist_nodemask(zone, z, zonelist, gfp_zone(gfp_mask), nodemask) {
-               spin_lock_irqsave(&zone->lock, flags);
+       unsigned long nr_pages = 1UL << huge_page_order(h);
 
-               pfn = ALIGN(zone->zone_start_pfn, nr_pages);
-               while (zone_spans_last_pfn(zone, pfn, nr_pages)) {
-                       if (pfn_range_valid_gigantic(zone, pfn, nr_pages)) {
-                               /*
-                                * We release the zone lock here because
-                                * alloc_contig_range() will also lock the zone
-                                * at some point. If there's an allocation
-                                * spinning on this lock, it may win the race
-                                * and cause alloc_contig_range() to fail...
-                                */
-                               spin_unlock_irqrestore(&zone->lock, flags);
-                               ret = __alloc_gigantic_page(pfn, nr_pages, gfp_mask);
-                               if (!ret)
-                                       return pfn_to_page(pfn);
-                               spin_lock_irqsave(&zone->lock, flags);
-                       }
-                       pfn += nr_pages;
-               }
-
-               spin_unlock_irqrestore(&zone->lock, flags);
-       }
-
-       return NULL;
+       return alloc_contig_pages(nr_pages, gfp_mask, nid, nodemask);
 }
 
 static void prep_new_huge_page(struct hstate *h, struct page *page, int nid);

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index c289b02aaa3b1f5093ef294c44ca59ede78b3809..2e47398ba4985ce7841562e3713e041525612496 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -8502,6 +8502,107 @@ done:
                                pfn_max_align_up(end), migratetype);
        return ret;
 }
+
+static int __alloc_contig_pages(unsigned long start_pfn,
+                               unsigned long nr_pages, gfp_t gfp_mask)
+{
+       unsigned long end_pfn = start_pfn + nr_pages;
+
+       return alloc_contig_range(start_pfn, end_pfn, MIGRATE_MOVABLE,
+                                 gfp_mask);
+}
+
+static bool pfn_range_valid_contig(struct zone *z, unsigned long start_pfn,
+                                  unsigned long nr_pages)
+{
+       unsigned long i, end_pfn = start_pfn + nr_pages;
+       struct page *page;
+
+       for (i = start_pfn; i < end_pfn; i++) {
+               page = pfn_to_online_page(i);
+               if (!page)
+                       return false;
+
+               if (page_zone(page) != z)
+                       return false;
+
+               if (PageReserved(page))
+                       return false;
+
+               if (page_count(page) > 0)
+                       return false;
+
+               if (PageHuge(page))
+                       return false;
+       }
+       return true;
+}
+
+static bool zone_spans_last_pfn(const struct zone *zone,
+                               unsigned long start_pfn, unsigned long nr_pages)
+{
+       unsigned long last_pfn = start_pfn + nr_pages - 1;
+
+       return zone_spans_pfn(zone, last_pfn);
+}
+
+/**
+ * alloc_contig_pages() -- tries to find and allocate contiguous range of pages
+ * @nr_pages:  Number of contiguous pages to allocate
+ * @gfp_mask:  GFP mask to limit search and used during compaction
+ * @nid:       Target node
+ * @nodemask:  Mask for other possible nodes
+ *
+ * This routine is a wrapper around alloc_contig_range(). It scans over zones
+ * on an applicable zonelist to find a contiguous pfn range which can then be
+ * tried for allocation with alloc_contig_range(). This routine is intended
+ * for allocation requests which can not be fulfilled with the buddy allocator.
+ *
+ * The allocated memory is always aligned to a page boundary. If nr_pages is a
+ * power of two then the alignment is guaranteed to be to the given nr_pages
+ * (e.g. 1GB request would be aligned to 1GB).
+ *
+ * Allocated pages can be freed with free_contig_range() or by manually calling
+ * __free_page() on each allocated page.
+ *
+ * Return: pointer to contiguous pages on success, or NULL if not successful.
+ */
+struct page *alloc_contig_pages(unsigned long nr_pages, gfp_t gfp_mask,
+                               int nid, nodemask_t *nodemask)
+{
+       unsigned long ret, pfn, flags;
+       struct zonelist *zonelist;
+       struct zone *zone;
+       struct zoneref *z;
+
+       zonelist = node_zonelist(nid, gfp_mask);
+       for_each_zone_zonelist_nodemask(zone, z, zonelist,
+                                       gfp_zone(gfp_mask), nodemask) {
+               spin_lock_irqsave(&zone->lock, flags);
+
+               pfn = ALIGN(zone->zone_start_pfn, nr_pages);
+               while (zone_spans_last_pfn(zone, pfn, nr_pages)) {
+                       if (pfn_range_valid_contig(zone, pfn, nr_pages)) {
+                               /*
+                                * We release the zone lock here because
+                                * alloc_contig_range() will also lock the zone
+                                * at some point. If there's an allocation
+                                * spinning on this lock, it may win the race
+                                * and cause alloc_contig_range() to fail...
+                                */
+                               spin_unlock_irqrestore(&zone->lock, flags);
+                               ret = __alloc_contig_pages(pfn, nr_pages,
+                                                       gfp_mask);
+                               if (!ret)
+                                       return pfn_to_page(pfn);
+                               spin_lock_irqsave(&zone->lock, flags);
+                       }
+                       pfn += nr_pages;
+               }
+               spin_unlock_irqrestore(&zone->lock, flags);
+       }
+       return NULL;
+}
 #endif /* CONFIG_CONTIG_ALLOC */
 
 void free_contig_range(unsigned long pfn, unsigned int nr_pages)