* [PATCH 1/6] mm: rename VMA flag helpers to be more readable
2026-03-05 10:50 [PATCH 0/6] mm: vma flag tweaks Lorenzo Stoakes (Oracle)
@ 2026-03-05 10:50 ` Lorenzo Stoakes (Oracle)
2026-03-05 10:50 ` [PATCH 2/6] mm: add vma_desc_test_all() and use it Lorenzo Stoakes (Oracle)
` (4 subsequent siblings)
5 siblings, 0 replies; 10+ messages in thread
From: Lorenzo Stoakes (Oracle) @ 2026-03-05 10:50 UTC (permalink / raw)
To: Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, David Hildenbrand, Konstantin Komarov, Tony Luck,
Reinette Chatre, Dave Martin, James Morse, Babu Moger,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
Jan Kara, Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
On reflection, it's confusing to have vma_flags_test() and
vma_desc_test_flags() test whether any comma-separated VMA flag bit is set,
while also having vma_flags_test_all() and vma_test_all_flags() separately
test whether all flags are set.
Firstly, rename vma_flags_test() to vma_flags_test_any() to eliminate this
confusion.
Secondly, since the VMA descriptor flag functions are becoming rather
cumbersome, prefer vma_desc_test*() to vma_desc_test_flags*(), and also
rename vma_desc_test_flags() to vma_desc_test_any().
Finally, rename vma_test_all_flags() to vma_test_all() to keep the
VMA-specific helper consistent with the VMA descriptor naming convention
and to help avoid confusion vs. vma_flags_test_all().
While we're here, also update whitespace to be consistent in helper
functions.
Suggested-by: Pedro Falcato <pfalcato@suse.de>
Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
---
drivers/char/mem.c | 2 +-
drivers/dax/device.c | 2 +-
fs/erofs/data.c | 4 +--
fs/hugetlbfs/inode.c | 2 +-
fs/ntfs3/file.c | 2 +-
fs/resctrl/pseudo_lock.c | 2 +-
fs/zonefs/file.c | 4 +--
include/linux/dax.h | 4 +--
include/linux/hugetlb_inline.h | 2 +-
include/linux/mm.h | 48 +++++++++++++++++----------------
mm/hugetlb.c | 14 +++++-----
mm/memory.c | 2 +-
mm/secretmem.c | 2 +-
mm/shmem.c | 4 +--
tools/testing/vma/include/dup.h | 20 +++++++-------
tools/testing/vma/tests/vma.c | 28 +++++++++----------
16 files changed, 72 insertions(+), 70 deletions(-)
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index cca4529431f8..5118787d0954 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -520,7 +520,7 @@ static int mmap_zero_prepare(struct vm_area_desc *desc)
#ifndef CONFIG_MMU
return -ENOSYS;
#endif
- if (vma_desc_test_flags(desc, VMA_SHARED_BIT))
+ if (vma_desc_test_any(desc, VMA_SHARED_BIT))
return shmem_zero_setup_desc(desc);
desc->action.success_hook = mmap_zero_private_success;
diff --git a/drivers/dax/device.c b/drivers/dax/device.c
index 528e81240c4d..381021c2e031 100644
--- a/drivers/dax/device.c
+++ b/drivers/dax/device.c
@@ -24,7 +24,7 @@ static int __check_vma(struct dev_dax *dev_dax, vma_flags_t flags,
return -ENXIO;
/* prevent private mappings from being established */
- if (!vma_flags_test(&flags, VMA_MAYSHARE_BIT)) {
+ if (!vma_flags_test_any(&flags, VMA_MAYSHARE_BIT)) {
dev_info_ratelimited(dev,
"%s: %s: fail, attempted private mapping\n",
current->comm, func);
diff --git a/fs/erofs/data.c b/fs/erofs/data.c
index f79ee80627d9..6774d9b5ee82 100644
--- a/fs/erofs/data.c
+++ b/fs/erofs/data.c
@@ -473,8 +473,8 @@ static int erofs_file_mmap_prepare(struct vm_area_desc *desc)
if (!IS_DAX(file_inode(desc->file)))
return generic_file_readonly_mmap_prepare(desc);
- if (vma_desc_test_flags(desc, VMA_SHARED_BIT) &&
- vma_desc_test_flags(desc, VMA_MAYWRITE_BIT))
+ if (vma_desc_test_any(desc, VMA_SHARED_BIT) &&
+ vma_desc_test_any(desc, VMA_MAYWRITE_BIT))
return -EINVAL;
desc->vm_ops = &erofs_dax_vm_ops;
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 2ec3e4231252..079ffaaf1f6c 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -164,7 +164,7 @@ static int hugetlbfs_file_mmap_prepare(struct vm_area_desc *desc)
goto out;
ret = 0;
- if (vma_desc_test_flags(desc, VMA_WRITE_BIT) && inode->i_size < len)
+ if (vma_desc_test_any(desc, VMA_WRITE_BIT) && inode->i_size < len)
i_size_write(inode, len);
out:
inode_unlock(inode);
diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c
index 7eecf1e01f74..c5e2181f9f02 100644
--- a/fs/ntfs3/file.c
+++ b/fs/ntfs3/file.c
@@ -276,7 +276,7 @@ static int ntfs_file_mmap_prepare(struct vm_area_desc *desc)
struct file *file = desc->file;
struct inode *inode = file_inode(file);
struct ntfs_inode *ni = ntfs_i(inode);
- const bool rw = vma_desc_test_flags(desc, VMA_WRITE_BIT);
+ const bool rw = vma_desc_test_any(desc, VMA_WRITE_BIT);
int err;
/* Avoid any operation if inode is bad. */
diff --git a/fs/resctrl/pseudo_lock.c b/fs/resctrl/pseudo_lock.c
index fa3687d69ebd..79a006c6f26c 100644
--- a/fs/resctrl/pseudo_lock.c
+++ b/fs/resctrl/pseudo_lock.c
@@ -1044,7 +1044,7 @@ static int pseudo_lock_dev_mmap_prepare(struct vm_area_desc *desc)
* Ensure changes are carried directly to the memory being mapped,
* do not allow copy-on-write mapping.
*/
- if (!vma_desc_test_flags(desc, VMA_SHARED_BIT)) {
+ if (!vma_desc_test_any(desc, VMA_SHARED_BIT)) {
mutex_unlock(&rdtgroup_mutex);
return -EINVAL;
}
diff --git a/fs/zonefs/file.c b/fs/zonefs/file.c
index 8a7161fc49e5..9f9273ecf71a 100644
--- a/fs/zonefs/file.c
+++ b/fs/zonefs/file.c
@@ -333,8 +333,8 @@ static int zonefs_file_mmap_prepare(struct vm_area_desc *desc)
* ordering between msync() and page cache writeback.
*/
if (zonefs_inode_is_seq(file_inode(file)) &&
- vma_desc_test_flags(desc, VMA_SHARED_BIT) &&
- vma_desc_test_flags(desc, VMA_MAYWRITE_BIT))
+ vma_desc_test_any(desc, VMA_SHARED_BIT) &&
+ vma_desc_test_any(desc, VMA_MAYWRITE_BIT))
return -EINVAL;
file_accessed(file);
diff --git a/include/linux/dax.h b/include/linux/dax.h
index bf103f317cac..535019001577 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -69,7 +69,7 @@ static inline bool daxdev_mapping_supported(const struct vm_area_desc *desc,
const struct inode *inode,
struct dax_device *dax_dev)
{
- if (!vma_desc_test_flags(desc, VMA_SYNC_BIT))
+ if (!vma_desc_test_any(desc, VMA_SYNC_BIT))
return true;
if (!IS_DAX(inode))
return false;
@@ -115,7 +115,7 @@ static inline bool daxdev_mapping_supported(const struct vm_area_desc *desc,
const struct inode *inode,
struct dax_device *dax_dev)
{
- return !vma_desc_test_flags(desc, VMA_SYNC_BIT);
+ return !vma_desc_test_any(desc, VMA_SYNC_BIT);
}
static inline size_t dax_recovery_write(struct dax_device *dax_dev,
pgoff_t pgoff, void *addr, size_t bytes, struct iov_iter *i)
diff --git a/include/linux/hugetlb_inline.h b/include/linux/hugetlb_inline.h
index 593f5d4e108b..84afc3c3e2e4 100644
--- a/include/linux/hugetlb_inline.h
+++ b/include/linux/hugetlb_inline.h
@@ -13,7 +13,7 @@ static inline bool is_vm_hugetlb_flags(vm_flags_t vm_flags)
static inline bool is_vma_hugetlb_flags(const vma_flags_t *flags)
{
- return vma_flags_test(flags, VMA_HUGETLB_BIT);
+ return vma_flags_test_any(flags, VMA_HUGETLB_BIT);
}
#else
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 1e2af6810f96..db738a567637 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1063,7 +1063,7 @@ static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits)
(const vma_flag_t []){__VA_ARGS__})
/* Test each of to_test flags in flags, non-atomically. */
-static __always_inline bool vma_flags_test_mask(const vma_flags_t *flags,
+static __always_inline bool vma_flags_test_any_mask(const vma_flags_t *flags,
vma_flags_t to_test)
{
const unsigned long *bitmap = flags->__vma_flags;
@@ -1075,10 +1075,10 @@ static __always_inline bool vma_flags_test_mask(const vma_flags_t *flags,
/*
* Test whether any specified VMA flag is set, e.g.:
*
- * if (vma_flags_test(flags, VMA_READ_BIT, VMA_MAYREAD_BIT)) { ... }
+ * if (vma_flags_test_any(flags, VMA_READ_BIT, VMA_MAYREAD_BIT)) { ... }
*/
-#define vma_flags_test(flags, ...) \
- vma_flags_test_mask(flags, mk_vma_flags(__VA_ARGS__))
+#define vma_flags_test_any(flags, ...) \
+ vma_flags_test_any_mask(flags, mk_vma_flags(__VA_ARGS__))
/* Test that ALL of the to_test flags are set, non-atomically. */
static __always_inline bool vma_flags_test_all_mask(const vma_flags_t *flags,
@@ -1099,7 +1099,8 @@ static __always_inline bool vma_flags_test_all_mask(const vma_flags_t *flags,
vma_flags_test_all_mask(flags, mk_vma_flags(__VA_ARGS__))
/* Set each of the to_set flags in flags, non-atomically. */
-static __always_inline void vma_flags_set_mask(vma_flags_t *flags, vma_flags_t to_set)
+static __always_inline void vma_flags_set_mask(vma_flags_t *flags,
+ vma_flags_t to_set)
{
unsigned long *bitmap = flags->__vma_flags;
const unsigned long *bitmap_to_set = to_set.__vma_flags;
@@ -1116,7 +1117,8 @@ static __always_inline void vma_flags_set_mask(vma_flags_t *flags, vma_flags_t t
vma_flags_set_mask(flags, mk_vma_flags(__VA_ARGS__))
/* Clear all of the to-clear flags in flags, non-atomically. */
-static __always_inline void vma_flags_clear_mask(vma_flags_t *flags, vma_flags_t to_clear)
+static __always_inline void vma_flags_clear_mask(vma_flags_t *flags,
+ vma_flags_t to_clear)
{
unsigned long *bitmap = flags->__vma_flags;
const unsigned long *bitmap_to_clear = to_clear.__vma_flags;
@@ -1138,8 +1140,8 @@ static __always_inline void vma_flags_clear_mask(vma_flags_t *flags, vma_flags_t
* Note: appropriate locks must be held, this function does not acquire them for
* you.
*/
-static inline bool vma_test_all_flags_mask(const struct vm_area_struct *vma,
- vma_flags_t flags)
+static inline bool vma_test_all_mask(const struct vm_area_struct *vma,
+ vma_flags_t flags)
{
return vma_flags_test_all_mask(&vma->flags, flags);
}
@@ -1147,10 +1149,10 @@ static inline bool vma_test_all_flags_mask(const struct vm_area_struct *vma,
/*
* Helper macro for checking that ALL specified flags are set in a VMA, e.g.:
*
- * if (vma_test_all_flags(vma, VMA_READ_BIT, VMA_MAYREAD_BIT) { ... }
+ * if (vma_test_all(vma, VMA_READ_BIT, VMA_MAYREAD_BIT) { ... }
*/
-#define vma_test_all_flags(vma, ...) \
- vma_test_all_flags_mask(vma, mk_vma_flags(__VA_ARGS__))
+#define vma_test_all(vma, ...) \
+ vma_test_all_mask(vma, mk_vma_flags(__VA_ARGS__))
/*
* Helper to set all VMA flags in a VMA.
@@ -1159,7 +1161,7 @@ static inline bool vma_test_all_flags_mask(const struct vm_area_struct *vma,
* you.
*/
static inline void vma_set_flags_mask(struct vm_area_struct *vma,
- vma_flags_t flags)
+ vma_flags_t flags)
{
vma_flags_set_mask(&vma->flags, flags);
}
@@ -1177,25 +1179,25 @@ static inline void vma_set_flags_mask(struct vm_area_struct *vma,
vma_set_flags_mask(vma, mk_vma_flags(__VA_ARGS__))
/* Helper to test all VMA flags in a VMA descriptor. */
-static inline bool vma_desc_test_flags_mask(const struct vm_area_desc *desc,
- vma_flags_t flags)
+static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
+ vma_flags_t flags)
{
- return vma_flags_test_mask(&desc->vma_flags, flags);
+ return vma_flags_test_any_mask(&desc->vma_flags, flags);
}
/*
* Helper macro for testing VMA flags for an input pointer to a struct
* vm_area_desc object describing a proposed VMA, e.g.:
*
- * if (vma_desc_test_flags(desc, VMA_IO_BIT, VMA_PFNMAP_BIT,
+ * if (vma_desc_test_any(desc, VMA_IO_BIT, VMA_PFNMAP_BIT,
* VMA_DONTEXPAND_BIT, VMA_DONTDUMP_BIT)) { ... }
*/
-#define vma_desc_test_flags(desc, ...) \
- vma_desc_test_flags_mask(desc, mk_vma_flags(__VA_ARGS__))
+#define vma_desc_test_any(desc, ...) \
+ vma_desc_test_any_mask(desc, mk_vma_flags(__VA_ARGS__))
/* Helper to set all VMA flags in a VMA descriptor. */
static inline void vma_desc_set_flags_mask(struct vm_area_desc *desc,
- vma_flags_t flags)
+ vma_flags_t flags)
{
vma_flags_set_mask(&desc->vma_flags, flags);
}
@@ -1212,7 +1214,7 @@ static inline void vma_desc_set_flags_mask(struct vm_area_desc *desc,
/* Helper to clear all VMA flags in a VMA descriptor. */
static inline void vma_desc_clear_flags_mask(struct vm_area_desc *desc,
- vma_flags_t flags)
+ vma_flags_t flags)
{
vma_flags_clear_mask(&desc->vma_flags, flags);
}
@@ -1937,8 +1939,8 @@ static inline bool vma_desc_is_cow_mapping(struct vm_area_desc *desc)
{
const vma_flags_t *flags = &desc->vma_flags;
- return vma_flags_test(flags, VMA_MAYWRITE_BIT) &&
- !vma_flags_test(flags, VMA_SHARED_BIT);
+ return vma_flags_test_any(flags, VMA_MAYWRITE_BIT) &&
+ !vma_flags_test_any(flags, VMA_SHARED_BIT);
}
#ifndef CONFIG_MMU
@@ -1957,7 +1959,7 @@ static inline bool is_nommu_shared_mapping(vm_flags_t flags)
static inline bool is_nommu_shared_vma_flags(const vma_flags_t *flags)
{
- return vma_flags_test(flags, VMA_MAYSHARE_BIT, VMA_MAYOVERLAY_BIT);
+ return vma_flags_test_any(flags, VMA_MAYSHARE_BIT, VMA_MAYOVERLAY_BIT);
}
#endif
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 327eaa4074d3..8286c5db2c12 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1194,7 +1194,7 @@ static void set_vma_resv_flags(struct vm_area_struct *vma, unsigned long flags)
static void set_vma_desc_resv_map(struct vm_area_desc *desc, struct resv_map *map)
{
VM_WARN_ON_ONCE(!is_vma_hugetlb_flags(&desc->vma_flags));
- VM_WARN_ON_ONCE(vma_desc_test_flags(desc, VMA_MAYSHARE_BIT));
+ VM_WARN_ON_ONCE(vma_desc_test_any(desc, VMA_MAYSHARE_BIT));
desc->private_data = map;
}
@@ -1202,7 +1202,7 @@ static void set_vma_desc_resv_map(struct vm_area_desc *desc, struct resv_map *ma
static void set_vma_desc_resv_flags(struct vm_area_desc *desc, unsigned long flags)
{
VM_WARN_ON_ONCE(!is_vma_hugetlb_flags(&desc->vma_flags));
- VM_WARN_ON_ONCE(vma_desc_test_flags(desc, VMA_MAYSHARE_BIT));
+ VM_WARN_ON_ONCE(vma_desc_test_any(desc, VMA_MAYSHARE_BIT));
desc->private_data = (void *)((unsigned long)desc->private_data | flags);
}
@@ -6591,7 +6591,7 @@ long hugetlb_reserve_pages(struct inode *inode,
* attempt will be made for VM_NORESERVE to allocate a page
* without using reserves
*/
- if (vma_flags_test(&vma_flags, VMA_NORESERVE_BIT))
+ if (vma_flags_test_any(&vma_flags, VMA_NORESERVE_BIT))
return 0;
/*
@@ -6600,7 +6600,7 @@ long hugetlb_reserve_pages(struct inode *inode,
* to reserve the full area even if read-only as mprotect() may be
* called to make the mapping read-write. Assume !desc is a shm mapping
*/
- if (!desc || vma_desc_test_flags(desc, VMA_MAYSHARE_BIT)) {
+ if (!desc || vma_desc_test_any(desc, VMA_MAYSHARE_BIT)) {
/*
* resv_map can not be NULL as hugetlb_reserve_pages is only
* called for inodes for which resv_maps were created (see
@@ -6634,7 +6634,7 @@ long hugetlb_reserve_pages(struct inode *inode,
if (err < 0)
goto out_err;
- if (desc && !vma_desc_test_flags(desc, VMA_MAYSHARE_BIT) && h_cg) {
+ if (desc && !vma_desc_test_any(desc, VMA_MAYSHARE_BIT) && h_cg) {
/* For private mappings, the hugetlb_cgroup uncharge info hangs
* of the resv_map.
*/
@@ -6671,7 +6671,7 @@ long hugetlb_reserve_pages(struct inode *inode,
* consumed reservations are stored in the map. Hence, nothing
* else has to be done for private mappings here
*/
- if (!desc || vma_desc_test_flags(desc, VMA_MAYSHARE_BIT)) {
+ if (!desc || vma_desc_test_any(desc, VMA_MAYSHARE_BIT)) {
add = region_add(resv_map, from, to, regions_needed, h, h_cg);
if (unlikely(add < 0)) {
@@ -6735,7 +6735,7 @@ long hugetlb_reserve_pages(struct inode *inode,
hugetlb_cgroup_uncharge_cgroup_rsvd(hstate_index(h),
chg * pages_per_huge_page(h), h_cg);
out_err:
- if (!desc || vma_desc_test_flags(desc, VMA_MAYSHARE_BIT))
+ if (!desc || vma_desc_test_any(desc, VMA_MAYSHARE_BIT))
/* Only call region_abort if the region_chg succeeded but the
* region_add failed or didn't run.
*/
diff --git a/mm/memory.c b/mm/memory.c
index 9385842c3503..1d321acb1e50 100644
--- a/mm/memory.c
+++ b/mm/memory.c
@@ -2969,7 +2969,7 @@ static int remap_pfn_range_internal(struct vm_area_struct *vma, unsigned long ad
if (WARN_ON_ONCE(!PAGE_ALIGNED(addr)))
return -EINVAL;
- VM_WARN_ON_ONCE(!vma_test_all_flags_mask(vma, VMA_REMAP_FLAGS));
+ VM_WARN_ON_ONCE(!vma_test_all_mask(vma, VMA_REMAP_FLAGS));
BUG_ON(addr >= end);
pfn -= addr >> PAGE_SHIFT;
diff --git a/mm/secretmem.c b/mm/secretmem.c
index 11a779c812a7..5f57ac4720d3 100644
--- a/mm/secretmem.c
+++ b/mm/secretmem.c
@@ -122,7 +122,7 @@ static int secretmem_mmap_prepare(struct vm_area_desc *desc)
{
const unsigned long len = vma_desc_size(desc);
- if (!vma_desc_test_flags(desc, VMA_SHARED_BIT, VMA_MAYSHARE_BIT))
+ if (!vma_desc_test_any(desc, VMA_SHARED_BIT, VMA_MAYSHARE_BIT))
return -EINVAL;
vma_desc_set_flags(desc, VMA_LOCKED_BIT, VMA_DONTDUMP_BIT);
diff --git a/mm/shmem.c b/mm/shmem.c
index 5e7dcf5bc5d3..965a8908200b 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -3086,7 +3086,7 @@ static struct inode *__shmem_get_inode(struct mnt_idmap *idmap,
spin_lock_init(&info->lock);
atomic_set(&info->stop_eviction, 0);
info->seals = F_SEAL_SEAL;
- info->flags = vma_flags_test(&flags, VMA_NORESERVE_BIT)
+ info->flags = vma_flags_test_any(&flags, VMA_NORESERVE_BIT)
? SHMEM_F_NORESERVE : 0;
info->i_crtime = inode_get_mtime(inode);
info->fsflags = (dir == NULL) ? 0 :
@@ -5827,7 +5827,7 @@ static struct file *__shmem_file_setup(struct vfsmount *mnt, const char *name,
unsigned int i_flags)
{
const unsigned long shmem_flags =
- vma_flags_test(&flags, VMA_NORESERVE_BIT) ? SHMEM_F_NORESERVE : 0;
+ vma_flags_test_any(&flags, VMA_NORESERVE_BIT) ? SHMEM_F_NORESERVE : 0;
struct inode *inode;
struct file *res;
diff --git a/tools/testing/vma/include/dup.h b/tools/testing/vma/include/dup.h
index 3078ff1487d3..c46b523e428d 100644
--- a/tools/testing/vma/include/dup.h
+++ b/tools/testing/vma/include/dup.h
@@ -843,7 +843,7 @@ static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits);
#define mk_vma_flags(...) __mk_vma_flags(COUNT_ARGS(__VA_ARGS__), \
(const vma_flag_t []){__VA_ARGS__})
-static __always_inline bool vma_flags_test_mask(const vma_flags_t *flags,
+static __always_inline bool vma_flags_test_any_mask(const vma_flags_t *flags,
vma_flags_t to_test)
{
const unsigned long *bitmap = flags->__vma_flags;
@@ -852,8 +852,8 @@ static __always_inline bool vma_flags_test_mask(const vma_flags_t *flags,
return bitmap_intersects(bitmap_to_test, bitmap, NUM_VMA_FLAG_BITS);
}
-#define vma_flags_test(flags, ...) \
- vma_flags_test_mask(flags, mk_vma_flags(__VA_ARGS__))
+#define vma_flags_test_any(flags, ...) \
+ vma_flags_test_any_mask(flags, mk_vma_flags(__VA_ARGS__))
static __always_inline bool vma_flags_test_all_mask(const vma_flags_t *flags,
vma_flags_t to_test)
@@ -889,14 +889,14 @@ static __always_inline void vma_flags_clear_mask(vma_flags_t *flags, vma_flags_t
#define vma_flags_clear(flags, ...) \
vma_flags_clear_mask(flags, mk_vma_flags(__VA_ARGS__))
-static inline bool vma_test_all_flags_mask(const struct vm_area_struct *vma,
+static inline bool vma_test_all_mask(const struct vm_area_struct *vma,
vma_flags_t flags)
{
return vma_flags_test_all_mask(&vma->flags, flags);
}
-#define vma_test_all_flags(vma, ...) \
- vma_test_all_flags_mask(vma, mk_vma_flags(__VA_ARGS__))
+#define vma_test_all(vma, ...) \
+ vma_test_all_mask(vma, mk_vma_flags(__VA_ARGS__))
static inline bool is_shared_maywrite_vm_flags(vm_flags_t vm_flags)
{
@@ -913,14 +913,14 @@ static inline void vma_set_flags_mask(struct vm_area_struct *vma,
#define vma_set_flags(vma, ...) \
vma_set_flags_mask(vma, mk_vma_flags(__VA_ARGS__))
-static inline bool vma_desc_test_flags_mask(const struct vm_area_desc *desc,
+static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
vma_flags_t flags)
{
- return vma_flags_test_mask(&desc->vma_flags, flags);
+ return vma_flags_test_any_mask(&desc->vma_flags, flags);
}
-#define vma_desc_test_flags(desc, ...) \
- vma_desc_test_flags_mask(desc, mk_vma_flags(__VA_ARGS__))
+#define vma_desc_test_any(desc, ...) \
+ vma_desc_test_any_mask(desc, mk_vma_flags(__VA_ARGS__))
static inline void vma_desc_set_flags_mask(struct vm_area_desc *desc,
vma_flags_t flags)
diff --git a/tools/testing/vma/tests/vma.c b/tools/testing/vma/tests/vma.c
index c54ffc954f11..f031e6dfb474 100644
--- a/tools/testing/vma/tests/vma.c
+++ b/tools/testing/vma/tests/vma.c
@@ -159,8 +159,8 @@ static bool test_vma_flags_word(void)
return true;
}
-/* Ensure that vma_flags_test() and friends works correctly. */
-static bool test_vma_flags_test(void)
+/* Ensure that vma_flags_test_any() and friends works correctly. */
+static bool test_vma_flags_test_any(void)
{
const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
VMA_EXEC_BIT, 64, 65);
@@ -171,16 +171,16 @@ static bool test_vma_flags_test(void)
desc.vma_flags = flags;
#define do_test(...) \
- ASSERT_TRUE(vma_flags_test(&flags, __VA_ARGS__)); \
- ASSERT_TRUE(vma_desc_test_flags(&desc, __VA_ARGS__))
+ ASSERT_TRUE(vma_flags_test_any(&flags, __VA_ARGS__)); \
+ ASSERT_TRUE(vma_desc_test_any(&desc, __VA_ARGS__))
#define do_test_all_true(...) \
ASSERT_TRUE(vma_flags_test_all(&flags, __VA_ARGS__)); \
- ASSERT_TRUE(vma_test_all_flags(&vma, __VA_ARGS__))
+ ASSERT_TRUE(vma_test_all(&vma, __VA_ARGS__))
#define do_test_all_false(...) \
ASSERT_FALSE(vma_flags_test_all(&flags, __VA_ARGS__)); \
- ASSERT_FALSE(vma_test_all_flags(&vma, __VA_ARGS__))
+ ASSERT_FALSE(vma_test_all(&vma, __VA_ARGS__))
/*
* Testing for some flags that are present, some that are not - should
@@ -200,7 +200,7 @@ static bool test_vma_flags_test(void)
* Check _mask variant. We don't need to test extensively as macro
* helper is the equivalent.
*/
- ASSERT_TRUE(vma_flags_test_mask(&flags, flags));
+ ASSERT_TRUE(vma_flags_test_any_mask(&flags, flags));
ASSERT_TRUE(vma_flags_test_all_mask(&flags, flags));
/* Single bits. */
@@ -268,9 +268,9 @@ static bool test_vma_flags_clear(void)
vma_flags_clear_mask(&flags, mask);
vma_flags_clear_mask(&vma.flags, mask);
vma_desc_clear_flags_mask(&desc, mask);
- ASSERT_FALSE(vma_flags_test(&flags, VMA_EXEC_BIT, 64));
- ASSERT_FALSE(vma_flags_test(&vma.flags, VMA_EXEC_BIT, 64));
- ASSERT_FALSE(vma_desc_test_flags(&desc, VMA_EXEC_BIT, 64));
+ ASSERT_FALSE(vma_flags_test_any(&flags, VMA_EXEC_BIT, 64));
+ ASSERT_FALSE(vma_flags_test_any(&vma.flags, VMA_EXEC_BIT, 64));
+ ASSERT_FALSE(vma_desc_test_any(&desc, VMA_EXEC_BIT, 64));
/* Reset. */
vma_flags_set(&flags, VMA_EXEC_BIT, 64);
vma_set_flags(&vma, VMA_EXEC_BIT, 64);
@@ -284,9 +284,9 @@ static bool test_vma_flags_clear(void)
vma_flags_clear(&flags, __VA_ARGS__); \
vma_flags_clear(&vma.flags, __VA_ARGS__); \
vma_desc_clear_flags(&desc, __VA_ARGS__); \
- ASSERT_FALSE(vma_flags_test(&flags, __VA_ARGS__)); \
- ASSERT_FALSE(vma_flags_test(&vma.flags, __VA_ARGS__)); \
- ASSERT_FALSE(vma_desc_test_flags(&desc, __VA_ARGS__)); \
+ ASSERT_FALSE(vma_flags_test_any(&flags, __VA_ARGS__)); \
+ ASSERT_FALSE(vma_flags_test_any(&vma.flags, __VA_ARGS__)); \
+ ASSERT_FALSE(vma_desc_test_any(&desc, __VA_ARGS__)); \
vma_flags_set(&flags, __VA_ARGS__); \
vma_set_flags(&vma, __VA_ARGS__); \
vma_desc_set_flags(&desc, __VA_ARGS__)
@@ -334,6 +334,6 @@ static void run_vma_tests(int *num_tests, int *num_fail)
TEST(vma_flags_unchanged);
TEST(vma_flags_cleared);
TEST(vma_flags_word);
- TEST(vma_flags_test);
+ TEST(vma_flags_test_any);
TEST(vma_flags_clear);
}
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH 2/6] mm: add vma_desc_test_all() and use it
2026-03-05 10:50 [PATCH 0/6] mm: vma flag tweaks Lorenzo Stoakes (Oracle)
2026-03-05 10:50 ` [PATCH 1/6] mm: rename VMA flag helpers to be more readable Lorenzo Stoakes (Oracle)
@ 2026-03-05 10:50 ` Lorenzo Stoakes (Oracle)
2026-03-05 10:50 ` [PATCH 3/6] mm: always inline __mk_vma_flags() and invoked functions Lorenzo Stoakes (Oracle)
` (3 subsequent siblings)
5 siblings, 0 replies; 10+ messages in thread
From: Lorenzo Stoakes (Oracle) @ 2026-03-05 10:50 UTC (permalink / raw)
To: Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, David Hildenbrand, Konstantin Komarov, Tony Luck,
Reinette Chatre, Dave Martin, James Morse, Babu Moger,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
Jan Kara, Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
erofs and zonefs are using vma_desc_test_any() twice to check whether all
of VMA_SHARED_BIT and VMA_MAYWRITE_BIT are set, this is silly, so add
vma_desc_test_all() to test all flags and update erofs and zonefs to use
it.
While we're here, update the helper function comments to be more
consistent.
Also add the same to the VMA test headers.
Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
---
fs/erofs/data.c | 3 +--
fs/zonefs/file.c | 3 +--
include/linux/mm.h | 24 ++++++++++++++++++++----
tools/testing/vma/include/dup.h | 9 +++++++++
4 files changed, 31 insertions(+), 8 deletions(-)
diff --git a/fs/erofs/data.c b/fs/erofs/data.c
index 6774d9b5ee82..b33dd4d8710e 100644
--- a/fs/erofs/data.c
+++ b/fs/erofs/data.c
@@ -473,8 +473,7 @@ static int erofs_file_mmap_prepare(struct vm_area_desc *desc)
if (!IS_DAX(file_inode(desc->file)))
return generic_file_readonly_mmap_prepare(desc);
- if (vma_desc_test_any(desc, VMA_SHARED_BIT) &&
- vma_desc_test_any(desc, VMA_MAYWRITE_BIT))
+ if (vma_desc_test_all(desc, VMA_SHARED_BIT, VMA_MAYWRITE_BIT))
return -EINVAL;
desc->vm_ops = &erofs_dax_vm_ops;
diff --git a/fs/zonefs/file.c b/fs/zonefs/file.c
index 9f9273ecf71a..5ada33f70bb4 100644
--- a/fs/zonefs/file.c
+++ b/fs/zonefs/file.c
@@ -333,8 +333,7 @@ static int zonefs_file_mmap_prepare(struct vm_area_desc *desc)
* ordering between msync() and page cache writeback.
*/
if (zonefs_inode_is_seq(file_inode(file)) &&
- vma_desc_test_any(desc, VMA_SHARED_BIT) &&
- vma_desc_test_any(desc, VMA_MAYWRITE_BIT))
+ vma_desc_test_all(desc, VMA_SHARED_BIT, VMA_MAYWRITE_BIT))
return -EINVAL;
file_accessed(file);
diff --git a/include/linux/mm.h b/include/linux/mm.h
index db738a567637..9a052eedcdf4 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1178,7 +1178,7 @@ static inline void vma_set_flags_mask(struct vm_area_struct *vma,
#define vma_set_flags(vma, ...) \
vma_set_flags_mask(vma, mk_vma_flags(__VA_ARGS__))
-/* Helper to test all VMA flags in a VMA descriptor. */
+/* Helper to test any VMA flags in a VMA descriptor. */
static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
vma_flags_t flags)
{
@@ -1186,8 +1186,8 @@ static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
}
/*
- * Helper macro for testing VMA flags for an input pointer to a struct
- * vm_area_desc object describing a proposed VMA, e.g.:
+ * Helper macro for testing whether any VMA flags are set in a VMA descriptor,
+ * e.g.:
*
* if (vma_desc_test_any(desc, VMA_IO_BIT, VMA_PFNMAP_BIT,
* VMA_DONTEXPAND_BIT, VMA_DONTDUMP_BIT)) { ... }
@@ -1195,6 +1195,22 @@ static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
#define vma_desc_test_any(desc, ...) \
vma_desc_test_any_mask(desc, mk_vma_flags(__VA_ARGS__))
+/* Helper to test all VMA flags in a VMA descriptor. */
+static inline bool vma_desc_test_all_mask(const struct vm_area_desc *desc,
+ vma_flags_t flags)
+{
+ return vma_flags_test_all_mask(&desc->vma_flags, flags);
+}
+
+/*
+ * Helper macro for testing whether ALL VMA flags are set in a VMA descriptor,
+ * e.g.:
+ *
+ * if (vma_desc_test_all(desc, VMA_READ_BIT, VMA_MAYREAD_BIT)) { ... }
+ */
+#define vma_desc_test_all(desc, ...) \
+ vma_desc_test_all_mask(desc, mk_vma_flags(__VA_ARGS__))
+
/* Helper to set all VMA flags in a VMA descriptor. */
static inline void vma_desc_set_flags_mask(struct vm_area_desc *desc,
vma_flags_t flags)
@@ -1207,7 +1223,7 @@ static inline void vma_desc_set_flags_mask(struct vm_area_desc *desc,
* vm_area_desc object describing a proposed VMA, e.g.:
*
* vma_desc_set_flags(desc, VMA_IO_BIT, VMA_PFNMAP_BIT, VMA_DONTEXPAND_BIT,
- * VMA_DONTDUMP_BIT);
+ * VMA_DONTDUMP_BIT);
*/
#define vma_desc_set_flags(desc, ...) \
vma_desc_set_flags_mask(desc, mk_vma_flags(__VA_ARGS__))
diff --git a/tools/testing/vma/include/dup.h b/tools/testing/vma/include/dup.h
index c46b523e428d..59788bc14d75 100644
--- a/tools/testing/vma/include/dup.h
+++ b/tools/testing/vma/include/dup.h
@@ -922,6 +922,15 @@ static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
#define vma_desc_test_any(desc, ...) \
vma_desc_test_any_mask(desc, mk_vma_flags(__VA_ARGS__))
+static inline bool vma_desc_test_all_mask(const struct vm_area_desc *desc,
+ vma_flags_t flags)
+{
+ return vma_flags_test_all_mask(&desc->vma_flags, flags);
+}
+
+#define vma_desc_test_all(desc, ...) \
+ vma_desc_test_all_mask(desc, mk_vma_flags(__VA_ARGS__))
+
static inline void vma_desc_set_flags_mask(struct vm_area_desc *desc,
vma_flags_t flags)
{
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH 3/6] mm: always inline __mk_vma_flags() and invoked functions
2026-03-05 10:50 [PATCH 0/6] mm: vma flag tweaks Lorenzo Stoakes (Oracle)
2026-03-05 10:50 ` [PATCH 1/6] mm: rename VMA flag helpers to be more readable Lorenzo Stoakes (Oracle)
2026-03-05 10:50 ` [PATCH 2/6] mm: add vma_desc_test_all() and use it Lorenzo Stoakes (Oracle)
@ 2026-03-05 10:50 ` Lorenzo Stoakes (Oracle)
2026-03-05 10:50 ` [PATCH 4/6] mm: reintroduce vma_flags_test() as a singular flag test Lorenzo Stoakes (Oracle)
` (2 subsequent siblings)
5 siblings, 0 replies; 10+ messages in thread
From: Lorenzo Stoakes (Oracle) @ 2026-03-05 10:50 UTC (permalink / raw)
To: Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, David Hildenbrand, Konstantin Komarov, Tony Luck,
Reinette Chatre, Dave Martin, James Morse, Babu Moger,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
Jan Kara, Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
Be explicit about __mk_vma_flags() (which is used by the mk_vma_flags()
macro) always being inline, as we rely on the compiler converting this
function into meaningful.
Also update all of the functions __mk_vma_flags() ultimately invokes to be
always inline too.
Note that test_bitmap_const_eval() asserts that the relevant bitmap
functions result in build time constant values.
Additionally, vma_flag_set() operates on a vma_flags_t type, so it is
inconsistently named versus other VMA flags functions.
We only use vma_flag_set() in __mk_vma_flags() so we don't need to worry
about its new name being rather cumbersome, so rename it to
vma_flags_set_flag() to disambiguate it from vma_flags_set().
Also update the VMA test headers to reflect the changes.
Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
---
include/linux/mm.h | 8 +++++---
include/linux/mm_types.h | 2 +-
tools/testing/vma/include/custom.h | 5 +++--
tools/testing/vma/include/dup.h | 5 +++--
4 files changed, 12 insertions(+), 8 deletions(-)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 9a052eedcdf4..66b90de30bf6 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1031,21 +1031,23 @@ static inline bool vma_test_atomic_flag(struct vm_area_struct *vma, vma_flag_t b
}
/* Set an individual VMA flag in flags, non-atomically. */
-static inline void vma_flag_set(vma_flags_t *flags, vma_flag_t bit)
+static __always_inline void vma_flags_set_flag(vma_flags_t *flags,
+ vma_flag_t bit)
{
unsigned long *bitmap = flags->__vma_flags;
__set_bit((__force int)bit, bitmap);
}
-static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits)
+static __always_inline vma_flags_t __mk_vma_flags(size_t count,
+ const vma_flag_t *bits)
{
vma_flags_t flags;
int i;
vma_flags_clear_all(&flags);
for (i = 0; i < count; i++)
- vma_flag_set(&flags, bits[i]);
+ vma_flags_set_flag(&flags, bits[i]);
return flags;
}
diff --git a/include/linux/mm_types.h b/include/linux/mm_types.h
index 1a808d78245d..294efc22b2a4 100644
--- a/include/linux/mm_types.h
+++ b/include/linux/mm_types.h
@@ -1056,7 +1056,7 @@ struct vm_area_struct {
} __randomize_layout;
/* Clears all bits in the VMA flags bitmap, non-atomically. */
-static inline void vma_flags_clear_all(vma_flags_t *flags)
+static __always_inline void vma_flags_clear_all(vma_flags_t *flags)
{
bitmap_zero(flags->__vma_flags, NUM_VMA_FLAG_BITS);
}
diff --git a/tools/testing/vma/include/custom.h b/tools/testing/vma/include/custom.h
index 802a76317245..833ff4d7f799 100644
--- a/tools/testing/vma/include/custom.h
+++ b/tools/testing/vma/include/custom.h
@@ -102,7 +102,8 @@ static inline void vma_lock_init(struct vm_area_struct *vma, bool reset_refcnt)
refcount_set(&vma->vm_refcnt, 0);
}
-static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits)
+static __always_inline vma_flags_t __mk_vma_flags(size_t count,
+ const vma_flag_t *bits)
{
vma_flags_t flags;
int i;
@@ -114,6 +115,6 @@ static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits)
vma_flags_clear_all(&flags);
for (i = 0; i < count; i++)
if (bits[i] < NUM_VMA_FLAG_BITS)
- vma_flag_set(&flags, bits[i]);
+ vma_flags_set_flag(&flags, bits[i]);
return flags;
}
diff --git a/tools/testing/vma/include/dup.h b/tools/testing/vma/include/dup.h
index 59788bc14d75..ef6b9d963acc 100644
--- a/tools/testing/vma/include/dup.h
+++ b/tools/testing/vma/include/dup.h
@@ -780,12 +780,13 @@ static inline void vma_flags_clear_word(vma_flags_t *flags, unsigned long value)
*bitmap &= ~value;
}
-static inline void vma_flags_clear_all(vma_flags_t *flags)
+static __always_inline void vma_flags_clear_all(vma_flags_t *flags)
{
bitmap_zero(ACCESS_PRIVATE(flags, __vma_flags), NUM_VMA_FLAG_BITS);
}
-static inline void vma_flag_set(vma_flags_t *flags, vma_flag_t bit)
+static __always_inline void vma_flags_set_flag(vma_flags_t *flags,
+ vma_flag_t bit)
{
unsigned long *bitmap = ACCESS_PRIVATE(flags, __vma_flags);
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* [PATCH 4/6] mm: reintroduce vma_flags_test() as a singular flag test
2026-03-05 10:50 [PATCH 0/6] mm: vma flag tweaks Lorenzo Stoakes (Oracle)
` (2 preceding siblings ...)
2026-03-05 10:50 ` [PATCH 3/6] mm: always inline __mk_vma_flags() and invoked functions Lorenzo Stoakes (Oracle)
@ 2026-03-05 10:50 ` Lorenzo Stoakes (Oracle)
2026-03-05 13:49 ` David Hildenbrand (Arm)
2026-03-05 10:50 ` [PATCH 5/6] mm: reintroduce vma_desc_test() " Lorenzo Stoakes (Oracle)
2026-03-05 10:50 ` [PATCH 6/6] tools/testing/vma: add test for vma_flags_test(), vma_desc_test() Lorenzo Stoakes (Oracle)
5 siblings, 1 reply; 10+ messages in thread
From: Lorenzo Stoakes (Oracle) @ 2026-03-05 10:50 UTC (permalink / raw)
To: Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, David Hildenbrand, Konstantin Komarov, Tony Luck,
Reinette Chatre, Dave Martin, James Morse, Babu Moger,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
Jan Kara, Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
Since we've now renamed vma_flags_test() to vma_flags_test_any() to be very
clear as to what we are in fact testing, we now have the opportunity to
bring vma_flags_test() back, but for explicitly testing a single VMA flag.
This is useful, as often flag tests are against a single flag, and
vma_flags_test_any(flags, VMA_READ_BIT) reads oddly and potentially causes
confusion.
We use sparse to enforce that users won't accidentally pass vm_flags_t to
this function without it being flagged so this should make it harder to get
this wrong.
Of course, passing vma_flags_t to the function is impossible, as it is a
struct.
Also update the VMA tests to reflect this change.
Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
---
include/linux/mm.h | 17 +++++++++++++++--
mm/hugetlb.c | 2 +-
mm/shmem.c | 4 ++--
tools/testing/vma/include/dup.h | 8 ++++++++
4 files changed, 26 insertions(+), 5 deletions(-)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 66b90de30bf6..5622d04c9ba9 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1051,6 +1051,19 @@ static __always_inline vma_flags_t __mk_vma_flags(size_t count,
return flags;
}
+/*
+ * Test whether a specific VMA flag is set, e.g.:
+ *
+ * if (vma_flags_test(flags, VMA_READ_BIT)) { ... }
+ */
+static __always_inline bool vma_flags_test(const vma_flags_t *flags,
+ vma_flag_t bit)
+{
+ const unsigned long *bitmap = flags->__vma_flags;
+
+ return test_bit((__force int)bit, bitmap);
+}
+
/*
* Helper macro which bitwise-or combines the specified input flags into a
* vma_flags_t bitmap value. E.g.:
@@ -1957,8 +1970,8 @@ static inline bool vma_desc_is_cow_mapping(struct vm_area_desc *desc)
{
const vma_flags_t *flags = &desc->vma_flags;
- return vma_flags_test_any(flags, VMA_MAYWRITE_BIT) &&
- !vma_flags_test_any(flags, VMA_SHARED_BIT);
+ return vma_flags_test(flags, VMA_MAYWRITE_BIT) &&
+ !vma_flags_test(flags, VMA_SHARED_BIT);
}
#ifndef CONFIG_MMU
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index 8286c5db2c12..bd9f3b2d2cb0 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -6591,7 +6591,7 @@ long hugetlb_reserve_pages(struct inode *inode,
* attempt will be made for VM_NORESERVE to allocate a page
* without using reserves
*/
- if (vma_flags_test_any(&vma_flags, VMA_NORESERVE_BIT))
+ if (vma_flags_test(&vma_flags, VMA_NORESERVE_BIT))
return 0;
/*
diff --git a/mm/shmem.c b/mm/shmem.c
index 965a8908200b..5e7dcf5bc5d3 100644
--- a/mm/shmem.c
+++ b/mm/shmem.c
@@ -3086,7 +3086,7 @@ static struct inode *__shmem_get_inode(struct mnt_idmap *idmap,
spin_lock_init(&info->lock);
atomic_set(&info->stop_eviction, 0);
info->seals = F_SEAL_SEAL;
- info->flags = vma_flags_test_any(&flags, VMA_NORESERVE_BIT)
+ info->flags = vma_flags_test(&flags, VMA_NORESERVE_BIT)
? SHMEM_F_NORESERVE : 0;
info->i_crtime = inode_get_mtime(inode);
info->fsflags = (dir == NULL) ? 0 :
@@ -5827,7 +5827,7 @@ static struct file *__shmem_file_setup(struct vfsmount *mnt, const char *name,
unsigned int i_flags)
{
const unsigned long shmem_flags =
- vma_flags_test_any(&flags, VMA_NORESERVE_BIT) ? SHMEM_F_NORESERVE : 0;
+ vma_flags_test(&flags, VMA_NORESERVE_BIT) ? SHMEM_F_NORESERVE : 0;
struct inode *inode;
struct file *res;
diff --git a/tools/testing/vma/include/dup.h b/tools/testing/vma/include/dup.h
index ef6b9d963acc..630478f0d583 100644
--- a/tools/testing/vma/include/dup.h
+++ b/tools/testing/vma/include/dup.h
@@ -844,6 +844,14 @@ static inline vma_flags_t __mk_vma_flags(size_t count, const vma_flag_t *bits);
#define mk_vma_flags(...) __mk_vma_flags(COUNT_ARGS(__VA_ARGS__), \
(const vma_flag_t []){__VA_ARGS__})
+static __always_inline bool vma_flags_test(const vma_flags_t *flags,
+ vma_flag_t bit)
+{
+ const unsigned long *bitmap = flags->__vma_flags;
+
+ return test_bit((__force int)bit, bitmap);
+}
+
static __always_inline bool vma_flags_test_any_mask(const vma_flags_t *flags,
vma_flags_t to_test)
{
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH 4/6] mm: reintroduce vma_flags_test() as a singular flag test
2026-03-05 10:50 ` [PATCH 4/6] mm: reintroduce vma_flags_test() as a singular flag test Lorenzo Stoakes (Oracle)
@ 2026-03-05 13:49 ` David Hildenbrand (Arm)
0 siblings, 0 replies; 10+ messages in thread
From: David Hildenbrand (Arm) @ 2026-03-05 13:49 UTC (permalink / raw)
To: Lorenzo Stoakes (Oracle), Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, Konstantin Komarov, Tony Luck, Reinette Chatre,
Dave Martin, James Morse, Babu Moger, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Matthew Wilcox, Jan Kara,
Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
On 3/5/26 11:50, Lorenzo Stoakes (Oracle) wrote:
> Since we've now renamed vma_flags_test() to vma_flags_test_any() to be very
> clear as to what we are in fact testing, we now have the opportunity to
> bring vma_flags_test() back, but for explicitly testing a single VMA flag.
>
> This is useful, as often flag tests are against a single flag, and
> vma_flags_test_any(flags, VMA_READ_BIT) reads oddly and potentially causes
> confusion.
Agreed
Acked-by: David Hildenbrand (Arm) <david@kernel.org>
--
Cheers,
David
^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH 5/6] mm: reintroduce vma_desc_test() as a singular flag test
2026-03-05 10:50 [PATCH 0/6] mm: vma flag tweaks Lorenzo Stoakes (Oracle)
` (3 preceding siblings ...)
2026-03-05 10:50 ` [PATCH 4/6] mm: reintroduce vma_flags_test() as a singular flag test Lorenzo Stoakes (Oracle)
@ 2026-03-05 10:50 ` Lorenzo Stoakes (Oracle)
2026-03-05 13:49 ` David Hildenbrand (Arm)
2026-03-05 10:50 ` [PATCH 6/6] tools/testing/vma: add test for vma_flags_test(), vma_desc_test() Lorenzo Stoakes (Oracle)
5 siblings, 1 reply; 10+ messages in thread
From: Lorenzo Stoakes (Oracle) @ 2026-03-05 10:50 UTC (permalink / raw)
To: Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, David Hildenbrand, Konstantin Komarov, Tony Luck,
Reinette Chatre, Dave Martin, James Morse, Babu Moger,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
Jan Kara, Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
Similar to vma_flags_test(), we have previously renamed vma_desc_test() to
vma_desc_test_any(). Now that is in place, we can reintroduce
vma_desc_test() to explicitly check for a single VMA flag.
As with vma_flags_test(), this is useful as often flag tests are against a
single flag, and vma_desc_test_any(flags, VMA_READ_BIT) reads oddly and
potentially causes confusion.
As with vma_flags_test() a combination of sparse and vma_flags_t being a
struct means that users cannot misuse this function without it getting
flagged.
Also update the VMA tests to reflect this change.
Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
---
drivers/char/mem.c | 2 +-
fs/hugetlbfs/inode.c | 2 +-
fs/ntfs3/file.c | 2 +-
fs/resctrl/pseudo_lock.c | 2 +-
include/linux/dax.h | 4 ++--
include/linux/mm.h | 11 +++++++++++
mm/hugetlb.c | 12 ++++++------
tools/testing/vma/include/dup.h | 6 ++++++
8 files changed, 29 insertions(+), 12 deletions(-)
diff --git a/drivers/char/mem.c b/drivers/char/mem.c
index 5118787d0954..5fd421e48c04 100644
--- a/drivers/char/mem.c
+++ b/drivers/char/mem.c
@@ -520,7 +520,7 @@ static int mmap_zero_prepare(struct vm_area_desc *desc)
#ifndef CONFIG_MMU
return -ENOSYS;
#endif
- if (vma_desc_test_any(desc, VMA_SHARED_BIT))
+ if (vma_desc_test(desc, VMA_SHARED_BIT))
return shmem_zero_setup_desc(desc);
desc->action.success_hook = mmap_zero_private_success;
diff --git a/fs/hugetlbfs/inode.c b/fs/hugetlbfs/inode.c
index 079ffaaf1f6c..cd6b22f6e2b1 100644
--- a/fs/hugetlbfs/inode.c
+++ b/fs/hugetlbfs/inode.c
@@ -164,7 +164,7 @@ static int hugetlbfs_file_mmap_prepare(struct vm_area_desc *desc)
goto out;
ret = 0;
- if (vma_desc_test_any(desc, VMA_WRITE_BIT) && inode->i_size < len)
+ if (vma_desc_test(desc, VMA_WRITE_BIT) && inode->i_size < len)
i_size_write(inode, len);
out:
inode_unlock(inode);
diff --git a/fs/ntfs3/file.c b/fs/ntfs3/file.c
index c5e2181f9f02..fbdfaf989a31 100644
--- a/fs/ntfs3/file.c
+++ b/fs/ntfs3/file.c
@@ -276,7 +276,7 @@ static int ntfs_file_mmap_prepare(struct vm_area_desc *desc)
struct file *file = desc->file;
struct inode *inode = file_inode(file);
struct ntfs_inode *ni = ntfs_i(inode);
- const bool rw = vma_desc_test_any(desc, VMA_WRITE_BIT);
+ const bool rw = vma_desc_test(desc, VMA_WRITE_BIT);
int err;
/* Avoid any operation if inode is bad. */
diff --git a/fs/resctrl/pseudo_lock.c b/fs/resctrl/pseudo_lock.c
index 79a006c6f26c..d1cb0986006e 100644
--- a/fs/resctrl/pseudo_lock.c
+++ b/fs/resctrl/pseudo_lock.c
@@ -1044,7 +1044,7 @@ static int pseudo_lock_dev_mmap_prepare(struct vm_area_desc *desc)
* Ensure changes are carried directly to the memory being mapped,
* do not allow copy-on-write mapping.
*/
- if (!vma_desc_test_any(desc, VMA_SHARED_BIT)) {
+ if (!vma_desc_test(desc, VMA_SHARED_BIT)) {
mutex_unlock(&rdtgroup_mutex);
return -EINVAL;
}
diff --git a/include/linux/dax.h b/include/linux/dax.h
index 535019001577..10a7cc79aea5 100644
--- a/include/linux/dax.h
+++ b/include/linux/dax.h
@@ -69,7 +69,7 @@ static inline bool daxdev_mapping_supported(const struct vm_area_desc *desc,
const struct inode *inode,
struct dax_device *dax_dev)
{
- if (!vma_desc_test_any(desc, VMA_SYNC_BIT))
+ if (!vma_desc_test(desc, VMA_SYNC_BIT))
return true;
if (!IS_DAX(inode))
return false;
@@ -115,7 +115,7 @@ static inline bool daxdev_mapping_supported(const struct vm_area_desc *desc,
const struct inode *inode,
struct dax_device *dax_dev)
{
- return !vma_desc_test_any(desc, VMA_SYNC_BIT);
+ return !vma_desc_test(desc, VMA_SYNC_BIT);
}
static inline size_t dax_recovery_write(struct dax_device *dax_dev,
pgoff_t pgoff, void *addr, size_t bytes, struct iov_iter *i)
diff --git a/include/linux/mm.h b/include/linux/mm.h
index 5622d04c9ba9..9bdfa1a91552 100644
--- a/include/linux/mm.h
+++ b/include/linux/mm.h
@@ -1193,6 +1193,17 @@ static inline void vma_set_flags_mask(struct vm_area_struct *vma,
#define vma_set_flags(vma, ...) \
vma_set_flags_mask(vma, mk_vma_flags(__VA_ARGS__))
+/*
+ * Test whether a specific VMA flag is set in a VMA descriptor, e.g.:
+ *
+ * if (vma_desc_test(desc, VMA_READ_BIT)) { ... }
+ */
+static __always_inline bool vma_desc_test(const struct vm_area_desc *desc,
+ vma_flag_t bit)
+{
+ return vma_flags_test(&desc->vma_flags, bit);
+}
+
/* Helper to test any VMA flags in a VMA descriptor. */
static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
vma_flags_t flags)
diff --git a/mm/hugetlb.c b/mm/hugetlb.c
index bd9f3b2d2cb0..8cde83fb8a5a 100644
--- a/mm/hugetlb.c
+++ b/mm/hugetlb.c
@@ -1194,7 +1194,7 @@ static void set_vma_resv_flags(struct vm_area_struct *vma, unsigned long flags)
static void set_vma_desc_resv_map(struct vm_area_desc *desc, struct resv_map *map)
{
VM_WARN_ON_ONCE(!is_vma_hugetlb_flags(&desc->vma_flags));
- VM_WARN_ON_ONCE(vma_desc_test_any(desc, VMA_MAYSHARE_BIT));
+ VM_WARN_ON_ONCE(vma_desc_test(desc, VMA_MAYSHARE_BIT));
desc->private_data = map;
}
@@ -1202,7 +1202,7 @@ static void set_vma_desc_resv_map(struct vm_area_desc *desc, struct resv_map *ma
static void set_vma_desc_resv_flags(struct vm_area_desc *desc, unsigned long flags)
{
VM_WARN_ON_ONCE(!is_vma_hugetlb_flags(&desc->vma_flags));
- VM_WARN_ON_ONCE(vma_desc_test_any(desc, VMA_MAYSHARE_BIT));
+ VM_WARN_ON_ONCE(vma_desc_test(desc, VMA_MAYSHARE_BIT));
desc->private_data = (void *)((unsigned long)desc->private_data | flags);
}
@@ -6600,7 +6600,7 @@ long hugetlb_reserve_pages(struct inode *inode,
* to reserve the full area even if read-only as mprotect() may be
* called to make the mapping read-write. Assume !desc is a shm mapping
*/
- if (!desc || vma_desc_test_any(desc, VMA_MAYSHARE_BIT)) {
+ if (!desc || vma_desc_test(desc, VMA_MAYSHARE_BIT)) {
/*
* resv_map can not be NULL as hugetlb_reserve_pages is only
* called for inodes for which resv_maps were created (see
@@ -6634,7 +6634,7 @@ long hugetlb_reserve_pages(struct inode *inode,
if (err < 0)
goto out_err;
- if (desc && !vma_desc_test_any(desc, VMA_MAYSHARE_BIT) && h_cg) {
+ if (desc && !vma_desc_test(desc, VMA_MAYSHARE_BIT) && h_cg) {
/* For private mappings, the hugetlb_cgroup uncharge info hangs
* of the resv_map.
*/
@@ -6671,7 +6671,7 @@ long hugetlb_reserve_pages(struct inode *inode,
* consumed reservations are stored in the map. Hence, nothing
* else has to be done for private mappings here
*/
- if (!desc || vma_desc_test_any(desc, VMA_MAYSHARE_BIT)) {
+ if (!desc || vma_desc_test(desc, VMA_MAYSHARE_BIT)) {
add = region_add(resv_map, from, to, regions_needed, h, h_cg);
if (unlikely(add < 0)) {
@@ -6735,7 +6735,7 @@ long hugetlb_reserve_pages(struct inode *inode,
hugetlb_cgroup_uncharge_cgroup_rsvd(hstate_index(h),
chg * pages_per_huge_page(h), h_cg);
out_err:
- if (!desc || vma_desc_test_any(desc, VMA_MAYSHARE_BIT))
+ if (!desc || vma_desc_test(desc, VMA_MAYSHARE_BIT))
/* Only call region_abort if the region_chg succeeded but the
* region_add failed or didn't run.
*/
diff --git a/tools/testing/vma/include/dup.h b/tools/testing/vma/include/dup.h
index 630478f0d583..5eb313beb43d 100644
--- a/tools/testing/vma/include/dup.h
+++ b/tools/testing/vma/include/dup.h
@@ -922,6 +922,12 @@ static inline void vma_set_flags_mask(struct vm_area_struct *vma,
#define vma_set_flags(vma, ...) \
vma_set_flags_mask(vma, mk_vma_flags(__VA_ARGS__))
+static __always_inline bool vma_desc_test(const struct vm_area_desc *desc,
+ vma_flag_t bit)
+{
+ return vma_flags_test(&desc->vma_flags, bit);
+}
+
static inline bool vma_desc_test_any_mask(const struct vm_area_desc *desc,
vma_flags_t flags)
{
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH 5/6] mm: reintroduce vma_desc_test() as a singular flag test
2026-03-05 10:50 ` [PATCH 5/6] mm: reintroduce vma_desc_test() " Lorenzo Stoakes (Oracle)
@ 2026-03-05 13:49 ` David Hildenbrand (Arm)
0 siblings, 0 replies; 10+ messages in thread
From: David Hildenbrand (Arm) @ 2026-03-05 13:49 UTC (permalink / raw)
To: Lorenzo Stoakes (Oracle), Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, Konstantin Komarov, Tony Luck, Reinette Chatre,
Dave Martin, James Morse, Babu Moger, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Matthew Wilcox, Jan Kara,
Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
On 3/5/26 11:50, Lorenzo Stoakes (Oracle) wrote:
> Similar to vma_flags_test(), we have previously renamed vma_desc_test() to
> vma_desc_test_any(). Now that is in place, we can reintroduce
> vma_desc_test() to explicitly check for a single VMA flag.
>
> As with vma_flags_test(), this is useful as often flag tests are against a
> single flag, and vma_desc_test_any(flags, VMA_READ_BIT) reads oddly and
> potentially causes confusion.
>
> As with vma_flags_test() a combination of sparse and vma_flags_t being a
> struct means that users cannot misuse this function without it getting
> flagged.
>
> Also update the VMA tests to reflect this change.
Acked-by: David Hildenbrand (Arm) <david@kernel.org>
--
Cheers,
David
^ permalink raw reply [flat|nested] 10+ messages in thread
* [PATCH 6/6] tools/testing/vma: add test for vma_flags_test(), vma_desc_test()
2026-03-05 10:50 [PATCH 0/6] mm: vma flag tweaks Lorenzo Stoakes (Oracle)
` (4 preceding siblings ...)
2026-03-05 10:50 ` [PATCH 5/6] mm: reintroduce vma_desc_test() " Lorenzo Stoakes (Oracle)
@ 2026-03-05 10:50 ` Lorenzo Stoakes (Oracle)
2026-03-05 13:52 ` David Hildenbrand (Arm)
5 siblings, 1 reply; 10+ messages in thread
From: Lorenzo Stoakes (Oracle) @ 2026-03-05 10:50 UTC (permalink / raw)
To: Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, David Hildenbrand, Konstantin Komarov, Tony Luck,
Reinette Chatre, Dave Martin, James Morse, Babu Moger,
Damien Le Moal, Naohiro Aota, Johannes Thumshirn, Matthew Wilcox,
Jan Kara, Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
Now we have helpers which test singular VMA flags - vma_flags_test() and
vma_desc_test() - add a test to explicitly assert that these behave as
expected.
Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
---
tools/testing/vma/tests/vma.c | 36 +++++++++++++++++++++++++++++++++++
1 file changed, 36 insertions(+)
diff --git a/tools/testing/vma/tests/vma.c b/tools/testing/vma/tests/vma.c
index f031e6dfb474..1aa94dd7e74a 100644
--- a/tools/testing/vma/tests/vma.c
+++ b/tools/testing/vma/tests/vma.c
@@ -159,6 +159,41 @@ static bool test_vma_flags_word(void)
return true;
}
+/* Ensure that vma_flags_test() and friends works correctly. */
+static bool test_vma_flags_test(void)
+{
+ const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
+ VMA_EXEC_BIT, 64, 65);
+ struct vm_area_desc desc;
+
+ desc.vma_flags = flags;
+
+#define do_test(_flag) \
+ ASSERT_TRUE(vma_flags_test(&flags, _flag)); \
+ ASSERT_TRUE(vma_desc_test(&desc, _flag))
+
+#define do_test_false(_flag) \
+ ASSERT_FALSE(vma_flags_test(&flags, _flag)); \
+ ASSERT_FALSE(vma_desc_test(&desc, _flag))
+
+ do_test(VMA_READ_BIT);
+ do_test(VMA_WRITE_BIT);
+ do_test(VMA_EXEC_BIT);
+#if NUM_VMA_FLAG_BITS > 64
+ do_test(64);
+ do_test(65);
+#endif
+ do_test_false(VMA_MAYWRITE_BIT);
+#if NUM_VMA_FLAG_BITS > 64
+ do_test_false(66);
+#endif
+
+#undef do_test
+#undef do_test_false
+
+ return true;
+}
+
/* Ensure that vma_flags_test_any() and friends works correctly. */
static bool test_vma_flags_test_any(void)
{
@@ -334,6 +369,7 @@ static void run_vma_tests(int *num_tests, int *num_fail)
TEST(vma_flags_unchanged);
TEST(vma_flags_cleared);
TEST(vma_flags_word);
+ TEST(vma_flags_test);
TEST(vma_flags_test_any);
TEST(vma_flags_clear);
}
--
2.53.0
^ permalink raw reply [flat|nested] 10+ messages in thread* Re: [PATCH 6/6] tools/testing/vma: add test for vma_flags_test(), vma_desc_test()
2026-03-05 10:50 ` [PATCH 6/6] tools/testing/vma: add test for vma_flags_test(), vma_desc_test() Lorenzo Stoakes (Oracle)
@ 2026-03-05 13:52 ` David Hildenbrand (Arm)
0 siblings, 0 replies; 10+ messages in thread
From: David Hildenbrand (Arm) @ 2026-03-05 13:52 UTC (permalink / raw)
To: Lorenzo Stoakes (Oracle), Andrew Morton
Cc: Arnd Bergmann, Greg Kroah-Hartman, Dan Williams, Vishal Verma,
Dave Jiang, Gao Xiang, Chao Yu, Yue Hu, Jeffle Xu,
Sandeep Dhavale, Hongbo Li, Chunhai Guo, Muchun Song,
Oscar Salvador, Konstantin Komarov, Tony Luck, Reinette Chatre,
Dave Martin, James Morse, Babu Moger, Damien Le Moal,
Naohiro Aota, Johannes Thumshirn, Matthew Wilcox, Jan Kara,
Liam R . Howlett, Vlastimil Babka, Mike Rapoport,
Suren Baghdasaryan, Michal Hocko, Hugh Dickins, Baolin Wang,
Jann Horn, Pedro Falcato, Jason Gunthorpe, linux-kernel, nvdimm,
linux-cxl, linux-erofs, linux-mm, ntfs3, linux-fsdevel
On 3/5/26 11:50, Lorenzo Stoakes (Oracle) wrote:
> Now we have helpers which test singular VMA flags - vma_flags_test() and
> vma_desc_test() - add a test to explicitly assert that these behave as
> expected.
>
> Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
> ---
> tools/testing/vma/tests/vma.c | 36 +++++++++++++++++++++++++++++++++++
> 1 file changed, 36 insertions(+)
>
> diff --git a/tools/testing/vma/tests/vma.c b/tools/testing/vma/tests/vma.c
> index f031e6dfb474..1aa94dd7e74a 100644
> --- a/tools/testing/vma/tests/vma.c
> +++ b/tools/testing/vma/tests/vma.c
> @@ -159,6 +159,41 @@ static bool test_vma_flags_word(void)
> return true;
> }
>
> +/* Ensure that vma_flags_test() and friends works correctly. */
> +static bool test_vma_flags_test(void)
> +{
> + const vma_flags_t flags = mk_vma_flags(VMA_READ_BIT, VMA_WRITE_BIT,
> + VMA_EXEC_BIT, 64, 65);
When already using numbers, I was wondering whether you'd want to stick
to numbers only here.
> + struct vm_area_desc desc;
struct vm_area_desc desc = {
.vma_flags = flags,
};
?
--
Cheers,
David
^ permalink raw reply [flat|nested] 10+ messages in thread