mm/page_isolation: remove migratetype parameter from more functions

migratetype is no longer overwritten during pageblock isolation,
start_isolate_page_range(), has_unmovable_pages(), and
set_migratetype_isolate() no longer need which migratetype to restore
during isolation failure.

For has_unmoable_pages(), it needs to know if the isolation is for CMA
allocation, so adding PB_ISOLATE_MODE_CMA_ALLOC provide the information.
At the same time change isolation flags to enum pb_isolate_mode
(PB_ISOLATE_MODE_MEM_OFFLINE, PB_ISOLATE_MODE_CMA_ALLOC,
PB_ISOLATE_MODE_OTHER).  Remove REPORT_FAILURE and check
PB_ISOLATE_MODE_MEM_OFFLINE, since only PB_ISOLATE_MODE_MEM_OFFLINE
reports isolation failures.

alloc_contig_range() no longer needs migratetype.  Replace it with a newly
defined acr_flags_t to tell if an allocation is for CMA.  So does
__alloc_contig_migrate_range().  Add ACR_FLAGS_NONE (set to 0) to indicate
ordinary allocations.

Link: https://lkml.kernel.org/r/20250617021115.2331563-7-ziy@nvidia.com
Signed-off-by: Zi Yan <ziy@nvidia.com>
Reviewed-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: David Hildenbrand <david@redhat.com>
Cc: Baolin Wang <baolin.wang@linux.alibaba.com>
Cc: Brendan Jackman <jackmanb@google.com>
Cc: Johannes Weiner <hannes@cmpxchg.org>
Cc: Kirill A. Shuemov <kirill.shutemov@linux.intel.com>
Cc: Mel Gorman <mgorman@techsingularity.net>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Oscar Salvador <osalvador@suse.de>
Cc: Richard Chang <richardycc@google.com>
Cc: Suren Baghdasaryan <surenb@google.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/drivers/virtio/virtio_mem.c b/drivers/virtio/virtio_mem.c
index 56d0dbe621637cb4be1d134222c287f3cdd8e921..1688ecd69a0445d5c21d108a9a1d60577f96d7ac 100644 (file)
--- a/drivers/virtio/virtio_mem.c
+++ b/drivers/virtio/virtio_mem.c
@@ -1243,7 +1243,7 @@ static int virtio_mem_fake_offline(struct virtio_mem *vm, unsigned long pfn,
                if (atomic_read(&vm->config_changed))
                        return -EAGAIN;
 
-               rc = alloc_contig_range(pfn, pfn + nr_pages, MIGRATE_MOVABLE,
+               rc = alloc_contig_range(pfn, pfn + nr_pages, ACR_FLAGS_NONE,
                                        GFP_KERNEL);
                if (rc == -ENOMEM)
                        /* whoops, out of memory */

diff --git a/include/linux/gfp.h b/include/linux/gfp.h
index be160e8d8bcbdd6acf81b9217546a9d74b3e209c..5ebf26fcdcfa3c813458503f0da988e00f1153fd 100644 (file)
--- a/include/linux/gfp.h
+++ b/include/linux/gfp.h
@@ -423,9 +423,14 @@ static inline bool gfp_compaction_allowed(gfp_t gfp_mask)
 extern gfp_t vma_thp_gfp_mask(struct vm_area_struct *vma);
 
 #ifdef CONFIG_CONTIG_ALLOC
+
+typedef unsigned int __bitwise acr_flags_t;
+#define ACR_FLAGS_NONE ((__force acr_flags_t)0) // ordinary allocation request
+#define ACR_FLAGS_CMA ((__force acr_flags_t)BIT(0)) // allocate for CMA
+
 /* The below functions must be run on a range from a single zone. */
 extern int alloc_contig_range_noprof(unsigned long start, unsigned long end,
-                             unsigned migratetype, gfp_t gfp_mask);
+                                    acr_flags_t alloc_flags, gfp_t gfp_mask);
 #define alloc_contig_range(...)                        alloc_hooks(alloc_contig_range_noprof(__VA_ARGS__))
 
 extern struct page *alloc_contig_pages_noprof(unsigned long nr_pages, gfp_t gfp_mask,

diff --git a/include/linux/page-isolation.h b/include/linux/page-isolation.h
index 7a681a49e73c90a1b84bcc7533244b7412586e13..3e2f960e166ca3b36fc8c374a5b7ff39599eb33b 100644 (file)
--- a/include/linux/page-isolation.h
+++ b/include/linux/page-isolation.h
@@ -38,8 +38,20 @@ static inline void set_pageblock_isolate(struct page *page)
 }
 #endif
 
-#define MEMORY_OFFLINE 0x1
-#define REPORT_FAILURE 0x2
+/*
+ * Pageblock isolation modes:
+ * PB_ISOLATE_MODE_MEM_OFFLINE - isolate to offline (!allocate) memory
+ *                              e.g., skip over PageHWPoison() pages and
+ *                              PageOffline() pages. Unmovable pages will be
+ *                              reported in this mode.
+ * PB_ISOLATE_MODE_CMA_ALLOC   - isolate for CMA allocations
+ * PB_ISOLATE_MODE_OTHER       - isolate for other purposes
+ */
+enum pb_isolate_mode {
+       PB_ISOLATE_MODE_MEM_OFFLINE,
+       PB_ISOLATE_MODE_CMA_ALLOC,
+       PB_ISOLATE_MODE_OTHER,
+};
 
 void __meminit init_pageblock_migratetype(struct page *page,
                                          enum migratetype migratetype,
@@ -49,10 +61,10 @@ bool pageblock_isolate_and_move_free_pages(struct zone *zone, struct page *page)
 bool pageblock_unisolate_and_move_free_pages(struct zone *zone, struct page *page);
 
 int start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
-                            int migratetype, int flags);
+                            enum pb_isolate_mode mode);
 
 void undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn);
 
 int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
-                       int isol_flags);
+                       enum pb_isolate_mode mode);
 #endif

diff --git a/include/trace/events/kmem.h b/include/trace/events/kmem.h
index f74925a6cf694c28432b61a3d709d3b76f2dab1b..efffcf5782172e8901f0ddb63840489cfe3703d1 100644 (file)
--- a/include/trace/events/kmem.h
+++ b/include/trace/events/kmem.h
@@ -304,6 +304,7 @@ TRACE_EVENT(mm_page_alloc_extfrag,
                __entry->change_ownership)
 );
 
+#ifdef CONFIG_CONTIG_ALLOC
 TRACE_EVENT(mm_alloc_contig_migrate_range_info,
 
        TP_PROTO(unsigned long start,
@@ -311,9 +312,9 @@ TRACE_EVENT(mm_alloc_contig_migrate_range_info,
                 unsigned long nr_migrated,
                 unsigned long nr_reclaimed,
                 unsigned long nr_mapped,
-                int migratetype),
+                acr_flags_t alloc_flags),
 
-       TP_ARGS(start, end, nr_migrated, nr_reclaimed, nr_mapped, migratetype),
+       TP_ARGS(start, end, nr_migrated, nr_reclaimed, nr_mapped, alloc_flags),
 
        TP_STRUCT__entry(
                __field(unsigned long, start)
@@ -321,7 +322,7 @@ TRACE_EVENT(mm_alloc_contig_migrate_range_info,
                __field(unsigned long, nr_migrated)
                __field(unsigned long, nr_reclaimed)
                __field(unsigned long, nr_mapped)
-               __field(int, migratetype)
+               __field(acr_flags_t, alloc_flags)
        ),
 
        TP_fast_assign(
@@ -330,17 +331,18 @@ TRACE_EVENT(mm_alloc_contig_migrate_range_info,
                __entry->nr_migrated = nr_migrated;
                __entry->nr_reclaimed = nr_reclaimed;
                __entry->nr_mapped = nr_mapped;
-               __entry->migratetype = migratetype;
+               __entry->alloc_flags = alloc_flags;
        ),
 
-       TP_printk("start=0x%lx end=0x%lx migratetype=%d nr_migrated=%lu nr_reclaimed=%lu nr_mapped=%lu",
+       TP_printk("start=0x%lx end=0x%lx alloc_flags=%d nr_migrated=%lu nr_reclaimed=%lu nr_mapped=%lu",
                  __entry->start,
                  __entry->end,
-                 __entry->migratetype,
+                 __entry->alloc_flags,
                  __entry->nr_migrated,
                  __entry->nr_reclaimed,
                  __entry->nr_mapped)
 );
+#endif
 
 TRACE_EVENT(mm_setup_per_zone_wmarks,
 

diff --git a/mm/cma.c b/mm/cma.c
index bd3772773736775ea2c9fd1d62fc62c6f02940db..c0b2630a1b81a064ce6a06470eaaca6598a020fd 100644 (file)
--- a/mm/cma.c
+++ b/mm/cma.c
@@ -822,7 +822,7 @@ static int cma_range_alloc(struct cma *cma, struct cma_memrange *cmr,
 
                pfn = cmr->base_pfn + (bitmap_no << cma->order_per_bit);
                mutex_lock(&cma->alloc_mutex);
-               ret = alloc_contig_range(pfn, pfn + count, MIGRATE_CMA, gfp);
+               ret = alloc_contig_range(pfn, pfn + count, ACR_FLAGS_CMA, gfp);
                mutex_unlock(&cma->alloc_mutex);
                if (ret == 0) {
                        page = pfn_to_page(pfn);

diff --git a/mm/memory_hotplug.c b/mm/memory_hotplug.c
index 6e3380ad1bf56cb76376f4137b8621824f659837..e4009a44f883e5ee4ca4789f96b6fcc41ff9a1ae 100644 (file)
--- a/mm/memory_hotplug.c
+++ b/mm/memory_hotplug.c
@@ -1962,8 +1962,7 @@ int offline_pages(unsigned long start_pfn, unsigned long nr_pages,
 
        /* set above range as isolated */
        ret = start_isolate_page_range(start_pfn, end_pfn,
-                                      MIGRATE_MOVABLE,
-                                      MEMORY_OFFLINE | REPORT_FAILURE);
+                                      PB_ISOLATE_MODE_MEM_OFFLINE);
        if (ret) {
                reason = "failure to isolate range";
                goto failed_removal_pcplists_disabled;
@@ -2033,7 +2032,8 @@ int offline_pages(unsigned long start_pfn, unsigned long nr_pages,
                        goto failed_removal_isolated;
                }
 
-               ret = test_pages_isolated(start_pfn, end_pfn, MEMORY_OFFLINE);
+               ret = test_pages_isolated(start_pfn, end_pfn,
+                                         PB_ISOLATE_MODE_MEM_OFFLINE);
 
        } while (ret);
 

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 8d4b3f12b9a623e7bc56d8e009a568ba11f1e2c7..4f55f8ed65c7d0cbc80b4767c632ab6f8603e499 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -6693,11 +6693,12 @@ static void alloc_contig_dump_pages(struct list_head *page_list)
 
 /*
  * [start, end) must belong to a single zone.
- * @migratetype: using migratetype to filter the type of migration in
+ * @alloc_flags: using acr_flags_t to filter the type of migration in
  *             trace_mm_alloc_contig_migrate_range_info.
  */
 static int __alloc_contig_migrate_range(struct compact_control *cc,
-               unsigned long start, unsigned long end, int migratetype)
+                                       unsigned long start, unsigned long end,
+                                       acr_flags_t alloc_flags)
 {
        /* This function is based on compact_zone() from compaction.c. */
        unsigned int nr_reclaimed;
@@ -6769,7 +6770,7 @@ static int __alloc_contig_migrate_range(struct compact_control *cc,
                putback_movable_pages(&cc->migratepages);
        }
 
-       trace_mm_alloc_contig_migrate_range_info(start, end, migratetype,
+       trace_mm_alloc_contig_migrate_range_info(start, end, alloc_flags,
                                                 total_migrated,
                                                 total_reclaimed,
                                                 total_mapped);
@@ -6840,10 +6841,7 @@ static int __alloc_contig_verify_gfp_mask(gfp_t gfp_mask, gfp_t *gfp_cc_mask)
  * alloc_contig_range() -- tries to allocate given range of pages
  * @start:     start PFN to allocate
  * @end:       one-past-the-last PFN to allocate
- * @migratetype:       migratetype of the underlying pageblocks (either
- *                     #MIGRATE_MOVABLE or #MIGRATE_CMA).  All pageblocks
- *                     in range must have the same migratetype and it must
- *                     be either of the two.
+ * @alloc_flags:       allocation information
  * @gfp_mask:  GFP mask. Node/zone/placement hints are ignored; only some
  *             action and reclaim modifiers are supported. Reclaim modifiers
  *             control allocation behavior during compaction/migration/reclaim.
@@ -6860,7 +6858,7 @@ static int __alloc_contig_verify_gfp_mask(gfp_t gfp_mask, gfp_t *gfp_cc_mask)
  * need to be freed with free_contig_range().
  */
 int alloc_contig_range_noprof(unsigned long start, unsigned long end,
-                      unsigned migratetype, gfp_t gfp_mask)
+                             acr_flags_t alloc_flags, gfp_t gfp_mask)
 {
        unsigned long outer_start, outer_end;
        int ret = 0;
@@ -6875,6 +6873,9 @@ int alloc_contig_range_noprof(unsigned long start, unsigned long end,
                .alloc_contig = true,
        };
        INIT_LIST_HEAD(&cc.migratepages);
+       enum pb_isolate_mode mode = (alloc_flags & ACR_FLAGS_CMA) ?
+                                           PB_ISOLATE_MODE_CMA_ALLOC :
+                                           PB_ISOLATE_MODE_OTHER;
 
        gfp_mask = current_gfp_context(gfp_mask);
        if (__alloc_contig_verify_gfp_mask(gfp_mask, (gfp_t *)&cc.gfp_mask))
@@ -6901,7 +6902,7 @@ int alloc_contig_range_noprof(unsigned long start, unsigned long end,
         * put back to page allocator so that buddy can use them.
         */
 
-       ret = start_isolate_page_range(start, end, migratetype, 0);
+       ret = start_isolate_page_range(start, end, mode);
        if (ret)
                goto done;
 
@@ -6917,7 +6918,7 @@ int alloc_contig_range_noprof(unsigned long start, unsigned long end,
         * allocated.  So, if we fall through be sure to clear ret so that
         * -EBUSY is not accidentally used or returned to caller.
         */
-       ret = __alloc_contig_migrate_range(&cc, start, end, migratetype);
+       ret = __alloc_contig_migrate_range(&cc, start, end, alloc_flags);
        if (ret && ret != -EBUSY)
                goto done;
 
@@ -6951,7 +6952,7 @@ int alloc_contig_range_noprof(unsigned long start, unsigned long end,
        outer_start = find_large_buddy(start);
 
        /* Make sure the range is really isolated. */
-       if (test_pages_isolated(outer_start, end, 0)) {
+       if (test_pages_isolated(outer_start, end, mode)) {
                ret = -EBUSY;
                goto done;
        }
@@ -6994,8 +6995,8 @@ static int __alloc_contig_pages(unsigned long start_pfn,
 {
        unsigned long end_pfn = start_pfn + nr_pages;
 
-       return alloc_contig_range_noprof(start_pfn, end_pfn, MIGRATE_MOVABLE,
-                                  gfp_mask);
+       return alloc_contig_range_noprof(start_pfn, end_pfn, ACR_FLAGS_NONE,
+                                        gfp_mask);
 }
 
 static bool pfn_range_valid_contig(struct zone *z, unsigned long start_pfn,

diff --git a/mm/page_isolation.c b/mm/page_isolation.c
index 1edfef408faf6ee70ae631c67952623c19a26cab..ece3bfc56bcd52c35cf36c1e6a89347bb60053c2 100644 (file)
--- a/mm/page_isolation.c
+++ b/mm/page_isolation.c
@@ -31,7 +31,7 @@
  *
  */
 static struct page *has_unmovable_pages(unsigned long start_pfn, unsigned long end_pfn,
-                               int migratetype, int flags)
+                               enum pb_isolate_mode mode)
 {
        struct page *page = pfn_to_page(start_pfn);
        struct zone *zone = page_zone(page);
@@ -46,7 +46,7 @@ static struct page *has_unmovable_pages(unsigned long start_pfn, unsigned long e
                 * isolate CMA pageblocks even when they are not movable in fact
                 * so consider them movable here.
                 */
-               if (is_migrate_cma(migratetype))
+               if (mode == PB_ISOLATE_MODE_CMA_ALLOC)
                        return NULL;
 
                return page;
@@ -117,7 +117,7 @@ static struct page *has_unmovable_pages(unsigned long start_pfn, unsigned long e
                 * The HWPoisoned page may be not in buddy system, and
                 * page_count() is not 0.
                 */
-               if ((flags & MEMORY_OFFLINE) && PageHWPoison(page))
+               if ((mode == PB_ISOLATE_MODE_MEM_OFFLINE) && PageHWPoison(page))
                        continue;
 
                /*
@@ -130,7 +130,7 @@ static struct page *has_unmovable_pages(unsigned long start_pfn, unsigned long e
                 * move these pages that still have a reference count > 0.
                 * (false negatives in this function only)
                 */
-               if ((flags & MEMORY_OFFLINE) && PageOffline(page))
+               if ((mode == PB_ISOLATE_MODE_MEM_OFFLINE) && PageOffline(page))
                        continue;
 
                if (__PageMovable(page) || PageLRU(page))
@@ -151,7 +151,7 @@ static struct page *has_unmovable_pages(unsigned long start_pfn, unsigned long e
  * present in [start_pfn, end_pfn). The pageblock must intersect with
  * [start_pfn, end_pfn).
  */
-static int set_migratetype_isolate(struct page *page, int migratetype, int isol_flags,
+static int set_migratetype_isolate(struct page *page, enum pb_isolate_mode mode,
                        unsigned long start_pfn, unsigned long end_pfn)
 {
        struct zone *zone = page_zone(page);
@@ -186,7 +186,7 @@ static int set_migratetype_isolate(struct page *page, int migratetype, int isol_
                                  end_pfn);
 
        unmovable = has_unmovable_pages(check_unmovable_start, check_unmovable_end,
-                       migratetype, isol_flags);
+                       mode);
        if (!unmovable) {
                if (!pageblock_isolate_and_move_free_pages(zone, page)) {
                        spin_unlock_irqrestore(&zone->lock, flags);
@@ -198,7 +198,7 @@ static int set_migratetype_isolate(struct page *page, int migratetype, int isol_
        }
 
        spin_unlock_irqrestore(&zone->lock, flags);
-       if (isol_flags & REPORT_FAILURE) {
+       if (mode == PB_ISOLATE_MODE_MEM_OFFLINE) {
                /*
                 * printk() with zone->lock held will likely trigger a
                 * lockdep splat, so defer it here.
@@ -292,11 +292,10 @@ __first_valid_page(unsigned long pfn, unsigned long nr_pages)
  * isolate_single_pageblock() -- tries to isolate a pageblock that might be
  * within a free or in-use page.
  * @boundary_pfn:              pageblock-aligned pfn that a page might cross
- * @flags:                     isolation flags
+ * @mode:                      isolation mode
  * @isolate_before:    isolate the pageblock before the boundary_pfn
  * @skip_isolation:    the flag to skip the pageblock isolation in second
  *                     isolate_single_pageblock()
- * @migratetype:       migrate type to set in error recovery.
  *
  * Free and in-use pages can be as big as MAX_PAGE_ORDER and contain more than one
  * pageblock. When not all pageblocks within a page are isolated at the same
@@ -311,8 +310,9 @@ __first_valid_page(unsigned long pfn, unsigned long nr_pages)
  * either. The function handles this by splitting the free page or migrating
  * the in-use page then splitting the free page.
  */
-static int isolate_single_pageblock(unsigned long boundary_pfn, int flags,
-               bool isolate_before, bool skip_isolation, int migratetype)
+static int isolate_single_pageblock(unsigned long boundary_pfn,
+                       enum pb_isolate_mode mode, bool isolate_before,
+                       bool skip_isolation)
 {
        unsigned long start_pfn;
        unsigned long isolate_pageblock;
@@ -338,12 +338,11 @@ static int isolate_single_pageblock(unsigned long boundary_pfn, int flags,
                                      zone->zone_start_pfn);
 
        if (skip_isolation) {
-               int mt __maybe_unused = get_pageblock_migratetype(pfn_to_page(isolate_pageblock));
-
-               VM_BUG_ON(!is_migrate_isolate(mt));
+               VM_BUG_ON(!get_pageblock_isolate(pfn_to_page(isolate_pageblock)));
        } else {
-               ret = set_migratetype_isolate(pfn_to_page(isolate_pageblock), migratetype,
-                               flags, isolate_pageblock, isolate_pageblock + pageblock_nr_pages);
+               ret = set_migratetype_isolate(pfn_to_page(isolate_pageblock),
+                               mode, isolate_pageblock,
+                               isolate_pageblock + pageblock_nr_pages);
 
                if (ret)
                        return ret;
@@ -441,14 +440,7 @@ failed:
  * start_isolate_page_range() - mark page range MIGRATE_ISOLATE
  * @start_pfn:         The first PFN of the range to be isolated.
  * @end_pfn:           The last PFN of the range to be isolated.
- * @migratetype:       Migrate type to set in error recovery.
- * @flags:             The following flags are allowed (they can be combined in
- *                     a bit mask)
- *                     MEMORY_OFFLINE - isolate to offline (!allocate) memory
- *                                      e.g., skip over PageHWPoison() pages
- *                                      and PageOffline() pages.
- *                     REPORT_FAILURE - report details about the failure to
- *                     isolate the range
+ * @mode:              isolation mode
  *
  * Making page-allocation-type to be MIGRATE_ISOLATE means free pages in
  * the range will never be allocated. Any free pages and pages freed in the
@@ -481,7 +473,7 @@ failed:
  * Return: 0 on success and -EBUSY if any part of range cannot be isolated.
  */
 int start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
-                            int migratetype, int flags)
+                            enum pb_isolate_mode mode)
 {
        unsigned long pfn;
        struct page *page;
@@ -492,8 +484,8 @@ int start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
        bool skip_isolation = false;
 
        /* isolate [isolate_start, isolate_start + pageblock_nr_pages) pageblock */
-       ret = isolate_single_pageblock(isolate_start, flags, false,
-                       skip_isolation, migratetype);
+       ret = isolate_single_pageblock(isolate_start, mode, false,
+                       skip_isolation);
        if (ret)
                return ret;
 
@@ -501,8 +493,7 @@ int start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
                skip_isolation = true;
 
        /* isolate [isolate_end - pageblock_nr_pages, isolate_end) pageblock */
-       ret = isolate_single_pageblock(isolate_end, flags, true,
-                       skip_isolation, migratetype);
+       ret = isolate_single_pageblock(isolate_end, mode, true, skip_isolation);
        if (ret) {
                unset_migratetype_isolate(pfn_to_page(isolate_start));
                return ret;
@@ -513,8 +504,8 @@ int start_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn,
             pfn < isolate_end - pageblock_nr_pages;
             pfn += pageblock_nr_pages) {
                page = __first_valid_page(pfn, pageblock_nr_pages);
-               if (page && set_migratetype_isolate(page, migratetype, flags,
-                                       start_pfn, end_pfn)) {
+               if (page && set_migratetype_isolate(page, mode, start_pfn,
+                                       end_pfn)) {
                        undo_isolate_page_range(isolate_start, pfn);
                        unset_migratetype_isolate(
                                pfn_to_page(isolate_end - pageblock_nr_pages));
@@ -556,7 +547,7 @@ void undo_isolate_page_range(unsigned long start_pfn, unsigned long end_pfn)
  */
 static unsigned long
 __test_page_isolated_in_pageblock(unsigned long pfn, unsigned long end_pfn,
-                                 int flags)
+                                 enum pb_isolate_mode mode)
 {
        struct page *page;
 
@@ -569,11 +560,12 @@ __test_page_isolated_in_pageblock(unsigned long pfn, unsigned long end_pfn,
                         * simple way to verify that as VM_BUG_ON(), though.
                         */
                        pfn += 1 << buddy_order(page);
-               else if ((flags & MEMORY_OFFLINE) && PageHWPoison(page))
+               else if ((mode == PB_ISOLATE_MODE_MEM_OFFLINE) &&
+                        PageHWPoison(page))
                        /* A HWPoisoned page cannot be also PageBuddy */
                        pfn++;
-               else if ((flags & MEMORY_OFFLINE) && PageOffline(page) &&
-                        !page_count(page))
+               else if ((mode == PB_ISOLATE_MODE_MEM_OFFLINE) &&
+                        PageOffline(page) && !page_count(page))
                        /*
                         * The responsible driver agreed to skip PageOffline()
                         * pages when offlining memory by dropping its
@@ -591,11 +583,11 @@ __test_page_isolated_in_pageblock(unsigned long pfn, unsigned long end_pfn,
  * test_pages_isolated - check if pageblocks in range are isolated
  * @start_pfn:         The first PFN of the isolated range
  * @end_pfn:           The first PFN *after* the isolated range
- * @isol_flags:                Testing mode flags
+ * @mode:              Testing mode
  *
  * This tests if all in the specified range are free.
  *
- * If %MEMORY_OFFLINE is specified in @flags, it will consider
+ * If %PB_ISOLATE_MODE_MEM_OFFLINE specified in @mode, it will consider
  * poisoned and offlined pages free as well.
  *
  * Caller must ensure the requested range doesn't span zones.
@@ -603,7 +595,7 @@ __test_page_isolated_in_pageblock(unsigned long pfn, unsigned long end_pfn,
  * Returns 0 if true, -EBUSY if one or more pages are in use.
  */
 int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
-                       int isol_flags)
+                       enum pb_isolate_mode mode)
 {
        unsigned long pfn, flags;
        struct page *page;
@@ -639,7 +631,7 @@ int test_pages_isolated(unsigned long start_pfn, unsigned long end_pfn,
        /* Check all pages are free or marked as ISOLATED */
        zone = page_zone(page);
        spin_lock_irqsave(&zone->lock, flags);
-       pfn = __test_page_isolated_in_pageblock(start_pfn, end_pfn, isol_flags);
+       pfn = __test_page_isolated_in_pageblock(start_pfn, end_pfn, mode);
        spin_unlock_irqrestore(&zone->lock, flags);
 
        ret = pfn < end_pfn ? -EBUSY : 0;