Re: [PATCH v3 19/26] mm/page_alloc: rename ALLOC_NON_BLOCK back to _HARDER

[Vlastimil Babka (SUSE)]

On 7/27/26 00:22, Brendan Jackman wrote:
> Commit 1ebbb21811b7 ("mm/page_alloc: explicitly define how __GFP_HIGH
> non-blocking allocations accesses reserves") renamed ALLOC_HARDER to
> ALLOC_NON_BLOCK because the former is "a vague description".
> 
> However, vagueness is accurate here, this is a vague flag. It is not set
> for __GFP_NOMEMALLOC. It doesn't really mean "allocate without blocking"
> but rather "allow dipping into atomic reserves, _because_ of the need
> not to block".
> 
> A later commit will need an alloc flag that really means "don't block
> here", so go back to the flag's old name and update the commentary
> to try and give it a slightly clearer meaning.
> 
> Signed-off-by: Brendan Jackman <jackmanb@xxxxxxxxxx>

I wonder if we need to do this, and instead we could repurpose
ALLOC_NON_BLOCK directly. AFAIU it's about removing the side-effect of
gfp_allowed_mask in the next patch. But what would happen if we did that
using the existing ALLOC_NON_BLOCK (or maybe just renamed to ALLOC_NOBLOCK?).

- in __zone_watermark_ok(), ALLOC_NON_BLOCK could now be *not* set in
situations where previously it was set due to gfp_allowed_mask masking out
__GFP_DIRECT_RECLAIM. But it only has an effect on top of __GFP_HIGH (thus
ALLOC_MIN_RESERVE... which seems contradicting the ALLOC_NON_BLOCK
description comment btw). Also __GFP_DIRECT_RECLAIM is only masked out by
GFP_BOOT_MASK when all memory is free, so it's kinda moot?

- in rmqueue_buddy() we allow access to highatomic reserves since
281dd25c1a018. That commit describes GFP_ATOMIC so we could have been
checking ALLOC_MIN_RESERVE. But we can also leave this alone because it
doesn't actually matter when GFP_BOOT_MASK is set, as above.

> ---
>  mm/page_alloc.c | 8 ++++----
>  mm/page_alloc.h | 9 +++++----
>  2 files changed, 9 insertions(+), 8 deletions(-)
> 
> diff --git a/mm/page_alloc.c b/mm/page_alloc.c
> index 30ba61c20209c..fb522a09f2e60 100644
> --- a/mm/page_alloc.c
> +++ b/mm/page_alloc.c
> @@ -3431,7 +3431,7 @@ struct page *rmqueue_buddy(struct zone *preferred_zone, struct zone *zone,
>  			 * reserves as failing now is worse than failing a
>  			 * high-order atomic allocation in the future.
>  			 */
> -			if (!page && (alloc_flags & (ALLOC_OOM|ALLOC_NON_BLOCK)))
> +			if (!page && (alloc_flags & (ALLOC_OOM|ALLOC_HARDER)))
>  				page = __rmqueue_smallest(zone, order, ft_high);
>  
>  			if (!page) {
> @@ -3811,7 +3811,7 @@ bool __zone_watermark_ok(struct zone *z, unsigned int order, unsigned long mark,
>  			 * or (GFP_KERNEL & ~__GFP_DIRECT_RECLAIM) do not get
>  			 * access to the min reserve.
>  			 */
> -			if (alloc_flags & ALLOC_NON_BLOCK)
> +			if (alloc_flags & ALLOC_HARDER)
>  				min -= min / 4;
>  		}
>  
> @@ -4733,7 +4733,7 @@ alloc_flags_nonblocking(gfp_t gfp_mask, unsigned int order)
>  	if (gfp_mask & __GFP_NOMEMALLOC)
>  		return 0;
>  
> -	alloc_flags |= ALLOC_NON_BLOCK;
> +	alloc_flags |= ALLOC_HARDER;
>  
>  	if (order > 0 && (gfp_mask & __GFP_HIGH))
>  		alloc_flags |= ALLOC_HIGHATOMIC;
> @@ -4750,7 +4750,7 @@ alloc_flags_slowpath(gfp_t gfp_mask, unsigned int order)
>  	 * The caller may dip into page reserves a bit more if the caller
>  	 * cannot run direct reclaim, or if the caller has realtime scheduling
>  	 * policy or is asking for __GFP_HIGH memory.  GFP_ATOMIC requests will
> -	 * set both ALLOC_NON_BLOCK and ALLOC_MIN_RESERVE(__GFP_HIGH).
> +	 * set both ALLOC_HARDER and ALLOC_MIN_RESERVE(__GFP_HIGH).
>  	 */
>  	if (gfp_mask & __GFP_HIGH)
>  		alloc_flags |= ALLOC_MIN_RESERVE;
> diff --git a/mm/page_alloc.h b/mm/page_alloc.h
> index fac8e5304bb03..2307b173a459f 100644
> --- a/mm/page_alloc.h
> +++ b/mm/page_alloc.h
> @@ -32,9 +32,10 @@
>  #define ALLOC_OOM		ALLOC_NO_WATERMARKS
>  #endif
>  
> -#define ALLOC_NON_BLOCK		 0x10 /* Caller cannot block. Allow access
> -				       * to 25% of the min watermark or
> -				       * 62.5% if __GFP_HIGH is set.
> +#define ALLOC_HARDER		 0x10 /* Because the caller cannot block,
> +				       * allow access to 25% of the min
> +				       * watermark or 62.5% if __GFP_HIGH is
> +				       * set.
>  				       */
>  #define ALLOC_MIN_RESERVE	 0x20 /* __GFP_HIGH set. Allow access to 50%
>  				       * of the min watermark.
> @@ -76,7 +77,7 @@
>  #endif
>  
>  /* Flags that allow allocations below the min watermark. */
> -#define ALLOC_RESERVES (ALLOC_NON_BLOCK|ALLOC_MIN_RESERVE|ALLOC_HIGHATOMIC|ALLOC_OOM)
> +#define ALLOC_RESERVES (ALLOC_HARDER|ALLOC_MIN_RESERVE|ALLOC_HIGHATOMIC|ALLOC_OOM)
>  
>  /*
>   * Structure for holding the mostly immutable allocation parameters passed
>