mm/page_alloc: explicitly record high-order atomic allocations in alloc_flags

[ Upstream commit eb2e2b425c6984ca8034448a3f2c680622bd3d4d ]

A high-order ALLOC_HARDER allocation is assumed to be atomic.  While that
is accurate, it changes later in the series.  In preparation, explicitly
record high-order atomic allocations in gfp_to_alloc_flags().

Link: https://lkml.kernel.org/r/20230113111217.14134-4-mgorman@techsingularity.net
Signed-off-by: Mel Gorman <mgorman@techsingularity.net>
Acked-by: Vlastimil Babka <vbabka@suse.cz>
Acked-by: Michal Hocko <mhocko@suse.com>
Cc: Matthew Wilcox <willy@infradead.org>
Cc: NeilBrown <neilb@suse.de>
Cc: Thierry Reding <thierry.reding@gmail.com>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
Stable-dep-of: 281dd25c1a01 ("mm/page_alloc: let GFP_ATOMIC order-0 allocs access highatomic reserves")
Signed-off-by: Sasha Levin <sashal@kernel.org>

diff --git a/mm/internal.h b/mm/internal.h
index e6c96327b5855ebecac228c3256a951d5a379e1e..136f435e0f1ab0c9a24cc52869137b15eae2390b 100644 (file)
--- a/mm/internal.h
+++ b/mm/internal.h
@@ -603,6 +603,7 @@ unsigned int reclaim_clean_pages_from_list(struct zone *zone,
 #else
 #define ALLOC_NOFRAGMENT         0x0
 #endif
+#define ALLOC_HIGHATOMIC       0x200 /* Allows access to MIGRATE_HIGHATOMIC */
 #define ALLOC_KSWAPD           0x800 /* allow waking of kswapd, __GFP_KSWAPD_RECLAIM set */
 
 enum ttu_flags;

diff --git a/mm/page_alloc.c b/mm/page_alloc.c
index 72835cf4034bcffceb4e9b130eca17b5bbd02d4d..43122de999c4c13694605543b052cc8d390edbe2 100644 (file)
--- a/mm/page_alloc.c
+++ b/mm/page_alloc.c
@@ -3614,10 +3614,20 @@ struct page *rmqueue_buddy(struct zone *preferred_zone, struct zone *zone,
                 * reserved for high-order atomic allocation, so order-0
                 * request should skip it.
                 */
-               if (order > 0 && alloc_flags & ALLOC_HARDER)
+               if (alloc_flags & ALLOC_HIGHATOMIC)
                        page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
                if (!page) {
                        page = __rmqueue(zone, order, migratetype, alloc_flags);
+
+                       /*
+                        * If the allocation fails, allow OOM handling access
+                        * to HIGHATOMIC reserves as failing now is worse than
+                        * failing a high-order atomic allocation in the
+                        * future.
+                        */
+                       if (!page && (alloc_flags & ALLOC_OOM))
+                               page = __rmqueue_smallest(zone, order, MIGRATE_HIGHATOMIC);
+
                        if (!page) {
                                spin_unlock_irqrestore(&zone->lock, flags);
                                return NULL;
@@ -3912,8 +3922,10 @@ bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
                        return true;
                }
 #endif
-               if (alloc_harder && !free_area_empty(area, MIGRATE_HIGHATOMIC))
+               if ((alloc_flags & (ALLOC_HIGHATOMIC|ALLOC_OOM)) &&
+                   !free_area_empty(area, MIGRATE_HIGHATOMIC)) {
                        return true;
+               }
        }
        return false;
 }
@@ -4172,7 +4184,7 @@ try_this_zone:
                         * If this is a high-order atomic allocation then check
                         * if the pageblock should be reserved for the future
                         */
-                       if (unlikely(order && (alloc_flags & ALLOC_HARDER)))
+                       if (unlikely(alloc_flags & ALLOC_HIGHATOMIC))
                                reserve_highatomic_pageblock(page, zone, order);
 
                        return page;
@@ -4691,7 +4703,7 @@ static void wake_all_kswapds(unsigned int order, gfp_t gfp_mask,
 }
 
 static inline unsigned int
-gfp_to_alloc_flags(gfp_t gfp_mask)
+gfp_to_alloc_flags(gfp_t gfp_mask, unsigned int order)
 {
        unsigned int alloc_flags = ALLOC_WMARK_MIN | ALLOC_CPUSET;
 
@@ -4717,8 +4729,13 @@ gfp_to_alloc_flags(gfp_t gfp_mask)
                 * Not worth trying to allocate harder for __GFP_NOMEMALLOC even
                 * if it can't schedule.
                 */
-               if (!(gfp_mask & __GFP_NOMEMALLOC))
+               if (!(gfp_mask & __GFP_NOMEMALLOC)) {
                        alloc_flags |= ALLOC_HARDER;
+
+                       if (order > 0)
+                               alloc_flags |= ALLOC_HIGHATOMIC;
+               }
+
                /*
                 * Ignore cpuset mems for GFP_ATOMIC rather than fail, see the
                 * comment for __cpuset_node_allowed().
@@ -4946,7 +4963,7 @@ restart:
         * kswapd needs to be woken up, and to avoid the cost of setting up
         * alloc_flags precisely. So we do that now.
         */
-       alloc_flags = gfp_to_alloc_flags(gfp_mask);
+       alloc_flags = gfp_to_alloc_flags(gfp_mask, order);
 
        /*
         * We need to recalculate the starting point for the zonelist iterator