Re: [PATCH v1 26/29] mm: rename PAGE_MAPPING_* to FOLIO_MAPPING_*

[Lorenzo Stoakes <lorenzo.stoakes@oracle.com>]

On Mon, Jun 30, 2025 at 03:00:07PM +0200, David Hildenbrand wrote:
> Now that the mapping flags are only used for folios, let's rename the
> defines.
>
> Reviewed-by: Zi Yan <ziy@nvidia.com>
> Signed-off-by: David Hildenbrand <david@redhat.com>

As the official King of Churn (TM) I approve of this :)

Reviewed-by: Lorenzo Stoakes <lorenzo.stoakes@oracle.com>

> ---
>  fs/proc/page.c             |  4 ++--
>  include/linux/fs.h         |  2 +-
>  include/linux/mm_types.h   |  1 -
>  include/linux/page-flags.h | 20 ++++++++++----------
>  include/linux/pagemap.h    |  2 +-
>  mm/gup.c                   |  4 ++--
>  mm/internal.h              |  2 +-
>  mm/ksm.c                   |  4 ++--
>  mm/rmap.c                  | 16 ++++++++--------
>  mm/util.c                  |  6 +++---
>  10 files changed, 30 insertions(+), 31 deletions(-)
>
> diff --git a/fs/proc/page.c b/fs/proc/page.c
> index 999af26c72985..0cdc78c0d23fa 100644
> --- a/fs/proc/page.c
> +++ b/fs/proc/page.c
> @@ -149,7 +149,7 @@ u64 stable_page_flags(const struct page *page)
>
>  	k = folio->flags;
>  	mapping = (unsigned long)folio->mapping;
> -	is_anon = mapping & PAGE_MAPPING_ANON;
> +	is_anon = mapping & FOLIO_MAPPING_ANON;
>
>  	/*
>  	 * pseudo flags for the well known (anonymous) memory mapped pages
> @@ -158,7 +158,7 @@ u64 stable_page_flags(const struct page *page)
>  		u |= 1 << KPF_MMAP;
>  	if (is_anon) {
>  		u |= 1 << KPF_ANON;
> -		if (mapping & PAGE_MAPPING_KSM)
> +		if (mapping & FOLIO_MAPPING_KSM)
>  			u |= 1 << KPF_KSM;
>  	}
>
> diff --git a/include/linux/fs.h b/include/linux/fs.h
> index c68c9a07cda33..9b0de18746815 100644
> --- a/include/linux/fs.h
> +++ b/include/linux/fs.h
> @@ -526,7 +526,7 @@ struct address_space {
>  	/*
>  	 * On most architectures that alignment is already the case; but
>  	 * must be enforced here for CRIS, to let the least significant bit
> -	 * of struct page's "mapping" pointer be used for PAGE_MAPPING_ANON.
> +	 * of struct folio's "mapping" pointer be used for FOLIO_MAPPING_ANON.
>  	 */
>
>  /* XArray tags, for tagging dirty and writeback pages in the pagecache. */
> diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
> index 804d269a4f5e8..1ec273b066915 100644
> --- a/include/linux/mm_types.h
> +++ b/include/linux/mm_types.h
> @@ -105,7 +105,6 @@ struct page {
>  					unsigned int order;
>  				};
>  			};
> -			/* See page-flags.h for PAGE_MAPPING_FLAGS */
>  			struct address_space *mapping;
>  			union {
>  				pgoff_t __folio_index;		/* Our offset within mapping. */
> diff --git a/include/linux/page-flags.h b/include/linux/page-flags.h
> index b42986a578b71..23b1e458dfeda 100644
> --- a/include/linux/page-flags.h
> +++ b/include/linux/page-flags.h
> @@ -695,10 +695,10 @@ PAGEFLAG_FALSE(VmemmapSelfHosted, vmemmap_self_hosted)
>  /*
>   * On an anonymous folio mapped into a user virtual memory area,
>   * folio->mapping points to its anon_vma, not to a struct address_space;
> - * with the PAGE_MAPPING_ANON bit set to distinguish it.  See rmap.h.
> + * with the FOLIO_MAPPING_ANON bit set to distinguish it.  See rmap.h.
>   *
>   * On an anonymous folio in a VM_MERGEABLE area, if CONFIG_KSM is enabled,
> - * the PAGE_MAPPING_ANON_KSM bit may be set along with the PAGE_MAPPING_ANON
> + * the FOLIO_MAPPING_ANON_KSM bit may be set along with the FOLIO_MAPPING_ANON
>   * bit; and then folio->mapping points, not to an anon_vma, but to a private
>   * structure which KSM associates with that merged folio.  See ksm.h.
>   *
> @@ -713,21 +713,21 @@ PAGEFLAG_FALSE(VmemmapSelfHosted, vmemmap_self_hosted)
>   * false before calling the following functions (e.g., folio_test_anon).
>   * See mm/slab.h.
>   */
> -#define PAGE_MAPPING_ANON	0x1
> -#define PAGE_MAPPING_ANON_KSM	0x2
> -#define PAGE_MAPPING_KSM	(PAGE_MAPPING_ANON | PAGE_MAPPING_ANON_KSM)
> -#define PAGE_MAPPING_FLAGS	(PAGE_MAPPING_ANON | PAGE_MAPPING_ANON_KSM)
> +#define FOLIO_MAPPING_ANON	0x1
> +#define FOLIO_MAPPING_ANON_KSM	0x2
> +#define FOLIO_MAPPING_KSM	(FOLIO_MAPPING_ANON | FOLIO_MAPPING_ANON_KSM)
> +#define FOLIO_MAPPING_FLAGS	(FOLIO_MAPPING_ANON | FOLIO_MAPPING_ANON_KSM)
>
>  static __always_inline bool folio_test_anon(const struct folio *folio)
>  {
> -	return ((unsigned long)folio->mapping & PAGE_MAPPING_ANON) != 0;
> +	return ((unsigned long)folio->mapping & FOLIO_MAPPING_ANON) != 0;
>  }
>
>  static __always_inline bool PageAnonNotKsm(const struct page *page)
>  {
>  	unsigned long flags = (unsigned long)page_folio(page)->mapping;
>
> -	return (flags & PAGE_MAPPING_FLAGS) == PAGE_MAPPING_ANON;
> +	return (flags & FOLIO_MAPPING_FLAGS) == FOLIO_MAPPING_ANON;
>  }
>
>  static __always_inline bool PageAnon(const struct page *page)
> @@ -743,8 +743,8 @@ static __always_inline bool PageAnon(const struct page *page)
>   */
>  static __always_inline bool folio_test_ksm(const struct folio *folio)
>  {
> -	return ((unsigned long)folio->mapping & PAGE_MAPPING_FLAGS) ==
> -				PAGE_MAPPING_KSM;
> +	return ((unsigned long)folio->mapping & FOLIO_MAPPING_FLAGS) ==
> +				FOLIO_MAPPING_KSM;
>  }
>  #else
>  FOLIO_TEST_FLAG_FALSE(ksm)
> diff --git a/include/linux/pagemap.h b/include/linux/pagemap.h
> index e63fbfbd5b0f3..10a222e68b851 100644
> --- a/include/linux/pagemap.h
> +++ b/include/linux/pagemap.h
> @@ -502,7 +502,7 @@ static inline pgoff_t mapping_align_index(struct address_space *mapping,
>  static inline bool mapping_large_folio_support(struct address_space *mapping)
>  {
>  	/* AS_FOLIO_ORDER is only reasonable for pagecache folios */
> -	VM_WARN_ONCE((unsigned long)mapping & PAGE_MAPPING_ANON,
> +	VM_WARN_ONCE((unsigned long)mapping & FOLIO_MAPPING_ANON,
>  			"Anonymous mapping always supports large folio");
>
>  	return mapping_max_folio_order(mapping) > 0;
> diff --git a/mm/gup.c b/mm/gup.c
> index 30d320719fa23..adffe663594dc 100644
> --- a/mm/gup.c
> +++ b/mm/gup.c
> @@ -2804,9 +2804,9 @@ static bool gup_fast_folio_allowed(struct folio *folio, unsigned int flags)
>  		return false;
>
>  	/* Anonymous folios pose no problem. */
> -	mapping_flags = (unsigned long)mapping & PAGE_MAPPING_FLAGS;
> +	mapping_flags = (unsigned long)mapping & FOLIO_MAPPING_FLAGS;
>  	if (mapping_flags)
> -		return mapping_flags & PAGE_MAPPING_ANON;
> +		return mapping_flags & FOLIO_MAPPING_ANON;
>
>  	/*
>  	 * At this point, we know the mapping is non-null and points to an
> diff --git a/mm/internal.h b/mm/internal.h
> index e84217e27778d..c29ddec7ade3d 100644
> --- a/mm/internal.h
> +++ b/mm/internal.h
> @@ -149,7 +149,7 @@ static inline void *folio_raw_mapping(const struct folio *folio)
>  {
>  	unsigned long mapping = (unsigned long)folio->mapping;
>
> -	return (void *)(mapping & ~PAGE_MAPPING_FLAGS);
> +	return (void *)(mapping & ~FOLIO_MAPPING_FLAGS);
>  }
>
>  /*
> diff --git a/mm/ksm.c b/mm/ksm.c
> index ef73b25fd65a6..2b0210d41c553 100644
> --- a/mm/ksm.c
> +++ b/mm/ksm.c
> @@ -893,7 +893,7 @@ static struct folio *ksm_get_folio(struct ksm_stable_node *stable_node,
>  	unsigned long kpfn;
>
>  	expected_mapping = (void *)((unsigned long)stable_node |
> -					PAGE_MAPPING_KSM);
> +					FOLIO_MAPPING_KSM);
>  again:
>  	kpfn = READ_ONCE(stable_node->kpfn); /* Address dependency. */
>  	folio = pfn_folio(kpfn);
> @@ -1070,7 +1070,7 @@ static inline void folio_set_stable_node(struct folio *folio,
>  					 struct ksm_stable_node *stable_node)
>  {
>  	VM_WARN_ON_FOLIO(folio_test_anon(folio) && PageAnonExclusive(&folio->page), folio);
> -	folio->mapping = (void *)((unsigned long)stable_node | PAGE_MAPPING_KSM);
> +	folio->mapping = (void *)((unsigned long)stable_node | FOLIO_MAPPING_KSM);
>  }
>
>  #ifdef CONFIG_SYSFS
> diff --git a/mm/rmap.c b/mm/rmap.c
> index 34311f654d0c2..de14fb6963c24 100644
> --- a/mm/rmap.c
> +++ b/mm/rmap.c
> @@ -503,12 +503,12 @@ struct anon_vma *folio_get_anon_vma(const struct folio *folio)
>
>  	rcu_read_lock();
>  	anon_mapping = (unsigned long)READ_ONCE(folio->mapping);
> -	if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
> +	if ((anon_mapping & FOLIO_MAPPING_FLAGS) != FOLIO_MAPPING_ANON)
>  		goto out;
>  	if (!folio_mapped(folio))
>  		goto out;
>
> -	anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
> +	anon_vma = (struct anon_vma *) (anon_mapping - FOLIO_MAPPING_ANON);
>  	if (!atomic_inc_not_zero(&anon_vma->refcount)) {
>  		anon_vma = NULL;
>  		goto out;
> @@ -550,12 +550,12 @@ struct anon_vma *folio_lock_anon_vma_read(const struct folio *folio,
>  retry:
>  	rcu_read_lock();
>  	anon_mapping = (unsigned long)READ_ONCE(folio->mapping);
> -	if ((anon_mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
> +	if ((anon_mapping & FOLIO_MAPPING_FLAGS) != FOLIO_MAPPING_ANON)
>  		goto out;
>  	if (!folio_mapped(folio))
>  		goto out;
>
> -	anon_vma = (struct anon_vma *) (anon_mapping - PAGE_MAPPING_ANON);
> +	anon_vma = (struct anon_vma *) (anon_mapping - FOLIO_MAPPING_ANON);
>  	root_anon_vma = READ_ONCE(anon_vma->root);
>  	if (down_read_trylock(&root_anon_vma->rwsem)) {
>  		/*
> @@ -1334,9 +1334,9 @@ void folio_move_anon_rmap(struct folio *folio, struct vm_area_struct *vma)
>  	VM_BUG_ON_FOLIO(!folio_test_locked(folio), folio);
>  	VM_BUG_ON_VMA(!anon_vma, vma);
>
> -	anon_vma += PAGE_MAPPING_ANON;
> +	anon_vma += FOLIO_MAPPING_ANON;
>  	/*
> -	 * Ensure that anon_vma and the PAGE_MAPPING_ANON bit are written
> +	 * Ensure that anon_vma and the FOLIO_MAPPING_ANON bit are written
>  	 * simultaneously, so a concurrent reader (eg folio_referenced()'s
>  	 * folio_test_anon()) will not see one without the other.
>  	 */
> @@ -1367,10 +1367,10 @@ static void __folio_set_anon(struct folio *folio, struct vm_area_struct *vma,
>  	/*
>  	 * page_idle does a lockless/optimistic rmap scan on folio->mapping.
>  	 * Make sure the compiler doesn't split the stores of anon_vma and
> -	 * the PAGE_MAPPING_ANON type identifier, otherwise the rmap code
> +	 * the FOLIO_MAPPING_ANON type identifier, otherwise the rmap code
>  	 * could mistake the mapping for a struct address_space and crash.
>  	 */
> -	anon_vma = (void *) anon_vma + PAGE_MAPPING_ANON;
> +	anon_vma = (void *) anon_vma + FOLIO_MAPPING_ANON;
>  	WRITE_ONCE(folio->mapping, (struct address_space *) anon_vma);
>  	folio->index = linear_page_index(vma, address);
>  }
> diff --git a/mm/util.c b/mm/util.c
> index 0b270c43d7d12..20bbfe4ce1b8b 100644
> --- a/mm/util.c
> +++ b/mm/util.c
> @@ -670,9 +670,9 @@ struct anon_vma *folio_anon_vma(const struct folio *folio)
>  {
>  	unsigned long mapping = (unsigned long)folio->mapping;
>
> -	if ((mapping & PAGE_MAPPING_FLAGS) != PAGE_MAPPING_ANON)
> +	if ((mapping & FOLIO_MAPPING_FLAGS) != FOLIO_MAPPING_ANON)
>  		return NULL;
> -	return (void *)(mapping - PAGE_MAPPING_ANON);
> +	return (void *)(mapping - FOLIO_MAPPING_ANON);
>  }
>
>  /**
> @@ -699,7 +699,7 @@ struct address_space *folio_mapping(struct folio *folio)
>  		return swap_address_space(folio->swap);
>
>  	mapping = folio->mapping;
> -	if ((unsigned long)mapping & PAGE_MAPPING_FLAGS)
> +	if ((unsigned long)mapping & FOLIO_MAPPING_FLAGS)
>  		return NULL;
>
>  	return mapping;
> --
> 2.49.0
>