mm: make mm->flags a bitmap and 64-bit on all arches
Subsystems (19)
cover mm: make mm->flags a bitmap and 64-bit on all arches
We are currently in the bizarre situation where we are constrained on the number of flags we can set in an mm_struct based on whether this is a 32-bit or 64-bit kernel.
This is because mm->flags is an unsigned long field, which is 32-bits on a 32-bit system and 64-bits on a 64-bit system.
In order to keep things functional across both architectures, we do not permit mm flag bits to be set above flag 31 (i.e. the 32nd bit).
This is a silly situation, especially given how profligate we are in storing metadata in mm_struct, so let's convert mm->flags into a bitmap and allow ourselves as many bits as we like.
In order to execute this change, we introduce a new opaque type - mm_flags_t - which wraps a bitmap.
We go further and mark the bitmap field __private, which forces users to have to use accessors, which allows us to enforce atomicity rules around mm->flags (except on those occasions they are not required - fork, etc.) and makes it far easier to keep track of how mm flags are being utilised.
In order to implement this change sensibly and an an iterative way, we start by introducing the type with the same bitsize as the current mm flags (system word size) and place it in union with mm->flags.
We are then able to gradually update users as we go without being forced to do everything in a single patch.
In the course of working on this series I noticed the MMF_* flag masks encounter a sign extension bug that, due to the 32-bit limit on mm->flags thus far, has not caused any issues in practice, but required fixing for this series.
We must make special dispensation for two cases - coredump and initailisation on fork, but of which use masks extensively.
Since coredump flags are set in stone, we can safely assume they will remain in the first 32-bits of the flags. We therefore provide special non-atomic accessors for this case that access the first system word of flags, keeping everything there essentially the same.
For mm->flags initialisation on fork, we adjust the logic to ensure all bits are cleared correctly, and then adjust the existing intialisation logic, dubbing the implementation utilising flags as legacy.
This means we get the same fast operations as we do now, but in future we can also choose to update the forking logic to additionally propagate flags beyond 32-bits across fork.
With this change in place we can, in future, decide to have as many bits as we please.
Since the size of the bitmap will scale in system word multiples, there should be no issues with changes in alignment in mm_struct. Additionally, the really sensitive field (mmap_lock) is located prior to the flags field so this should have no impact on that either.
Lorenzo Stoakes (10):
mm: add bitmap mm->flags field
mm: convert core mm to mm_flags_*() accessors
mm: convert prctl to mm_flags_*() accessors
mm: convert arch-specific code to mm_flags_*() accessors
mm: convert uprobes to mm_flags_*() accessors
mm: update coredump logic to correctly use bitmap mm flags
mm: correct sign-extension issue in MMF_* flag masks
mm: update fork mm->flags initialisation to use bitmap
mm: convert remaining users to mm_flags_*() accessors
mm: replace mm->flags with bitmap entirely and set to 64 bits
arch/s390/mm/mmap.c | 4 +- arch/sparc/kernel/sys_sparc_64.c | 4 +- arch/x86/mm/mmap.c | 4 +- fs/coredump.c | 4 +- fs/exec.c | 2 +- fs/pidfs.c | 7 +++- fs/proc/array.c | 2 +- fs/proc/base.c | 12 +++--- fs/proc/task_mmu.c | 2 +- include/linux/huge_mm.h | 2 +- include/linux/khugepaged.h | 6 ++- include/linux/ksm.h | 6 +-- include/linux/mm.h | 34 +++++++++++++++- include/linux/mm_types.h | 67 +++++++++++++++++++++++++------- include/linux/mman.h | 2 +- include/linux/oom.h | 2 +- include/linux/sched/coredump.h | 21 +++++++++- kernel/events/uprobes.c | 32 +++++++-------- kernel/fork.c | 9 +++-- kernel/sys.c | 16 ++++---- mm/debug.c | 4 +- mm/gup.c | 10 ++--- mm/huge_memory.c | 8 ++-- mm/khugepaged.c | 10 ++--- mm/ksm.c | 32 +++++++-------- mm/mmap.c | 8 ++-- mm/oom_kill.c | 26 ++++++------- mm/util.c | 6 +-- tools/testing/vma/vma_internal.h | 19 ++++++++- 29 files changed, 239 insertions(+), 122 deletions(-)
--
2.50.1
PATCH 1/10 mm: add bitmap mm->flags field
We are currently in the bizarre situation where we are constrained on the number of flags we can set in an mm_struct based on whether this is a 32-bit or 64-bit kernel.
This is because mm->flags is an unsigned long field, which is 32-bits on a 32-bit system and 64-bits on a 64-bit system.
In order to keep things functional across both architectures, we do not permit mm flag bits to be set above flag 31 (i.e. the 32nd bit).
This is a silly situation, especially given how profligate we are in storing metadata in mm_struct, so let's convert mm->flags into a bitmap and allow ourselves as many bits as we like.
To keep things manageable, firstly we introduce the bitmap at a system word system as a new field mm->_flags, in union.
This means the new bitmap mm->_flags is bitwise exactly identical to the existing mm->flags field.
We have an opportunity to also introduce some type safety here, so let's wrap the mm flags field as a struct and declare it as an mm_flags_t typedef to keep it consistent with vm_flags_t for VMAs.
We make the internal field privately accessible, in order to force the use of helper functions so we can enforce that accesses are bitwise as required.
We therefore introduce accessors prefixed with mm_flags_*() for callers to use. We place the bit parameter first so as to match the parameter ordering of the *_bit() functions.
Having this temporary union arrangement allows us to incrementally swap over users of mm->flags patch-by-patch rather than having to do everything in one fell swoop.
--- include/linux/mm.h | 32 ++++++++++++++++++++++++++++++++ include/linux/mm_types.h | 39 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 70 insertions(+), 1 deletion(-)
include/linux/mm.h +32 -0
@@ -34,6 +34,8 @@#include <linux/slab.h> #include <linux/cacheinfo.h> #include <linux/rcuwait.h> +#include <linux/bitmap.h> +#include <linux/bitops.h> struct mempolicy ;struct anon_vma ;
@@ -720,6 +722,36 @@ static inline void assert_fault_locked(struct vm_fault *vmf) }#endif /* CONFIG_PER_VMA_LOCK */ +static inline bool mm_flags_test (int flag,const struct mm_struct *mm) +{ +return test_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline bool mm_flags_test_and_set (int flag,struct mm_struct *mm) +{ +return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline bool mm_flags_test_and_clear (int flag,struct mm_struct *mm) +{ +return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline void mm_flags_set (int flag,struct mm_struct *mm) +{ +set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline void mm_flags_clear (int flag,struct mm_struct *mm) +{ +clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline void mm_flags_clear_all (struct mm_struct *mm) +{ +bitmap_zero (ACCESS_PRIVATE (&mm->_flags, __mm_flags),NUM_MM_FLAG_BITS ); +} +extern const struct vm_operations_struct vma_dummy_vm_ops;static inline void vma_init (struct vm_area_struct *vma,struct mm_struct *mm)
include/linux/mm_types.h +38 -1
@@ -20,6 +20,7 @@#include <linux/seqlock.h> #include <linux/percpu_counter.h> #include <linux/types.h> +#include <linux/bitmap.h> #include <asm/mmu.h>
@@ -927,6 +928,15 @@ struct mm_cid { };#endif +/* +* Opaque type representing current mm_struct flag state. Must be accessed via +* mm_flags_xxx() helper functions. +*/ +#define NUM_MM_FLAG_BITS BITS_PER_LONG +typedef struct { + __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); +}mm_flags_t ; +struct kioctx_table ;struct iommu_mm_data ;struct mm_struct {
@@ -1109,7 +1119,11 @@ struct mm_struct {/* Architecture-specific MM context */ mm_context_t context; -unsigned long flags;/* Must use atomic bitops to access */ +/* Temporary union while we convert users to mm_flags_t. */ +union { +unsigned long flags;/* Must use atomic bitops to access */ +mm_flags_t _flags;/* Must use mm_flags_* helpers to access */ + };#ifdef CONFIG_AIO spinlock_t ioctx_lock;
@@ -1219,6 +1233,29 @@ struct mm_struct {unsigned long cpu_bitmap[]; }; +/* Read the first system word of mm flags, non-atomically. */ +static inline unsigned long __mm_flags_get_word (struct mm_struct *mm) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +return bitmap_read (bitmap,0 ,BITS_PER_LONG ); +} + +/* Set the first system word of mm flags, non-atomically. */ +static inline void __mm_flags_set_word (struct mm_struct *mm, +unsigned long value) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +bitmap_copy (bitmap, &value,BITS_PER_LONG ); +} + +/* Obtain a read-only view of the bitmap. */ +static inline const unsigned long *__mm_flags_get_bitmap (const struct mm_struct *mm) +{ +return (const unsigned long *)ACCESS_PRIVATE (&mm->_flags, __mm_flags); +} +#define MM_MT_FLAGS (MT_FLAGS_ALLOC_RANGE | MT_FLAGS_LOCK_EXTERN | \ MT_FLAGS_USE_RCU)extern struct mm_struct init_mm;
Signature · 1 line
2.50.1
Re: [PATCH 01/10] mm: add bitmap mm->flags field
Quoted 32 lines · Lorenzo Stoakes
We are currently in the bizarre situation where we are constrained on the number of flags we can set in an
mm_structbased on whether this is a 32-bit or 64-bit kernel.This is because
mm->flagsis an unsigned long field, which is 32-bits on a 32-bit system and 64-bits on a 64-bit system.In order to keep things functional across both architectures, we do not permit mm flag bits to be set above flag 31 (i.e. the 32nd bit).
This is a silly situation, especially given how profligate we are in storing metadata in
mm_struct, so let's convertmm->flagsinto a bitmap and allow ourselves as many bits as we like.To keep things manageable, firstly we introduce the bitmap at a system word system as a new field
mm->_flags, in union.This means the new bitmap
mm->_flagsis bitwise exactly identical to the existingmm->flagsfield.We have an opportunity to also introduce some type safety here, so let's wrap the mm flags field as a struct and declare it as an
mm_flags_ttypedef to keep it consistent withvm_flags_tfor VMAs.We make the internal field privately accessible, in order to force the use of helper functions so we can enforce that accesses are bitwise as required.
We therefore introduce accessors prefixed with mm_flags_*() for callers to use. We place the bit parameter first so as to match the parameter ordering of the
*_bit()functions.
Quoted 5 lines
Having this temporary union arrangement allows us to incrementally swap over users of
mm->flagspatch-by-patch rather than having to do everything in one fell swoop.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 129 lines
--- include/linux/mm.h | 32 ++++++++++++++++++++++++++++++++ include/linux/mm_types.h | 39 ++++++++++++++++++++++++++++++++++++++- 2 files changed, 70 insertions(+), 1 deletion(-)include/linux/mm.h +32
-0@@ -34,6 +34,8 @@#include <linux/slab.h> #include <linux/cacheinfo.h> #include <linux/rcuwait.h> +#include <linux/bitmap.h> +#include <linux/bitops.h> struct mempolicy ;struct anon_vma ;@@ -720,6 +722,36 @@ static inline void assert_fault_locked(struct vm_fault *vmf) }#endif /* CONFIG_PER_VMA_LOCK */ +static inline bool mm_flags_test (int flag,const struct mm_struct *mm) +{ +return test_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline bool mm_flags_test_and_set (int flag,struct mm_struct *mm) +{ +return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline bool mm_flags_test_and_clear (int flag,struct mm_struct *mm) +{ +return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline void mm_flags_set (int flag,struct mm_struct *mm) +{ +set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline void mm_flags_clear (int flag,struct mm_struct *mm) +{ +clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +} + +static inline void mm_flags_clear_all (struct mm_struct *mm) +{ +bitmap_zero (ACCESS_PRIVATE (&mm->_flags, __mm_flags),NUM_MM_FLAG_BITS ); +} +extern const struct vm_operations_struct vma_dummy_vm_ops;static inline void vma_init (struct vm_area_struct *vma,struct mm_struct *mm)include/linux/mm_types.h +38
-1@@ -20,6 +20,7 @@#include <linux/seqlock.h> #include <linux/percpu_counter.h> #include <linux/types.h> +#include <linux/bitmap.h> #include <asm/mmu.h> @@ -927,6 +928,15 @@ struct mm_cid { };#endif +/* +* Opaque type representing current mm_struct flag state. Must be accessed via +* mm_flags_xxx() helper functions. +*/ +#define NUM_MM_FLAG_BITS BITS_PER_LONG +typedef struct { + __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); +}mm_flags_t ; +struct kioctx_table ;struct iommu_mm_data ;struct mm_struct {@@ -1109,7 +1119,11 @@ struct mm_struct {/* Architecture-specific MM context */ mm_context_t context; -unsigned long flags;/* Must use atomic bitops to access */ +/* Temporary union while we convert users to mm_flags_t. */ +union { +unsigned long flags;/* Must use atomic bitops to access */ +mm_flags_t _flags;/* Must use mm_flags_* helpers to access */ + };#ifdef CONFIG_AIO spinlock_t ioctx_lock;@@ -1219,6 +1233,29 @@ struct mm_struct {unsigned long cpu_bitmap[]; }; +/* Read the first system word of mm flags, non-atomically. */ +static inline unsigned long __mm_flags_get_word (struct mm_struct *mm) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +return bitmap_read (bitmap,0 ,BITS_PER_LONG ); +} + +/* Set the first system word of mm flags, non-atomically. */ +static inline void __mm_flags_set_word (struct mm_struct *mm, +unsigned long value) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +bitmap_copy (bitmap, &value,BITS_PER_LONG ); +} + +/* Obtain a read-only view of the bitmap. */ +static inline const unsigned long *__mm_flags_get_bitmap (const struct mm_struct *mm) +{ +return (const unsigned long *)ACCESS_PRIVATE (&mm->_flags, __mm_flags); +} +#define MM_MT_FLAGS (MT_FLAGS_ALLOC_RANGE | MT_FLAGS_LOCK_EXTERN | \ MT_FLAGS_USE_RCU)extern struct mm_struct init_mm;Signature · 1 line
2.50.1
Re: [PATCH 01/10] mm: add bitmap mm->flags field
In reply to Lorenzo StoakesHi Andrew,
Apologies, it turns out I put the __private sparse decorator in the wrong place :)
I enclose a fix-patch that fixes this (now *ahem* tested with sparse...) as well as fixing some trivial whitespace/code reuse/const stuff in a couple accessors.
Cheers, Lorenzo
----8<----
From cbe60f2c5e35bf1fcffb00c51f79f700edc17e06 Mon Sep 17 00:00:00 2001
From: Lorenzo Stoakes <[email protected]>
Date: Wed, 13 Aug 2025 20:40:10 +0100
Subject: [PATCH] mm: place __private in correct place, const-ify
__mm_flags_get_word
The __private sparse indicator was placed in the wrong location, resulting in sparse errors, correct this by placing it where it ought to be.
Also, share some code for __mm_flags_get_word() and const-ify it to be consistent.
Finally, fixup inconsistency in __mm_flags_set_word() param alignment.
--- include/linux/mm_types.h | 23 +++++++++++------------ 1 file changed, 11 insertions(+), 12 deletions(-)
include/linux/mm_types.h +11 -12
@@ -934,8 +934,8 @@ struct mm_cid {*/ #define NUM_MM_FLAG_BITS BITS_PER_LONGtypedef struct { - __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); -}mm_flags_t ; + DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); +}__private mm_flags_t ;struct kioctx_table ;struct iommu_mm_data ;
@@ -1233,17 +1233,8 @@ struct mm_struct {unsigned long cpu_bitmap[]; }; -/* Read the first system word of mm flags, non-atomically. */ -static inline unsigned long __mm_flags_get_word (struct mm_struct *mm) -{ -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); - -return bitmap_read (bitmap,0 ,BITS_PER_LONG ); -} -/* Set the first system word of mm flags, non-atomically. */ -static inline void __mm_flags_set_word (struct mm_struct *mm, -unsigned long value) +static inline void __mm_flags_set_word (struct mm_struct *mm,unsigned long value) {unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags);
@@ -1256,6 +1247,14 @@ static inline const unsigned long *__mm_flags_get_bitmap(const struct mm_structreturn (const unsigned long *)ACCESS_PRIVATE (&mm->_flags, __mm_flags); } +/* Read the first system word of mm flags, non-atomically. */ +static inline unsigned long __mm_flags_get_word (const struct mm_struct *mm) +{ +const unsigned long *bitmap =__mm_flags_get_bitmap (mm); + +return bitmap_read (bitmap,0 ,BITS_PER_LONG ); +} +#define MM_MT_FLAGS (MT_FLAGS_ALLOC_RANGE | MT_FLAGS_LOCK_EXTERN | \ MT_FLAGS_USE_RCU)extern struct mm_struct init_mm;
--
2.50.1
Re: [PATCH 01/10] mm: add bitmap mm->flags field
In reply to Lorenzo StoakesQuoted 32 lines · Lorenzo Stoakes
We are currently in the bizarre situation where we are constrained on the number of flags we can set in an
mm_structbased on whether this is a 32-bit or 64-bit kernel.This is because
mm->flagsis an unsigned long field, which is 32-bits on a 32-bit system and 64-bits on a 64-bit system.In order to keep things functional across both architectures, we do not permit mm flag bits to be set above flag 31 (i.e. the 32nd bit).
This is a silly situation, especially given how profligate we are in storing metadata in
mm_struct, so let's convertmm->flagsinto a bitmap and allow ourselves as many bits as we like.To keep things manageable, firstly we introduce the bitmap at a system word system as a new field
mm->_flags, in union.This means the new bitmap
mm->_flagsis bitwise exactly identical to the existingmm->flagsfield.We have an opportunity to also introduce some type safety here, so let's wrap the mm flags field as a struct and declare it as an
mm_flags_ttypedef to keep it consistent withvm_flags_tfor VMAs.We make the internal field privately accessible, in order to force the use of helper functions so we can enforce that accesses are bitwise as required.
We therefore introduce accessors prefixed with mm_flags_*() for callers to use. We place the bit parameter first so as to match the parameter ordering of the
*_bit()functions.
Quoted 6 lines
Having this temporary union arrangement allows us to incrementally swap over users of
mm->flagspatch-by-patch rather than having to do everything in one fell swoop.Signed-off-by Lorenzo Stoakes <[email protected]>---
Incl. fixup LGTM
Signature · 3 lines
Cheers David / dhildenb
PATCH 2/10 mm: convert core mm to mm_flags_*() accessors
In reply to Lorenzo StoakesAs part of the effort to move to mm->flags becoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessing mm_struct flags.
This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
--- include/linux/huge_mm.h | 2 +- include/linux/khugepaged.h | 6 ++++-- include/linux/ksm.h | 6 +++--- include/linux/mm.h | 2 +- include/linux/mman.h | 2 +- include/linux/oom.h | 2 +- mm/debug.c | 4 ++-- mm/gup.c | 10 +++++----- mm/huge_memory.c | 8 ++++---- mm/khugepaged.c | 10 +++++----- mm/ksm.c | 32 ++++++++++++++++---------------- mm/mmap.c | 8 ++++---- mm/oom_kill.c | 26 +++++++++++++------------- mm/util.c | 6 +++--- 14 files changed, 63 insertions(+), 61 deletions(-)
include/linux/huge_mm.h +1 -1
@@ -327,7 +327,7 @@ static inline bool vma_thp_disabled(struct vm_area_struct *vma,* example, s390 kvm. */ return (vm_flags &VM_NOHUGEPAGE ) || -test_bit (MMF_DISABLE_THP , &vma->vm_mm->flags); +mm_flags_test (MMF_DISABLE_THP , vma->vm_mm); }static inline bool thp_disabled_by_hw (void )
include/linux/khugepaged.h +4 -2
@@ -2,6 +2,8 @@#ifndef _LINUX_KHUGEPAGED_H#define _LINUX_KHUGEPAGED_H +#include <linux/mm.h> +extern unsigned int khugepaged_max_ptes_none__read_mostly ;#ifdef CONFIG_TRANSPARENT_HUGEPAGE extern struct attribute_group khugepaged_attr_group;
@@ -20,13 +22,13 @@ extern int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr,static inline void khugepaged_fork (struct mm_struct *mm,struct mm_struct *oldmm) { -if (test_bit (MMF_VM_HUGEPAGE , &oldmm->flags)) +if (mm_flags_test (MMF_VM_HUGEPAGE , oldmm))__khugepaged_enter (mm); }static inline void khugepaged_exit (struct mm_struct *mm) { -if (test_bit (MMF_VM_HUGEPAGE , &mm->flags)) +if (mm_flags_test (MMF_VM_HUGEPAGE , mm))__khugepaged_exit (mm); }#else /* CONFIG_TRANSPARENT_HUGEPAGE */
include/linux/ksm.h +3 -3
@@ -56,13 +56,13 @@ static inline long mm_ksm_zero_pages(struct mm_struct *mm)static inline void ksm_fork (struct mm_struct *mm,struct mm_struct *oldmm) {/* Adding mm to ksm is best effort on fork. */ -if (test_bit (MMF_VM_MERGEABLE , &oldmm->flags)) +if (mm_flags_test (MMF_VM_MERGEABLE , oldmm))__ksm_enter (mm); }static inline int ksm_execve (struct mm_struct *mm) { -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return __ksm_enter (mm);return 0 ;
@@ -70,7 +70,7 @@ static inline int ksm_execve(struct mm_struct *mm)static inline void ksm_exit (struct mm_struct *mm) { -if (test_bit (MMF_VM_MERGEABLE , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGEABLE , mm))__ksm_exit (mm); }
include/linux/mm.h +1 -1
@@ -1949,7 +1949,7 @@ static inline bool folio_needs_cow_for_dma(struct vm_area_struct *vma, {VM_BUG_ON (!(raw_read_seqcount (&vma->vm_mm->write_protect_seq) &1 )); -if (!test_bit (MMF_HAS_PINNED , &vma->vm_mm->flags)) +if (!mm_flags_test (MMF_HAS_PINNED , vma->vm_mm))return false;return folio_maybe_dma_pinned (folio);
include/linux/mman.h +1 -1
@@ -201,7 +201,7 @@ static inline bool arch_memory_deny_write_exec_supported(void)static inline bool map_deny_write_exec (unsigned long old,unsigned long new) {/* If MDWE is disabled, we have nothing to deny. */ -if (!test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (!mm_flags_test (MMF_HAS_MDWE , current->mm))return false;/* If the new VMA is not executable, we have nothing to deny. */
include/linux/oom.h +1 -1
@@ -91,7 +91,7 @@ static inline bool tsk_is_oom_victim(struct task_struct * tsk)*/ static inline vm_fault_t check_stable_address_space (struct mm_struct *mm) { -if (unlikely (test_bit (MMF_UNSTABLE , &mm->flags))) +if (unlikely (mm_flags_test (MMF_UNSTABLE , mm)))return VM_FAULT_SIGBUS ;return 0 ; }
mm/debug.c +2 -2
@@ -182,7 +182,7 @@ void dump_mm(const struct mm_struct *mm)"start_code %lx end_code %lx start_data %lx end_data %lx\n" "start_brk %lx brk %lx start_stack %lx\n" "arg_start %lx arg_end %lx env_start %lx env_end %lx\n" -"binfmt %px flags %lx\n" +"binfmt %px flags %*pb\n" #ifdef CONFIG_AIO"ioctx_table %px\n" #endif
@@ -211,7 +211,7 @@ void dump_mm(const struct mm_struct *mm) mm->start_code, mm->end_code, mm->start_data, mm->end_data, mm->start_brk, mm->brk, mm->start_stack, mm->arg_start, mm->arg_end, mm->env_start, mm->env_end, - mm->binfmt, mm->flags, + mm->binfmt,NUM_MM_FLAG_BITS ,__mm_flags_get_bitmap (mm), #ifdef CONFIG_AIO mm->ioctx_table, #endif
mm/gup.c +5 -5
@@ -475,10 +475,10 @@ EXPORT_SYMBOL_GPL(unpin_folios);* lifecycle. Avoid setting the bit unless necessary, or it might cause write * cache bouncing on large SMP machines for concurrent pinned gups. */ -static inline void mm_set_has_pinned_flag (unsigned long *mm_flags) +static inline void mm_set_has_pinned_flag (struct mm_struct *mm) { -if (!test_bit (MMF_HAS_PINNED , mm_flags)) -set_bit (MMF_HAS_PINNED , mm_flags); +if (!mm_flags_test (MMF_HAS_PINNED , mm)) +mm_flags_set (MMF_HAS_PINNED , mm); }#ifdef CONFIG_MMU
@@ -1693,7 +1693,7 @@ static __always_inline long __get_user_pages_locked(struct mm_struct *mm,mmap_assert_locked (mm);if (flags &FOLL_PIN ) -mm_set_has_pinned_flag (&mm->flags); +mm_set_has_pinned_flag (mm);/* * FOLL_PIN and FOLL_GET are mutually exclusive. Traditional behavior
@@ -3210,7 +3210,7 @@ static int gup_fast_fallback(unsigned long start, unsigned long nr_pages,return -EINVAL ;if (gup_flags &FOLL_PIN ) -mm_set_has_pinned_flag (¤t->mm->flags); +mm_set_has_pinned_flag (current->mm);if (!(gup_flags &FOLL_FAST_ONLY ))might_lock_read (¤t->mm->mmap_lock);
mm/huge_memory.c +4 -4
@@ -251,13 +251,13 @@ struct folio *mm_get_huge_zero_folio(struct mm_struct *mm)if (IS_ENABLED (CONFIG_PERSISTENT_HUGE_ZERO_FOLIO ))return huge_zero_folio; -if (test_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test (MMF_HUGE_ZERO_FOLIO , mm))return READ_ONCE (huge_zero_folio);if (!get_huge_zero_folio ())return NULL ; -if (test_and_set_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test_and_set (MMF_HUGE_ZERO_FOLIO , mm))put_huge_zero_folio ();return READ_ONCE (huge_zero_folio);
@@ -268,7 +268,7 @@ void mm_put_huge_zero_folio(struct mm_struct *mm)if (IS_ENABLED (CONFIG_PERSISTENT_HUGE_ZERO_FOLIO ))return ; -if (test_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test (MMF_HUGE_ZERO_FOLIO , mm))put_huge_zero_folio (); }
@@ -1145,7 +1145,7 @@ static unsigned long __thp_get_unmapped_area(struct file *filp, off_sub = (off - ret) & (size -1 ); -if (test_bit (MMF_TOPDOWN , ¤t->mm->flags) && !off_sub) +if (mm_flags_test (MMF_TOPDOWN , current->mm) && !off_sub)return ret + size; ret += off_sub;
mm/khugepaged.c +5 -5
@@ -410,7 +410,7 @@ static inline int hpage_collapse_test_exit(struct mm_struct *mm)static inline int hpage_collapse_test_exit_or_disable (struct mm_struct *mm) {return hpage_collapse_test_exit (mm) || -test_bit (MMF_DISABLE_THP , &mm->flags); +mm_flags_test (MMF_DISABLE_THP , mm); }static bool hugepage_pmd_enabled (void )
@@ -445,7 +445,7 @@ void __khugepaged_enter(struct mm_struct *mm)/* __khugepaged_exit() must not run from under us */ VM_BUG_ON_MM (hpage_collapse_test_exit (mm), mm); -if (unlikely (test_and_set_bit (MMF_VM_HUGEPAGE , &mm->flags))) +if (unlikely (mm_flags_test_and_set (MMF_VM_HUGEPAGE , mm)))return ; mm_slot =mm_slot_alloc (mm_slot_cache);
@@ -472,7 +472,7 @@ void __khugepaged_enter(struct mm_struct *mm)void khugepaged_enter_vma (struct vm_area_struct *vma,vm_flags_t vm_flags) { -if (!test_bit (MMF_VM_HUGEPAGE , &vma->vm_mm->flags) && +if (!mm_flags_test (MMF_VM_HUGEPAGE , vma->vm_mm) &&hugepage_pmd_enabled ()) {if (thp_vma_allowable_order (vma, vm_flags,TVA_ENFORCE_SYSFS ,PMD_ORDER ))
@@ -497,7 +497,7 @@ void __khugepaged_exit(struct mm_struct *mm)spin_unlock (&khugepaged_mm_lock);if (free) { -clear_bit (MMF_VM_HUGEPAGE , &mm->flags); +mm_flags_clear (MMF_VM_HUGEPAGE , mm);mm_slot_free (mm_slot_cache, mm_slot);mmdrop (mm); }else if (mm_slot) {
@@ -1459,7 +1459,7 @@ static void collect_mm_slot(struct khugepaged_mm_slot *mm_slot)/* * Not strictly needed because the mm exited already. * -* clear_bit(MMF_VM_HUGEPAGE, &mm->flags); +* mm_clear(mm, MMF_VM_HUGEPAGE); */ /* khugepaged_mm_lock actually not necessary for the below */
mm/ksm.c +16 -16
@@ -1217,8 +1217,8 @@ static int unmerge_and_remove_all_rmap_items(void)spin_unlock (&ksm_mmlist_lock);mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGEABLE , mm); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);mmdrop (mm); }else spin_unlock (&ksm_mmlist_lock);
@@ -2620,8 +2620,8 @@ static struct ksm_rmap_item *scan_get_next_rmap_item(struct page **page)spin_unlock (&ksm_mmlist_lock);mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGEABLE , mm); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);mmap_read_unlock (mm);mmdrop (mm); }else {
@@ -2742,7 +2742,7 @@ static int __ksm_del_vma(struct vm_area_struct *vma)vm_flags_t ksm_vma_flags (const struct mm_struct *mm,const struct file *file,vm_flags_t vm_flags) { -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags) && +if (mm_flags_test (MMF_VM_MERGE_ANY , mm) &&__ksm_should_add_vma (file, vm_flags)) vm_flags |=VM_MERGEABLE ;
@@ -2784,16 +2784,16 @@ int ksm_enable_merge_any(struct mm_struct *mm) {int err; -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return 0 ; -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) { +if (!mm_flags_test (MMF_VM_MERGEABLE , mm)) { err =__ksm_enter (mm);if (err)return err; } -set_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_set (MMF_VM_MERGE_ANY , mm);ksm_add_vmas (mm);return 0 ;
@@ -2815,7 +2815,7 @@ int ksm_disable_merge_any(struct mm_struct *mm) {int err; -if (!test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (!mm_flags_test (MMF_VM_MERGE_ANY , mm))return 0 ; err =ksm_del_vmas (mm);
@@ -2824,7 +2824,7 @@ int ksm_disable_merge_any(struct mm_struct *mm)return err; } -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);return 0 ; }
@@ -2832,9 +2832,9 @@ int ksm_disable(struct mm_struct *mm) {mmap_assert_write_locked (mm); -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) +if (!mm_flags_test (MMF_VM_MERGEABLE , mm))return 0 ; -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return ksm_disable_merge_any (mm);return ksm_del_vmas (mm); }
@@ -2852,7 +2852,7 @@ int ksm_madvise(struct vm_area_struct *vma, unsigned long start,if (!vma_ksm_compatible (vma))return 0 ; -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) { +if (!mm_flags_test (MMF_VM_MERGEABLE , mm)) { err =__ksm_enter (mm);if (err)return err;
@@ -2912,7 +2912,7 @@ int __ksm_enter(struct mm_struct *mm)list_add_tail (&slot->mm_node, &ksm_scan.mm_slot->slot.mm_node);spin_unlock (&ksm_mmlist_lock); -set_bit (MMF_VM_MERGEABLE , &mm->flags); +mm_flags_set (MMF_VM_MERGEABLE , mm);mmgrab (mm);if (needs_wakeup)
@@ -2954,8 +2954,8 @@ void __ksm_exit(struct mm_struct *mm)if (easy_to_free) {mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); +mm_flags_clear (MMF_VM_MERGE_ANY , mm); +mm_flags_clear (MMF_VM_MERGEABLE , mm);mmdrop (mm); }else if (mm_slot) {mmap_write_lock (mm);
mm/mmap.c +4 -4
@@ -802,7 +802,7 @@ unsigned long mm_get_unmapped_area_vmflags(struct mm_struct *mm, struct file *fi unsigned long pgoff, unsigned long flags, vm_flags_t vm_flags) { - if (test_bit(MMF_TOPDOWN, &mm->flags)) + if (mm_flags_test(MMF_TOPDOWN, mm)) return arch_get_unmapped_area_topdown(filp, addr, len, pgoff, flags, vm_flags);return arch_get_unmapped_area (filp, addr, len, pgoff, flags, vm_flags);
@@ -1284,7 +1284,7 @@ void exit_mmap(struct mm_struct *mm)* Set MMF_OOM_SKIP to hide this task from the oom killer/reaper * because the memory has been already freed. */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);mmap_write_lock (mm);mt_clear_in_rcu (&mm->mm_mt);vma_iter_set (&vmi, vma->vm_end);
@@ -1859,14 +1859,14 @@ __latent_entropy int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)mas_set_range (&vmi.mas, mpnt->vm_start, mpnt->vm_end -1 );mas_store (&vmi.mas,XA_ZERO_ENTRY );/* Avoid OOM iterating a broken tree */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm); }/* * The mm_struct is going to exit, but the locks will be dropped * first. Set the mm_struct as unstable is advisable as it is * not fully initialised. */ -set_bit (MMF_UNSTABLE , &mm->flags); +mm_flags_set (MMF_UNSTABLE , mm); } out:mmap_write_unlock (mm);
mm/oom_kill.c +13 -13
@@ -1,7 +1,7 @@// SPDX-License-Identifier: GPL-2.0-only /* * linux/mm/oom_kill.c -* +* * Copyright (C) 1998,2000 Rik van Riel * Thanks go out to Claus Fischer for some serious inspiration and * for goading me into coding this file...
@@ -218,7 +218,7 @@ long oom_badness(struct task_struct *p, unsigned long totalpages)*/ adj = (long )p->signal->oom_score_adj;if (adj ==OOM_SCORE_ADJ_MIN || -test_bit (MMF_OOM_SKIP , &p->mm->flags) || +mm_flags_test (MMF_OOM_SKIP , p->mm) ||in_vfork (p)) {task_unlock (p);return LONG_MIN ;
@@ -325,7 +325,7 @@ static int oom_evaluate_task(struct task_struct *task, void *arg)* any memory is quite low. */ if (!is_sysrq_oom (oc) &&tsk_is_oom_victim (task)) { -if (test_bit (MMF_OOM_SKIP , &task->signal->oom_mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , task->signal->oom_mm)) goto next; goto abort; }
@@ -524,7 +524,7 @@ static bool __oom_reap_task_mm(struct mm_struct *mm)* should imply barriers already and the reader would hit a page fault * if it stumbled over a reaped memory. */ -set_bit (MMF_UNSTABLE , &mm->flags); +mm_flags_set (MMF_UNSTABLE , mm);for_each_vma (vmi, vma) {if (vma->vm_flags & (VM_HUGETLB |VM_PFNMAP ))
@@ -583,7 +583,7 @@ static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)* under mmap_lock for reading because it serializes against the * mmap_write_lock();mmap_write_unlock() cycle in exit_mmap(). */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) { +if (mm_flags_test (MMF_OOM_SKIP , mm)) {trace_skip_task_reaping (tsk->pid); goto out_unlock; }
@@ -619,7 +619,7 @@ static void oom_reap_task(struct task_struct *tsk)schedule_timeout_idle (HZ /10 );if (attempts <=MAX_OOM_REAP_RETRIES || -test_bit (MMF_OOM_SKIP , &mm->flags)) +mm_flags_test (MMF_OOM_SKIP , mm)) goto done; pr_info("oom_reaper: unable to reap pid:%d (%s)\n",
@@ -634,7 +634,7 @@ static void oom_reap_task(struct task_struct *tsk)* Hide this mm from OOM killer because it has been either reaped or * somebody can't call mmap_write_unlock(mm). */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);/* Drop a reference taken by queue_oom_reaper */ put_task_struct (tsk);
@@ -670,7 +670,7 @@ static void wake_oom_reaper(struct timer_list *timer)unsigned long flags;/* The victim managed to terminate on its own - see exit_mmap */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) { +if (mm_flags_test (MMF_OOM_SKIP , mm)) {put_task_struct (tsk);return ; }
@@ -695,7 +695,7 @@ static void wake_oom_reaper(struct timer_list *timer)static void queue_oom_reaper (struct task_struct *tsk) {/* mm is already queued? */ -if (test_and_set_bit (MMF_OOM_REAP_QUEUED , &tsk->signal->oom_mm->flags)) +if (mm_flags_test_and_set (MMF_OOM_REAP_QUEUED , tsk->signal->oom_mm))return ;get_task_struct (tsk);
@@ -892,7 +892,7 @@ static bool task_will_free_mem(struct task_struct *task)* This task has already been drained by the oom reaper so there are * only small chances it will free some more */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , mm))return false;if (atomic_read (&mm->mm_users) <=1 )
@@ -977,7 +977,7 @@ static void __oom_kill_process(struct task_struct *victim, const char *message)continue ;if (is_global_init (p)) { can_oom_reap = false; -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);pr_info ("oom killer %d (%s) has mm pinned by %d (%s)\n" ,task_pid_nr (victim), victim->comm,task_pid_nr (p), p->comm);
@@ -1235,7 +1235,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) reap = true; else {/* Error only if the work has not been done already */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags)) +if (!mm_flags_test (MMF_OOM_SKIP , mm)) ret = -EINVAL ; }task_unlock (p);
@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);
mm/util.c +3 -3
@@ -471,17 +471,17 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)if (mmap_is_legacy (rlim_stack)) { mm->mmap_base =TASK_UNMAPPED_BASE + random_factor; -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }else { mm->mmap_base =mmap_base (random_factor, rlim_stack); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); } }#elif defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)void arch_pick_mmap_layout (struct mm_struct *mm,struct rlimit *rlim_stack) { mm->mmap_base =TASK_UNMAPPED_BASE ; -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }#endif #ifdef CONFIG_MMU
Signature · 1 line
2.50.1
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 11 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 574 lines
--- include/linux/huge_mm.h | 2 +- include/linux/khugepaged.h | 6 ++++-- include/linux/ksm.h | 6 +++--- include/linux/mm.h | 2 +- include/linux/mman.h | 2 +- include/linux/oom.h | 2 +- mm/debug.c | 4 ++-- mm/gup.c | 10 +++++----- mm/huge_memory.c | 8 ++++---- mm/khugepaged.c | 10 +++++----- mm/ksm.c | 32 ++++++++++++++++---------------- mm/mmap.c | 8 ++++---- mm/oom_kill.c | 26 +++++++++++++------------- mm/util.c | 6 +++--- 14 files changed, 63 insertions(+), 61 deletions(-)include/linux/huge_mm.h +1
-1@@ -327,7 +327,7 @@ static inline bool vma_thp_disabled(struct vm_area_struct *vma,* example, s390 kvm. */ return (vm_flags &VM_NOHUGEPAGE ) || -test_bit (MMF_DISABLE_THP , &vma->vm_mm->flags); +mm_flags_test (MMF_DISABLE_THP , vma->vm_mm); }static inline bool thp_disabled_by_hw (void )include/linux/khugepaged.h +4
-2@@ -2,6 +2,8 @@#ifndef _LINUX_KHUGEPAGED_H#define _LINUX_KHUGEPAGED_H +#include <linux/mm.h> +extern unsigned int khugepaged_max_ptes_none__read_mostly ;#ifdef CONFIG_TRANSPARENT_HUGEPAGE extern struct attribute_group khugepaged_attr_group;@@ -20,13 +22,13 @@ extern int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr,static inline void khugepaged_fork (struct mm_struct *mm,struct mm_struct *oldmm) { -if (test_bit (MMF_VM_HUGEPAGE , &oldmm->flags)) +if (mm_flags_test (MMF_VM_HUGEPAGE , oldmm))__khugepaged_enter (mm); }static inline void khugepaged_exit (struct mm_struct *mm) { -if (test_bit (MMF_VM_HUGEPAGE , &mm->flags)) +if (mm_flags_test (MMF_VM_HUGEPAGE , mm))__khugepaged_exit (mm); }#else /* CONFIG_TRANSPARENT_HUGEPAGE */ include/linux/ksm.h +3
-3@@ -56,13 +56,13 @@ static inline long mm_ksm_zero_pages(struct mm_struct *mm)static inline void ksm_fork (struct mm_struct *mm,struct mm_struct *oldmm) {/* Adding mm to ksm is best effort on fork. */ -if (test_bit (MMF_VM_MERGEABLE , &oldmm->flags)) +if (mm_flags_test (MMF_VM_MERGEABLE , oldmm))__ksm_enter (mm); }static inline int ksm_execve (struct mm_struct *mm) { -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return __ksm_enter (mm);return 0 ;@@ -70,7 +70,7 @@ static inline int ksm_execve(struct mm_struct *mm)static inline void ksm_exit (struct mm_struct *mm) { -if (test_bit (MMF_VM_MERGEABLE , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGEABLE , mm))__ksm_exit (mm); }include/linux/mm.h +1
-1@@ -1949,7 +1949,7 @@ static inline bool folio_needs_cow_for_dma(struct vm_area_struct *vma, {VM_BUG_ON (!(raw_read_seqcount (&vma->vm_mm->write_protect_seq) &1 )); -if (!test_bit (MMF_HAS_PINNED , &vma->vm_mm->flags)) +if (!mm_flags_test (MMF_HAS_PINNED , vma->vm_mm))return false;return folio_maybe_dma_pinned (folio);include/linux/mman.h +1
-1@@ -201,7 +201,7 @@ static inline bool arch_memory_deny_write_exec_supported(void)static inline bool map_deny_write_exec (unsigned long old,unsigned long new) {/* If MDWE is disabled, we have nothing to deny. */ -if (!test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (!mm_flags_test (MMF_HAS_MDWE , current->mm))return false;/* If the new VMA is not executable, we have nothing to deny. */ include/linux/oom.h +1
-1@@ -91,7 +91,7 @@ static inline bool tsk_is_oom_victim(struct task_struct * tsk)*/ static inline vm_fault_t check_stable_address_space (struct mm_struct *mm) { -if (unlikely (test_bit (MMF_UNSTABLE , &mm->flags))) +if (unlikely (mm_flags_test (MMF_UNSTABLE , mm)))return VM_FAULT_SIGBUS ;return 0 ; }mm/debug.c +2
-2@@ -182,7 +182,7 @@ void dump_mm(const struct mm_struct *mm)"start_code %lx end_code %lx start_data %lx end_data %lx\n" "start_brk %lx brk %lx start_stack %lx\n" "arg_start %lx arg_end %lx env_start %lx env_end %lx\n" -"binfmt %px flags %lx\n" +"binfmt %px flags %*pb\n" #ifdef CONFIG_AIO"ioctx_table %px\n" #endif@@ -211,7 +211,7 @@ void dump_mm(const struct mm_struct *mm) mm->start_code, mm->end_code, mm->start_data, mm->end_data, mm->start_brk, mm->brk, mm->start_stack, mm->arg_start, mm->arg_end, mm->env_start, mm->env_end, - mm->binfmt, mm->flags, + mm->binfmt,NUM_MM_FLAG_BITS ,__mm_flags_get_bitmap (mm), #ifdef CONFIG_AIO mm->ioctx_table, #endifmm/gup.c +5
-5@@ -475,10 +475,10 @@ EXPORT_SYMBOL_GPL(unpin_folios);* lifecycle. Avoid setting the bit unless necessary, or it might cause write * cache bouncing on large SMP machines for concurrent pinned gups. */ -static inline void mm_set_has_pinned_flag (unsigned long *mm_flags) +static inline void mm_set_has_pinned_flag (struct mm_struct *mm) { -if (!test_bit (MMF_HAS_PINNED , mm_flags)) -set_bit (MMF_HAS_PINNED , mm_flags); +if (!mm_flags_test (MMF_HAS_PINNED , mm)) +mm_flags_set (MMF_HAS_PINNED , mm); }#ifdef CONFIG_MMU @@ -1693,7 +1693,7 @@ static __always_inline long __get_user_pages_locked(struct mm_struct *mm,mmap_assert_locked (mm);if (flags &FOLL_PIN ) -mm_set_has_pinned_flag (&mm->flags); +mm_set_has_pinned_flag (mm);/* * FOLL_PIN and FOLL_GET are mutually exclusive. Traditional behavior @@ -3210,7 +3210,7 @@ static int gup_fast_fallback(unsigned long start, unsigned long nr_pages,return -EINVAL ;if (gup_flags &FOLL_PIN ) -mm_set_has_pinned_flag (¤t->mm->flags); +mm_set_has_pinned_flag (current->mm);if (!(gup_flags &FOLL_FAST_ONLY ))might_lock_read (¤t->mm->mmap_lock);mm/huge_memory.c +4
-4@@ -251,13 +251,13 @@ struct folio *mm_get_huge_zero_folio(struct mm_struct *mm)if (IS_ENABLED (CONFIG_PERSISTENT_HUGE_ZERO_FOLIO ))return huge_zero_folio; -if (test_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test (MMF_HUGE_ZERO_FOLIO , mm))return READ_ONCE (huge_zero_folio);if (!get_huge_zero_folio ())return NULL ; -if (test_and_set_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test_and_set (MMF_HUGE_ZERO_FOLIO , mm))put_huge_zero_folio ();return READ_ONCE (huge_zero_folio);@@ -268,7 +268,7 @@ void mm_put_huge_zero_folio(struct mm_struct *mm)if (IS_ENABLED (CONFIG_PERSISTENT_HUGE_ZERO_FOLIO ))return ; -if (test_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test (MMF_HUGE_ZERO_FOLIO , mm))put_huge_zero_folio (); }@@ -1145,7 +1145,7 @@ static unsigned long __thp_get_unmapped_area(struct file *filp, off_sub = (off - ret) & (size -1 ); -if (test_bit (MMF_TOPDOWN , ¤t->mm->flags) && !off_sub) +if (mm_flags_test (MMF_TOPDOWN , current->mm) && !off_sub)return ret + size; ret += off_sub;mm/khugepaged.c +5
-5@@ -410,7 +410,7 @@ static inline int hpage_collapse_test_exit(struct mm_struct *mm)static inline int hpage_collapse_test_exit_or_disable (struct mm_struct *mm) {return hpage_collapse_test_exit (mm) || -test_bit (MMF_DISABLE_THP , &mm->flags); +mm_flags_test (MMF_DISABLE_THP , mm); }static bool hugepage_pmd_enabled (void )@@ -445,7 +445,7 @@ void __khugepaged_enter(struct mm_struct *mm)/* __khugepaged_exit() must not run from under us */ VM_BUG_ON_MM (hpage_collapse_test_exit (mm), mm); -if (unlikely (test_and_set_bit (MMF_VM_HUGEPAGE , &mm->flags))) +if (unlikely (mm_flags_test_and_set (MMF_VM_HUGEPAGE , mm)))return ; mm_slot =mm_slot_alloc (mm_slot_cache);@@ -472,7 +472,7 @@ void __khugepaged_enter(struct mm_struct *mm)void khugepaged_enter_vma (struct vm_area_struct *vma,vm_flags_t vm_flags) { -if (!test_bit (MMF_VM_HUGEPAGE , &vma->vm_mm->flags) && +if (!mm_flags_test (MMF_VM_HUGEPAGE , vma->vm_mm) &&hugepage_pmd_enabled ()) {if (thp_vma_allowable_order (vma, vm_flags,TVA_ENFORCE_SYSFS ,PMD_ORDER ))@@ -497,7 +497,7 @@ void __khugepaged_exit(struct mm_struct *mm)spin_unlock (&khugepaged_mm_lock);if (free) { -clear_bit (MMF_VM_HUGEPAGE , &mm->flags); +mm_flags_clear (MMF_VM_HUGEPAGE , mm);mm_slot_free (mm_slot_cache, mm_slot);mmdrop (mm); }else if (mm_slot) {@@ -1459,7 +1459,7 @@ static void collect_mm_slot(struct khugepaged_mm_slot *mm_slot)/* * Not strictly needed because the mm exited already. * -* clear_bit(MMF_VM_HUGEPAGE, &mm->flags); +* mm_clear(mm, MMF_VM_HUGEPAGE); */ /* khugepaged_mm_lock actually not necessary for the below */ mm/ksm.c +16
-16@@ -1217,8 +1217,8 @@ static int unmerge_and_remove_all_rmap_items(void)spin_unlock (&ksm_mmlist_lock);mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGEABLE , mm); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);mmdrop (mm); }else spin_unlock (&ksm_mmlist_lock);@@ -2620,8 +2620,8 @@ static struct ksm_rmap_item *scan_get_next_rmap_item(struct page **page)spin_unlock (&ksm_mmlist_lock);mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGEABLE , mm); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);mmap_read_unlock (mm);mmdrop (mm); }else {@@ -2742,7 +2742,7 @@ static int __ksm_del_vma(struct vm_area_struct *vma)vm_flags_t ksm_vma_flags (const struct mm_struct *mm,const struct file *file,vm_flags_t vm_flags) { -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags) && +if (mm_flags_test (MMF_VM_MERGE_ANY , mm) &&__ksm_should_add_vma (file, vm_flags)) vm_flags |=VM_MERGEABLE ;@@ -2784,16 +2784,16 @@ int ksm_enable_merge_any(struct mm_struct *mm) {int err; -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return 0 ; -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) { +if (!mm_flags_test (MMF_VM_MERGEABLE , mm)) { err =__ksm_enter (mm);if (err)return err; } -set_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_set (MMF_VM_MERGE_ANY , mm);ksm_add_vmas (mm);return 0 ;@@ -2815,7 +2815,7 @@ int ksm_disable_merge_any(struct mm_struct *mm) {int err; -if (!test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (!mm_flags_test (MMF_VM_MERGE_ANY , mm))return 0 ; err =ksm_del_vmas (mm);@@ -2824,7 +2824,7 @@ int ksm_disable_merge_any(struct mm_struct *mm)return err; } -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);return 0 ; }@@ -2832,9 +2832,9 @@ int ksm_disable(struct mm_struct *mm) {mmap_assert_write_locked (mm); -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) +if (!mm_flags_test (MMF_VM_MERGEABLE , mm))return 0 ; -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return ksm_disable_merge_any (mm);return ksm_del_vmas (mm); }@@ -2852,7 +2852,7 @@ int ksm_madvise(struct vm_area_struct *vma, unsigned long start,if (!vma_ksm_compatible (vma))return 0 ; -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) { +if (!mm_flags_test (MMF_VM_MERGEABLE , mm)) { err =__ksm_enter (mm);if (err)return err;@@ -2912,7 +2912,7 @@ int __ksm_enter(struct mm_struct *mm)list_add_tail (&slot->mm_node, &ksm_scan.mm_slot->slot.mm_node);spin_unlock (&ksm_mmlist_lock); -set_bit (MMF_VM_MERGEABLE , &mm->flags); +mm_flags_set (MMF_VM_MERGEABLE , mm);mmgrab (mm);if (needs_wakeup)@@ -2954,8 +2954,8 @@ void __ksm_exit(struct mm_struct *mm)if (easy_to_free) {mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); +mm_flags_clear (MMF_VM_MERGE_ANY , mm); +mm_flags_clear (MMF_VM_MERGEABLE , mm);mmdrop (mm); }else if (mm_slot) {mmap_write_lock (mm);mm/mmap.c +4
-4@@ -802,7 +802,7 @@ unsigned long mm_get_unmapped_area_vmflags(struct mm_struct *mm, struct file *fi unsigned long pgoff, unsigned long flags, vm_flags_t vm_flags) { - if (test_bit(MMF_TOPDOWN, &mm->flags)) + if (mm_flags_test(MMF_TOPDOWN, mm)) return arch_get_unmapped_area_topdown(filp, addr, len, pgoff, flags, vm_flags);return arch_get_unmapped_area (filp, addr, len, pgoff, flags, vm_flags);@@ -1284,7 +1284,7 @@ void exit_mmap(struct mm_struct *mm)* Set MMF_OOM_SKIP to hide this task from the oom killer/reaper * because the memory has been already freed. */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);mmap_write_lock (mm);mt_clear_in_rcu (&mm->mm_mt);vma_iter_set (&vmi, vma->vm_end);@@ -1859,14 +1859,14 @@ __latent_entropy int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)mas_set_range (&vmi.mas, mpnt->vm_start, mpnt->vm_end -1 );mas_store (&vmi.mas,XA_ZERO_ENTRY );/* Avoid OOM iterating a broken tree */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm); }/* * The mm_struct is going to exit, but the locks will be dropped * first. Set the mm_struct as unstable is advisable as it is * not fully initialised. */ -set_bit (MMF_UNSTABLE , &mm->flags); +mm_flags_set (MMF_UNSTABLE , mm); } out:mmap_write_unlock (mm);mm/oom_kill.c +13
-13@@ -1,7 +1,7 @@// SPDX-License-Identifier: GPL-2.0-only /* * linux/mm/oom_kill.c -* +* * Copyright (C) 1998,2000 Rik van Riel * Thanks go out to Claus Fischer for some serious inspiration and * for goading me into coding this file... @@ -218,7 +218,7 @@ long oom_badness(struct task_struct *p, unsigned long totalpages)*/ adj = (long )p->signal->oom_score_adj;if (adj ==OOM_SCORE_ADJ_MIN || -test_bit (MMF_OOM_SKIP , &p->mm->flags) || +mm_flags_test (MMF_OOM_SKIP , p->mm) ||in_vfork (p)) {task_unlock (p);return LONG_MIN ;@@ -325,7 +325,7 @@ static int oom_evaluate_task(struct task_struct *task, void *arg)* any memory is quite low. */ if (!is_sysrq_oom (oc) &&tsk_is_oom_victim (task)) { -if (test_bit (MMF_OOM_SKIP , &task->signal->oom_mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , task->signal->oom_mm)) goto next; goto abort; }@@ -524,7 +524,7 @@ static bool __oom_reap_task_mm(struct mm_struct *mm)* should imply barriers already and the reader would hit a page fault * if it stumbled over a reaped memory. */ -set_bit (MMF_UNSTABLE , &mm->flags); +mm_flags_set (MMF_UNSTABLE , mm);for_each_vma (vmi, vma) {if (vma->vm_flags & (VM_HUGETLB |VM_PFNMAP ))@@ -583,7 +583,7 @@ static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)* under mmap_lock for reading because it serializes against the * mmap_write_lock();mmap_write_unlock() cycle in exit_mmap(). */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) { +if (mm_flags_test (MMF_OOM_SKIP , mm)) {trace_skip_task_reaping (tsk->pid); goto out_unlock; }@@ -619,7 +619,7 @@ static void oom_reap_task(struct task_struct *tsk)schedule_timeout_idle (HZ /10 );if (attempts <=MAX_OOM_REAP_RETRIES || -test_bit (MMF_OOM_SKIP , &mm->flags)) +mm_flags_test (MMF_OOM_SKIP , mm)) goto done; pr_info("oom_reaper: unable to reap pid:%d (%s)\n",@@ -634,7 +634,7 @@ static void oom_reap_task(struct task_struct *tsk)* Hide this mm from OOM killer because it has been either reaped or * somebody can't call mmap_write_unlock(mm). */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);/* Drop a reference taken by queue_oom_reaper */ put_task_struct (tsk);@@ -670,7 +670,7 @@ static void wake_oom_reaper(struct timer_list *timer)unsigned long flags;/* The victim managed to terminate on its own - see exit_mmap */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) { +if (mm_flags_test (MMF_OOM_SKIP , mm)) {put_task_struct (tsk);return ; }@@ -695,7 +695,7 @@ static void wake_oom_reaper(struct timer_list *timer)static void queue_oom_reaper (struct task_struct *tsk) {/* mm is already queued? */ -if (test_and_set_bit (MMF_OOM_REAP_QUEUED , &tsk->signal->oom_mm->flags)) +if (mm_flags_test_and_set (MMF_OOM_REAP_QUEUED , tsk->signal->oom_mm))return ;get_task_struct (tsk);@@ -892,7 +892,7 @@ static bool task_will_free_mem(struct task_struct *task)* This task has already been drained by the oom reaper so there are * only small chances it will free some more */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , mm))return false;if (atomic_read (&mm->mm_users) <=1 )@@ -977,7 +977,7 @@ static void __oom_kill_process(struct task_struct *victim, const char *message)continue ;if (is_global_init (p)) { can_oom_reap = false; -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);pr_info ("oom killer %d (%s) has mm pinned by %d (%s)\n" ,task_pid_nr (victim), victim->comm,task_pid_nr (p), p->comm);@@ -1235,7 +1235,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) reap = true; else {/* Error only if the work has not been done already */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags)) +if (!mm_flags_test (MMF_OOM_SKIP , mm)) ret = -EINVAL ; }task_unlock (p);@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);mm/util.c +3
-3@@ -471,17 +471,17 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)if (mmap_is_legacy (rlim_stack)) { mm->mmap_base =TASK_UNMAPPED_BASE + random_factor; -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }else { mm->mmap_base =mmap_base (random_factor, rlim_stack); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); } }#elif defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)void arch_pick_mmap_layout (struct mm_struct *mm,struct rlimit *rlim_stack) { mm->mmap_base =TASK_UNMAPPED_BASE ; -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }#endif #ifdef CONFIG_MMU Signature · 1 line
2.50.1
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 9 lines · On Tue, 12 Aug 2025 16:44:11 +0100 Lorenzo Stoakes…
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Code is obviously buggy - you cannot possibly have tested it.
mm/khugepaged.c renamed from mm/khugepaged.c~mm-convert-core-mm-to-mm_flags_-accessors-fix +1 -1
@@ -1459,7 +1459,7 @@ static void collect_mm_slot(struct khuge/* * Not strictly needed because the mm exited already. * -* mm_clear(mm, MMF_VM_HUGEPAGE); +* mm_flags_clear(MMF_VM_HUGEPAGE, mm); */ /* khugepaged_mm_lock actually not necessary for the below */
there, fixed.
I applied the series to mm-new, thanks. Emails were suppressed out of kindness.
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 26 lines · Andrew Morton
Quoted 9 lines · On Tue, 12 Aug 2025 16:44:11 +0100 Lorenzo Stoakes…
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Code is obviously buggy - you cannot possibly have tested it.
mm/khugepaged.c renamed from mm/khugepaged.c~mm-convert-core-mm-to-mm_flags_-accessors-fix +1
-1@@ -1459,7 +1459,7 @@ static void collect_mm_slot(struct khuge/* * Not strictly needed because the mm exited already. * -* mm_clear(mm, MMF_VM_HUGEPAGE); +* mm_flags_clear(MMF_VM_HUGEPAGE, mm); */ /* khugepaged_mm_lock actually not necessary for the below */
Quoted 1 line
there, fixed.
Haha thanks!
Quoted 4 lines
I applied the series to mm-new, thanks. Emails were suppressed out of kindness.
Yes, probably for the best :)
Cheers, Lorenzo
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 11 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 574 lines
--- include/linux/huge_mm.h | 2 +- include/linux/khugepaged.h | 6 ++++-- include/linux/ksm.h | 6 +++--- include/linux/mm.h | 2 +- include/linux/mman.h | 2 +- include/linux/oom.h | 2 +- mm/debug.c | 4 ++-- mm/gup.c | 10 +++++----- mm/huge_memory.c | 8 ++++---- mm/khugepaged.c | 10 +++++----- mm/ksm.c | 32 ++++++++++++++++---------------- mm/mmap.c | 8 ++++---- mm/oom_kill.c | 26 +++++++++++++------------- mm/util.c | 6 +++--- 14 files changed, 63 insertions(+), 61 deletions(-)include/linux/huge_mm.h +1
-1@@ -327,7 +327,7 @@ static inline bool vma_thp_disabled(struct vm_area_struct *vma,* example, s390 kvm. */ return (vm_flags &VM_NOHUGEPAGE ) || -test_bit (MMF_DISABLE_THP , &vma->vm_mm->flags); +mm_flags_test (MMF_DISABLE_THP , vma->vm_mm); }static inline bool thp_disabled_by_hw (void )include/linux/khugepaged.h +4
-2@@ -2,6 +2,8 @@#ifndef _LINUX_KHUGEPAGED_H#define _LINUX_KHUGEPAGED_H +#include <linux/mm.h> +extern unsigned int khugepaged_max_ptes_none__read_mostly ;#ifdef CONFIG_TRANSPARENT_HUGEPAGE extern struct attribute_group khugepaged_attr_group;@@ -20,13 +22,13 @@ extern int collapse_pte_mapped_thp(struct mm_struct *mm, unsigned long addr,static inline void khugepaged_fork (struct mm_struct *mm,struct mm_struct *oldmm) { -if (test_bit (MMF_VM_HUGEPAGE , &oldmm->flags)) +if (mm_flags_test (MMF_VM_HUGEPAGE , oldmm))__khugepaged_enter (mm); }static inline void khugepaged_exit (struct mm_struct *mm) { -if (test_bit (MMF_VM_HUGEPAGE , &mm->flags)) +if (mm_flags_test (MMF_VM_HUGEPAGE , mm))__khugepaged_exit (mm); }#else /* CONFIG_TRANSPARENT_HUGEPAGE */ include/linux/ksm.h +3
-3@@ -56,13 +56,13 @@ static inline long mm_ksm_zero_pages(struct mm_struct *mm)static inline void ksm_fork (struct mm_struct *mm,struct mm_struct *oldmm) {/* Adding mm to ksm is best effort on fork. */ -if (test_bit (MMF_VM_MERGEABLE , &oldmm->flags)) +if (mm_flags_test (MMF_VM_MERGEABLE , oldmm))__ksm_enter (mm); }static inline int ksm_execve (struct mm_struct *mm) { -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return __ksm_enter (mm);return 0 ;@@ -70,7 +70,7 @@ static inline int ksm_execve(struct mm_struct *mm)static inline void ksm_exit (struct mm_struct *mm) { -if (test_bit (MMF_VM_MERGEABLE , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGEABLE , mm))__ksm_exit (mm); }include/linux/mm.h +1
-1@@ -1949,7 +1949,7 @@ static inline bool folio_needs_cow_for_dma(struct vm_area_struct *vma, {VM_BUG_ON (!(raw_read_seqcount (&vma->vm_mm->write_protect_seq) &1 )); -if (!test_bit (MMF_HAS_PINNED , &vma->vm_mm->flags)) +if (!mm_flags_test (MMF_HAS_PINNED , vma->vm_mm))return false;return folio_maybe_dma_pinned (folio);include/linux/mman.h +1
-1@@ -201,7 +201,7 @@ static inline bool arch_memory_deny_write_exec_supported(void)static inline bool map_deny_write_exec (unsigned long old,unsigned long new) {/* If MDWE is disabled, we have nothing to deny. */ -if (!test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (!mm_flags_test (MMF_HAS_MDWE , current->mm))return false;/* If the new VMA is not executable, we have nothing to deny. */ include/linux/oom.h +1
-1@@ -91,7 +91,7 @@ static inline bool tsk_is_oom_victim(struct task_struct * tsk)*/ static inline vm_fault_t check_stable_address_space (struct mm_struct *mm) { -if (unlikely (test_bit (MMF_UNSTABLE , &mm->flags))) +if (unlikely (mm_flags_test (MMF_UNSTABLE , mm)))return VM_FAULT_SIGBUS ;return 0 ; }mm/debug.c +2
-2@@ -182,7 +182,7 @@ void dump_mm(const struct mm_struct *mm)"start_code %lx end_code %lx start_data %lx end_data %lx\n" "start_brk %lx brk %lx start_stack %lx\n" "arg_start %lx arg_end %lx env_start %lx env_end %lx\n" -"binfmt %px flags %lx\n" +"binfmt %px flags %*pb\n" #ifdef CONFIG_AIO"ioctx_table %px\n" #endif@@ -211,7 +211,7 @@ void dump_mm(const struct mm_struct *mm) mm->start_code, mm->end_code, mm->start_data, mm->end_data, mm->start_brk, mm->brk, mm->start_stack, mm->arg_start, mm->arg_end, mm->env_start, mm->env_end, - mm->binfmt, mm->flags, + mm->binfmt,NUM_MM_FLAG_BITS ,__mm_flags_get_bitmap (mm), #ifdef CONFIG_AIO mm->ioctx_table, #endifmm/gup.c +5
-5@@ -475,10 +475,10 @@ EXPORT_SYMBOL_GPL(unpin_folios);* lifecycle. Avoid setting the bit unless necessary, or it might cause write * cache bouncing on large SMP machines for concurrent pinned gups. */ -static inline void mm_set_has_pinned_flag (unsigned long *mm_flags) +static inline void mm_set_has_pinned_flag (struct mm_struct *mm) { -if (!test_bit (MMF_HAS_PINNED , mm_flags)) -set_bit (MMF_HAS_PINNED , mm_flags); +if (!mm_flags_test (MMF_HAS_PINNED , mm)) +mm_flags_set (MMF_HAS_PINNED , mm); }#ifdef CONFIG_MMU @@ -1693,7 +1693,7 @@ static __always_inline long __get_user_pages_locked(struct mm_struct *mm,mmap_assert_locked (mm);if (flags &FOLL_PIN ) -mm_set_has_pinned_flag (&mm->flags); +mm_set_has_pinned_flag (mm);/* * FOLL_PIN and FOLL_GET are mutually exclusive. Traditional behavior @@ -3210,7 +3210,7 @@ static int gup_fast_fallback(unsigned long start, unsigned long nr_pages,return -EINVAL ;if (gup_flags &FOLL_PIN ) -mm_set_has_pinned_flag (¤t->mm->flags); +mm_set_has_pinned_flag (current->mm);if (!(gup_flags &FOLL_FAST_ONLY ))might_lock_read (¤t->mm->mmap_lock);mm/huge_memory.c +4
-4@@ -251,13 +251,13 @@ struct folio *mm_get_huge_zero_folio(struct mm_struct *mm)if (IS_ENABLED (CONFIG_PERSISTENT_HUGE_ZERO_FOLIO ))return huge_zero_folio; -if (test_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test (MMF_HUGE_ZERO_FOLIO , mm))return READ_ONCE (huge_zero_folio);if (!get_huge_zero_folio ())return NULL ; -if (test_and_set_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test_and_set (MMF_HUGE_ZERO_FOLIO , mm))put_huge_zero_folio ();return READ_ONCE (huge_zero_folio);@@ -268,7 +268,7 @@ void mm_put_huge_zero_folio(struct mm_struct *mm)if (IS_ENABLED (CONFIG_PERSISTENT_HUGE_ZERO_FOLIO ))return ; -if (test_bit (MMF_HUGE_ZERO_FOLIO , &mm->flags)) +if (mm_flags_test (MMF_HUGE_ZERO_FOLIO , mm))put_huge_zero_folio (); }@@ -1145,7 +1145,7 @@ static unsigned long __thp_get_unmapped_area(struct file *filp, off_sub = (off - ret) & (size -1 ); -if (test_bit (MMF_TOPDOWN , ¤t->mm->flags) && !off_sub) +if (mm_flags_test (MMF_TOPDOWN , current->mm) && !off_sub)return ret + size; ret += off_sub;mm/khugepaged.c +5
-5@@ -410,7 +410,7 @@ static inline int hpage_collapse_test_exit(struct mm_struct *mm)static inline int hpage_collapse_test_exit_or_disable (struct mm_struct *mm) {return hpage_collapse_test_exit (mm) || -test_bit (MMF_DISABLE_THP , &mm->flags); +mm_flags_test (MMF_DISABLE_THP , mm); }static bool hugepage_pmd_enabled (void )@@ -445,7 +445,7 @@ void __khugepaged_enter(struct mm_struct *mm)/* __khugepaged_exit() must not run from under us */ VM_BUG_ON_MM (hpage_collapse_test_exit (mm), mm); -if (unlikely (test_and_set_bit (MMF_VM_HUGEPAGE , &mm->flags))) +if (unlikely (mm_flags_test_and_set (MMF_VM_HUGEPAGE , mm)))return ; mm_slot =mm_slot_alloc (mm_slot_cache);@@ -472,7 +472,7 @@ void __khugepaged_enter(struct mm_struct *mm)void khugepaged_enter_vma (struct vm_area_struct *vma,vm_flags_t vm_flags) { -if (!test_bit (MMF_VM_HUGEPAGE , &vma->vm_mm->flags) && +if (!mm_flags_test (MMF_VM_HUGEPAGE , vma->vm_mm) &&hugepage_pmd_enabled ()) {if (thp_vma_allowable_order (vma, vm_flags,TVA_ENFORCE_SYSFS ,PMD_ORDER ))@@ -497,7 +497,7 @@ void __khugepaged_exit(struct mm_struct *mm)spin_unlock (&khugepaged_mm_lock);if (free) { -clear_bit (MMF_VM_HUGEPAGE , &mm->flags); +mm_flags_clear (MMF_VM_HUGEPAGE , mm);mm_slot_free (mm_slot_cache, mm_slot);mmdrop (mm); }else if (mm_slot) {@@ -1459,7 +1459,7 @@ static void collect_mm_slot(struct khugepaged_mm_slot *mm_slot)/* * Not strictly needed because the mm exited already. * -* clear_bit(MMF_VM_HUGEPAGE, &mm->flags); +* mm_clear(mm, MMF_VM_HUGEPAGE); */ /* khugepaged_mm_lock actually not necessary for the below */ mm/ksm.c +16
-16@@ -1217,8 +1217,8 @@ static int unmerge_and_remove_all_rmap_items(void)spin_unlock (&ksm_mmlist_lock);mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGEABLE , mm); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);mmdrop (mm); }else spin_unlock (&ksm_mmlist_lock);@@ -2620,8 +2620,8 @@ static struct ksm_rmap_item *scan_get_next_rmap_item(struct page **page)spin_unlock (&ksm_mmlist_lock);mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGEABLE , mm); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);mmap_read_unlock (mm);mmdrop (mm); }else {@@ -2742,7 +2742,7 @@ static int __ksm_del_vma(struct vm_area_struct *vma)vm_flags_t ksm_vma_flags (const struct mm_struct *mm,const struct file *file,vm_flags_t vm_flags) { -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags) && +if (mm_flags_test (MMF_VM_MERGE_ANY , mm) &&__ksm_should_add_vma (file, vm_flags)) vm_flags |=VM_MERGEABLE ;@@ -2784,16 +2784,16 @@ int ksm_enable_merge_any(struct mm_struct *mm) {int err; -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return 0 ; -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) { +if (!mm_flags_test (MMF_VM_MERGEABLE , mm)) { err =__ksm_enter (mm);if (err)return err; } -set_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_set (MMF_VM_MERGE_ANY , mm);ksm_add_vmas (mm);return 0 ;@@ -2815,7 +2815,7 @@ int ksm_disable_merge_any(struct mm_struct *mm) {int err; -if (!test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (!mm_flags_test (MMF_VM_MERGE_ANY , mm))return 0 ; err =ksm_del_vmas (mm);@@ -2824,7 +2824,7 @@ int ksm_disable_merge_any(struct mm_struct *mm)return err; } -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); +mm_flags_clear (MMF_VM_MERGE_ANY , mm);return 0 ; }@@ -2832,9 +2832,9 @@ int ksm_disable(struct mm_struct *mm) {mmap_assert_write_locked (mm); -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) +if (!mm_flags_test (MMF_VM_MERGEABLE , mm))return 0 ; -if (test_bit (MMF_VM_MERGE_ANY , &mm->flags)) +if (mm_flags_test (MMF_VM_MERGE_ANY , mm))return ksm_disable_merge_any (mm);return ksm_del_vmas (mm); }@@ -2852,7 +2852,7 @@ int ksm_madvise(struct vm_area_struct *vma, unsigned long start,if (!vma_ksm_compatible (vma))return 0 ; -if (!test_bit (MMF_VM_MERGEABLE , &mm->flags)) { +if (!mm_flags_test (MMF_VM_MERGEABLE , mm)) { err =__ksm_enter (mm);if (err)return err;@@ -2912,7 +2912,7 @@ int __ksm_enter(struct mm_struct *mm)list_add_tail (&slot->mm_node, &ksm_scan.mm_slot->slot.mm_node);spin_unlock (&ksm_mmlist_lock); -set_bit (MMF_VM_MERGEABLE , &mm->flags); +mm_flags_set (MMF_VM_MERGEABLE , mm);mmgrab (mm);if (needs_wakeup)@@ -2954,8 +2954,8 @@ void __ksm_exit(struct mm_struct *mm)if (easy_to_free) {mm_slot_free (mm_slot_cache, mm_slot); -clear_bit (MMF_VM_MERGE_ANY , &mm->flags); -clear_bit (MMF_VM_MERGEABLE , &mm->flags); +mm_flags_clear (MMF_VM_MERGE_ANY , mm); +mm_flags_clear (MMF_VM_MERGEABLE , mm);mmdrop (mm); }else if (mm_slot) {mmap_write_lock (mm);mm/mmap.c +4
-4@@ -802,7 +802,7 @@ unsigned long mm_get_unmapped_area_vmflags(struct mm_struct *mm, struct file *fi unsigned long pgoff, unsigned long flags, vm_flags_t vm_flags) { - if (test_bit(MMF_TOPDOWN, &mm->flags)) + if (mm_flags_test(MMF_TOPDOWN, mm)) return arch_get_unmapped_area_topdown(filp, addr, len, pgoff, flags, vm_flags);return arch_get_unmapped_area (filp, addr, len, pgoff, flags, vm_flags);@@ -1284,7 +1284,7 @@ void exit_mmap(struct mm_struct *mm)* Set MMF_OOM_SKIP to hide this task from the oom killer/reaper * because the memory has been already freed. */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);mmap_write_lock (mm);mt_clear_in_rcu (&mm->mm_mt);vma_iter_set (&vmi, vma->vm_end);@@ -1859,14 +1859,14 @@ __latent_entropy int dup_mmap(struct mm_struct *mm, struct mm_struct *oldmm)mas_set_range (&vmi.mas, mpnt->vm_start, mpnt->vm_end -1 );mas_store (&vmi.mas,XA_ZERO_ENTRY );/* Avoid OOM iterating a broken tree */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm); }/* * The mm_struct is going to exit, but the locks will be dropped * first. Set the mm_struct as unstable is advisable as it is * not fully initialised. */ -set_bit (MMF_UNSTABLE , &mm->flags); +mm_flags_set (MMF_UNSTABLE , mm); } out:mmap_write_unlock (mm);mm/oom_kill.c +13
-13@@ -1,7 +1,7 @@// SPDX-License-Identifier: GPL-2.0-only /* * linux/mm/oom_kill.c -* +* * Copyright (C) 1998,2000 Rik van Riel * Thanks go out to Claus Fischer for some serious inspiration and * for goading me into coding this file... @@ -218,7 +218,7 @@ long oom_badness(struct task_struct *p, unsigned long totalpages)*/ adj = (long )p->signal->oom_score_adj;if (adj ==OOM_SCORE_ADJ_MIN || -test_bit (MMF_OOM_SKIP , &p->mm->flags) || +mm_flags_test (MMF_OOM_SKIP , p->mm) ||in_vfork (p)) {task_unlock (p);return LONG_MIN ;@@ -325,7 +325,7 @@ static int oom_evaluate_task(struct task_struct *task, void *arg)* any memory is quite low. */ if (!is_sysrq_oom (oc) &&tsk_is_oom_victim (task)) { -if (test_bit (MMF_OOM_SKIP , &task->signal->oom_mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , task->signal->oom_mm)) goto next; goto abort; }@@ -524,7 +524,7 @@ static bool __oom_reap_task_mm(struct mm_struct *mm)* should imply barriers already and the reader would hit a page fault * if it stumbled over a reaped memory. */ -set_bit (MMF_UNSTABLE , &mm->flags); +mm_flags_set (MMF_UNSTABLE , mm);for_each_vma (vmi, vma) {if (vma->vm_flags & (VM_HUGETLB |VM_PFNMAP ))@@ -583,7 +583,7 @@ static bool oom_reap_task_mm(struct task_struct *tsk, struct mm_struct *mm)* under mmap_lock for reading because it serializes against the * mmap_write_lock();mmap_write_unlock() cycle in exit_mmap(). */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) { +if (mm_flags_test (MMF_OOM_SKIP , mm)) {trace_skip_task_reaping (tsk->pid); goto out_unlock; }@@ -619,7 +619,7 @@ static void oom_reap_task(struct task_struct *tsk)schedule_timeout_idle (HZ /10 );if (attempts <=MAX_OOM_REAP_RETRIES || -test_bit (MMF_OOM_SKIP , &mm->flags)) +mm_flags_test (MMF_OOM_SKIP , mm)) goto done; pr_info("oom_reaper: unable to reap pid:%d (%s)\n",@@ -634,7 +634,7 @@ static void oom_reap_task(struct task_struct *tsk)* Hide this mm from OOM killer because it has been either reaped or * somebody can't call mmap_write_unlock(mm). */ -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);/* Drop a reference taken by queue_oom_reaper */ put_task_struct (tsk);@@ -670,7 +670,7 @@ static void wake_oom_reaper(struct timer_list *timer)unsigned long flags;/* The victim managed to terminate on its own - see exit_mmap */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) { +if (mm_flags_test (MMF_OOM_SKIP , mm)) {put_task_struct (tsk);return ; }@@ -695,7 +695,7 @@ static void wake_oom_reaper(struct timer_list *timer)static void queue_oom_reaper (struct task_struct *tsk) {/* mm is already queued? */ -if (test_and_set_bit (MMF_OOM_REAP_QUEUED , &tsk->signal->oom_mm->flags)) +if (mm_flags_test_and_set (MMF_OOM_REAP_QUEUED , tsk->signal->oom_mm))return ;get_task_struct (tsk);@@ -892,7 +892,7 @@ static bool task_will_free_mem(struct task_struct *task)* This task has already been drained by the oom reaper so there are * only small chances it will free some more */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , mm))return false;if (atomic_read (&mm->mm_users) <=1 )@@ -977,7 +977,7 @@ static void __oom_kill_process(struct task_struct *victim, const char *message)continue ;if (is_global_init (p)) { can_oom_reap = false; -set_bit (MMF_OOM_SKIP , &mm->flags); +mm_flags_set (MMF_OOM_SKIP , mm);pr_info ("oom killer %d (%s) has mm pinned by %d (%s)\n" ,task_pid_nr (victim), victim->comm,task_pid_nr (p), p->comm);@@ -1235,7 +1235,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) reap = true; else {/* Error only if the work has not been done already */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags)) +if (!mm_flags_test (MMF_OOM_SKIP , mm)) ret = -EINVAL ; }task_unlock (p);@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);mm/util.c +3
-3@@ -471,17 +471,17 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)if (mmap_is_legacy (rlim_stack)) { mm->mmap_base =TASK_UNMAPPED_BASE + random_factor; -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }else { mm->mmap_base =mmap_base (random_factor, rlim_stack); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); } }#elif defined(CONFIG_MMU) && !defined(HAVE_ARCH_PICK_MMAP_LAYOUT)void arch_pick_mmap_layout (struct mm_struct *mm,struct rlimit *rlim_stack) { mm->mmap_base =TASK_UNMAPPED_BASE ; -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }#endif #ifdef CONFIG_MMU Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 4 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.
Quoted 8 lines
This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>---
LGTM.
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 19 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>---
mm/oom_kill.c +0
-0
mm/oom_kill.c line 4
Quoted 5 lines
mm/oom_kill.c +1
-1@@ -1,7 +1,7 @@// SPDX-License-Identifier: GPL-2.0-only /* * linux/mm/oom_kill.c -* +*
^ unrelated change
Signature · 3 lines
Cheers David / dhildenb
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 15 lines · David Hildenbrand
Quoted 12 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>---
Quoted 12 lines
mm/oom_kill.c line 4
Quoted 10 lines
mm/oom_kill.c +1
-1@@ -1,7 +1,7 @@// SPDX-License-Identifier: GPL-2.0-only /* * linux/mm/oom_kill.c -* +* ^ unrelated change
Whoops! This is my editor removing trailing space...
I mean may as well leave in tbh for this case I think :)
Quoted 2 lines
Thanks for this + other acks! :)
Quoted 6 lines
--
CheersDavid / dhildenb
Cheers, Lorenzo
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 11 lines · On Tue, 12 Aug 2025 16:44:11 +0100 Lorenzo Stoakes…
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
[ ... ]
Quoted 4 lines
mm/oom_kill.c +0
-0
[ ... ]
mm/oom_kill.c SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) · line 1257
Quoted 9 lines
mm/oom_kill.c +1
-1@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);
Hi Lorzeno, I think we lost a ! here.
claude found enough inverted logic in moved code that I did a new run with a more explicit prompt for it, but this was the only new hit.
-chris
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 36 lines · Chris Mason
Quoted 11 lines · On Tue, 12 Aug 2025 16:44:11 +0100 Lorenzo Stoakes…
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>[ ... ]
Quoted 4 lines
mm/oom_kill.c +0
-0[ ... ]
mm/oom_kill.c SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) · line 1257
Quoted 9 lines
mm/oom_kill.c +1
-1@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);Hi Lorzeno, I think we lost a ! here.
Quoted 3 lines
claude found enough inverted logic in moved code that I did a new run with a more explicit prompt for it, but this was the only new hit.
I presume conversion was done mostly manually?
The way(tm) is to use coccinelle.
I whipped out the following real quick and results look good:
@@
expression mm, bit;
@@
- test_bit(bit, &mm->flags)
+ mm_flags_test(bit, mm)
$ spatch --sp-file mmbit.cocci mm/oom_kill.c
[snip]
@@ -892,7 +892,7 @@ static bool task_will_free_mem(struct ta
* This task has already been drained by the oom reaper so there are
* only small chances it will free some more
*/
- if (test_bit(MMF_OOM_SKIP, &mm->flags))
+ if (mm_flags_test(MMF_OOM_SKIP, mm))
return false; if (atomic_read(&mm->mm_users) <= 1)
@@ -1235,7 +1235,7 @@ SYSCALL_DEFINE2(process_mrelease, int, p
reap = true;
else {
/* Error only if the work has not been done already */
- if (!test_bit(MMF_OOM_SKIP, &mm->flags))
+ if (!mm_flags_test(MMF_OOM_SKIP, mm))
ret = -EINVAL;
}
task_unlock(p);@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, p
* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure
* possible change in exit_mmap is seen
*/
- if (!test_bit(MMF_OOM_SKIP, &mm->flags) && !__oom_reap_task_mm(mm))
+ if (!mm_flags_test(MMF_OOM_SKIP, mm) && !__oom_reap_task_mm(mm))
ret = -EAGAIN;
mmap_read_unlock(mm);Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 37 lines · Mateusz Guzik
Quoted 36 lines · Chris Mason
Quoted 11 lines · On Tue, 12 Aug 2025 16:44:11 +0100 Lorenzo Stoakes…
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>[ ... ]
Quoted 4 lines
mm/oom_kill.c +0
-0[ ... ]
mm/oom_kill.c SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) · line 1257
Quoted 9 lines
mm/oom_kill.c +1
-1@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);Hi Lorzeno, I think we lost a ! here.
Quoted 5 lines
Quoted 3 lines
claude found enough inverted logic in moved code that I did a new run with a more explicit prompt for it, but this was the only new hit.
I presume conversion was done mostly manually?
Actually largely via sed/emacs find-replace. I'm not sure why this case happened. But maybe it's one of the not 'largely' changes...
Human-in-the-middle is obviously subject to errors :)
Quoted 11 lines
The way(tm) is to use coccinelle.
I whipped out the following real quick and results look good:
@@
expression mm, bit;
@@-
test_bit(bit, &mm->flags)
+mm_flags_test(bit, mm)
Thanks. Not sure it'd hit every case. But that's useful to know, could presumably expand to hit others.
I will be changing VMA flags when my review load finally allows me to so knowing this is useful...
Cheers, Lorenzo
Quoted 29 lines
$ spatch --sp-file mmbit.cocci mm/oom_kill.c [snip]mm/oom_kill.c +3
-3@@ -892,7 +892,7 @@ static bool task_will_free_mem(struct ta* This task has already been drained by the oom reaper so there are * only small chances it will free some more */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , mm))return false;if (atomic_read (&mm->mm_users) <=1 )@@ -1235,7 +1235,7 @@ SYSCALL_DEFINE2(process_mrelease, int, p reap = true; else {/* Error only if the work has not been done already */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags)) +if (!mm_flags_test (MMF_OOM_SKIP , mm)) ret = -EINVAL ; }task_unlock (p);@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, p* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (!mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 43 lines · Lorenzo Stoakes
Quoted 41 lines · Mateusz Guzik
Quoted 39 lines · Chris Mason
Quoted 11 lines · On Tue, 12 Aug 2025 16:44:11 +0100 Lorenzo Stoakes…
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>[ ... ]
Quoted 4 lines
mm/oom_kill.c +0
-0[ ... ]
mm/oom_kill.c SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) · line 1257
Quoted 9 lines
mm/oom_kill.c +1
-1@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);Hi Lorzeno, I think we lost a ! here.
claude found enough inverted logic in moved code that I did a new run with a more explicit prompt for it, but this was the only new hit.
Quoted 7 lines
Quoted 1 line
I presume conversion was done mostly manually?
Actually largely via sed/emacs find-replace. I'm not sure why this case happened. But maybe it's one of the not 'largely' changes...
Human-in-the-middle is obviously subject to errors :)
tru.dat
Quoted 9 lines
Quoted 9 lines
The way(tm) is to use coccinelle.
I whipped out the following real quick and results look good:
@@
expression mm, bit;
@@
Quoted 9 lines
Quoted 2 lines
-
test_bit(bit, &mm->flags)
+mm_flags_test(bit, mm)Thanks. Not sure it'd hit every case. But that's useful to know, could presumably expand to hit others.
I will be changing VMA flags when my review load finally allows me to so knowing this is useful...
I ran into bugs in spatch in the past where it just neglected to patch something, but that's rare and can be trivially caught.
Defo easier to check than making sure none of the manual fixups are off.
Quoted 31 lines
Cheers, Lorenzo
Quoted 29 lines
$ spatch --sp-file mmbit.cocci mm/oom_kill.c [snip]mm/oom_kill.c +3
-3@@ -892,7 +892,7 @@ static bool task_will_free_mem(struct ta* This task has already been drained by the oom reaper so there are * only small chances it will free some more */ -if (test_bit (MMF_OOM_SKIP , &mm->flags)) +if (mm_flags_test (MMF_OOM_SKIP , mm))return false;if (atomic_read (&mm->mm_users) <=1 )@@ -1235,7 +1235,7 @@ SYSCALL_DEFINE2(process_mrelease, int, p reap = true; else {/* Error only if the work has not been done already */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags)) +if (!mm_flags_test (MMF_OOM_SKIP , mm)) ret = -EINVAL ; }task_unlock (p);@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, p* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (!mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
In reply to Chris MasonQuoted 35 lines · Chris Mason
Quoted 11 lines · On Tue, 12 Aug 2025 16:44:11 +0100 Lorenzo Stoakes…
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.This will result in the debug output being that of a bitmap output, which will result in a minor change here, but since this is for debug only, this should have no bearing.
Otherwise, no functional changes intended.
Signed-off-by Lorenzo Stoakes <[email protected]>[ ... ]
Quoted 4 lines
mm/oom_kill.c +0
-0[ ... ]
mm/oom_kill.c SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags) · line 1257
Quoted 9 lines
mm/oom_kill.c +1
-1@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (!test_bit (MMF_OOM_SKIP , &mm->flags) && !__oom_reap_task_mm (mm)) +if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);Hi Lorzeno, I think we lost a ! here.
Quoted 2 lines
claude found enough inverted logic in moved code that I did a new run with a more explicit prompt for it, but this was the only new hit.
Thanks, my bad, will send a fix-patch.
Kind of remarkable/interesting nothing hit this though... but not necessarily a good thing :)
Quoted 3 lines
-chris
Cheers, Lorenzo
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
In reply to Lorenzo StoakesHi Andrew,
Please apply the below fixpatch to account for an accidentally inverted check.
Thanks, Lorenzo
----8<----
From e5a04f488d2f5bc7e94003ffa586e01fa76b39c1 Mon Sep 17 00:00:00 2001
From: Lorenzo Stoakes <[email protected]>
Date: Wed, 17 Sep 2025 06:15:31 +0100
Subject: [PATCH] fix missing !
--- mm/oom_kill.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
mm/oom_kill.c +1 -1
@@ -1251,7 +1251,7 @@ SYSCALL_DEFINE2(process_mrelease, int, pidfd, unsigned int, flags)* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) +if (!mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);
--
2.51.0
Andrew Morton
maintainerRe: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 5 lines · On Wed, 17 Sep 2025 06:16:37 +0100 Lorenzo Stoakes…
Hi Andrew,
Please apply the below fixpatch to account for an accidentally inverted check.
Thanks, Lorenzo
The fixee is now in mm-stable so I turned this into a standalone thing.
(hate having to do it this way! A place where git requirements simply don't match the workflow)
From: Lorenzo Stoakes <[email protected]>
Subject: mm/oom_kill.c: fix inverted check
Date: Wed, 17 Sep 2025 06:16:37 +0100
Fix an incorrect logic conversion in process_mrelease().
---
mm/oom_kill.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
mm/oom_kill.c renamed from mm/oom_kill.c~mm-oom_killc-fix-inverted-check +1 -1
@@ -1257,7 +1257,7 @@ SYSCALL_DEFINE2(process_mrelease, int, p* Check MMF_OOM_SKIP again under mmap_read_lock protection to ensure * possible change in exit_mmap is seen */ -if (mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) +if (!mm_flags_test (MMF_OOM_SKIP , mm) && !__oom_reap_task_mm (mm)) ret = -EAGAIN ;mmap_read_unlock (mm);
_
Re: [PATCH 02/10] mm: convert core mm to mm_flags_*() accessors
Quoted 4 lines · Andrew Morton
Quoted 2 lines · On Wed, 17 Sep 2025 06:16:37 +0100 Lorenzo Stoakes…
Hi Andrew,
Quoted 8 lines
Quoted 3 lines
Please apply the below fixpatch to account for an accidentally inverted check.
Thanks, Lorenzo
The fixee is now in mm-stable so I turned this into a standalone thing.
(hate having to do it this way! A place where git requirements simply don't match the workflow)
Oops, sorry :)
Thanks for fixing up!
Cheers, Lorenzo
PATCH 3/10 mm: convert prctl to mm_flags_*() accessors
In reply to Lorenzo StoakesAs part of the effort to move to mm->flags becoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessing mm_struct flags.
No functional change intended.
--- kernel/sys.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)
kernel/sys.c +8 -8
@@ -2392,9 +2392,9 @@ static inline unsigned long get_current_mdwe(void) {unsigned long ret =0 ; -if (test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE , current->mm)) ret |=PR_MDWE_REFUSE_EXEC_GAIN ; -if (test_bit (MMF_HAS_MDWE_NO_INHERIT , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE_NO_INHERIT , current->mm)) ret |=PR_MDWE_NO_INHERIT ;return ret;
@@ -2427,9 +2427,9 @@ static inline int prctl_set_mdwe(unsigned long bits, unsigned long arg3,return -EPERM ;/* Cannot unset the flags */ if (bits &PR_MDWE_NO_INHERIT ) -set_bit (MMF_HAS_MDWE_NO_INHERIT , ¤t->mm->flags); +mm_flags_set (MMF_HAS_MDWE_NO_INHERIT , current->mm);if (bits &PR_MDWE_REFUSE_EXEC_GAIN ) -set_bit (MMF_HAS_MDWE , ¤t->mm->flags); +mm_flags_set (MMF_HAS_MDWE , current->mm);return 0 ; }
@@ -2627,7 +2627,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,case PR_GET_THP_DISABLE :if (arg2 || arg3 || arg4 || arg5)return -EINVAL ; - error = !!test_bit (MMF_DISABLE_THP , &me->mm->flags); + error = !!mm_flags_test (MMF_DISABLE_THP , me->mm);break ;case PR_SET_THP_DISABLE :if (arg3 || arg4 || arg5)
@@ -2635,9 +2635,9 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,if (mmap_write_lock_killable (me->mm))return -EINTR ;if (arg2) -set_bit (MMF_DISABLE_THP , &me->mm->flags); +mm_flags_set (MMF_DISABLE_THP , me->mm);else -clear_bit (MMF_DISABLE_THP , &me->mm->flags); +mm_flags_clear (MMF_DISABLE_THP , me->mm);mmap_write_unlock (me->mm);break ;case PR_MPX_ENABLE_MANAGEMENT :
@@ -2770,7 +2770,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,if (arg2 || arg3 || arg4 || arg5)return -EINVAL ; - error = !!test_bit (MMF_VM_MERGE_ANY , &me->mm->flags); + error = !!mm_flags_test (MMF_VM_MERGE_ANY , me->mm);break ;#endif case PR_RISCV_V_SET_CONTROL :
Signature · 1 line
2.50.1
Re: [PATCH 03/10] mm: convert prctl to mm_flags_*() accessors
Quoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 65 lines
--- kernel/sys.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)kernel/sys.c +8
-8@@ -2392,9 +2392,9 @@ static inline unsigned long get_current_mdwe(void) {unsigned long ret =0 ; -if (test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE , current->mm)) ret |=PR_MDWE_REFUSE_EXEC_GAIN ; -if (test_bit (MMF_HAS_MDWE_NO_INHERIT , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE_NO_INHERIT , current->mm)) ret |=PR_MDWE_NO_INHERIT ;return ret;@@ -2427,9 +2427,9 @@ static inline int prctl_set_mdwe(unsigned long bits, unsigned long arg3,return -EPERM ;/* Cannot unset the flags */ if (bits &PR_MDWE_NO_INHERIT ) -set_bit (MMF_HAS_MDWE_NO_INHERIT , ¤t->mm->flags); +mm_flags_set (MMF_HAS_MDWE_NO_INHERIT , current->mm);if (bits &PR_MDWE_REFUSE_EXEC_GAIN ) -set_bit (MMF_HAS_MDWE , ¤t->mm->flags); +mm_flags_set (MMF_HAS_MDWE , current->mm);return 0 ; }@@ -2627,7 +2627,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,case PR_GET_THP_DISABLE :if (arg2 || arg3 || arg4 || arg5)return -EINVAL ; - error = !!test_bit (MMF_DISABLE_THP , &me->mm->flags); + error = !!mm_flags_test (MMF_DISABLE_THP , me->mm);break ;case PR_SET_THP_DISABLE :if (arg3 || arg4 || arg5)@@ -2635,9 +2635,9 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,if (mmap_write_lock_killable (me->mm))return -EINTR ;if (arg2) -set_bit (MMF_DISABLE_THP , &me->mm->flags); +mm_flags_set (MMF_DISABLE_THP , me->mm);else -clear_bit (MMF_DISABLE_THP , &me->mm->flags); +mm_flags_clear (MMF_DISABLE_THP , me->mm);mmap_write_unlock (me->mm);break ;case PR_MPX_ENABLE_MANAGEMENT :@@ -2770,7 +2770,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,if (arg2 || arg3 || arg4 || arg5)return -EINVAL ; - error = !!test_bit (MMF_VM_MERGE_ANY , &me->mm->flags); + error = !!mm_flags_test (MMF_VM_MERGE_ANY , me->mm);break ;#endif case PR_RISCV_V_SET_CONTROL :Signature · 1 line
2.50.1
Re: [PATCH 03/10] mm: convert prctl to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 65 lines
--- kernel/sys.c | 16 ++++++++-------- 1 file changed, 8 insertions(+), 8 deletions(-)kernel/sys.c +8
-8@@ -2392,9 +2392,9 @@ static inline unsigned long get_current_mdwe(void) {unsigned long ret =0 ; -if (test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE , current->mm)) ret |=PR_MDWE_REFUSE_EXEC_GAIN ; -if (test_bit (MMF_HAS_MDWE_NO_INHERIT , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE_NO_INHERIT , current->mm)) ret |=PR_MDWE_NO_INHERIT ;return ret;@@ -2427,9 +2427,9 @@ static inline int prctl_set_mdwe(unsigned long bits, unsigned long arg3,return -EPERM ;/* Cannot unset the flags */ if (bits &PR_MDWE_NO_INHERIT ) -set_bit (MMF_HAS_MDWE_NO_INHERIT , ¤t->mm->flags); +mm_flags_set (MMF_HAS_MDWE_NO_INHERIT , current->mm);if (bits &PR_MDWE_REFUSE_EXEC_GAIN ) -set_bit (MMF_HAS_MDWE , ¤t->mm->flags); +mm_flags_set (MMF_HAS_MDWE , current->mm);return 0 ; }@@ -2627,7 +2627,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,case PR_GET_THP_DISABLE :if (arg2 || arg3 || arg4 || arg5)return -EINVAL ; - error = !!test_bit (MMF_DISABLE_THP , &me->mm->flags); + error = !!mm_flags_test (MMF_DISABLE_THP , me->mm);break ;case PR_SET_THP_DISABLE :if (arg3 || arg4 || arg5)@@ -2635,9 +2635,9 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,if (mmap_write_lock_killable (me->mm))return -EINTR ;if (arg2) -set_bit (MMF_DISABLE_THP , &me->mm->flags); +mm_flags_set (MMF_DISABLE_THP , me->mm);else -clear_bit (MMF_DISABLE_THP , &me->mm->flags); +mm_flags_clear (MMF_DISABLE_THP , me->mm);mmap_write_unlock (me->mm);break ;case PR_MPX_ENABLE_MANAGEMENT :@@ -2770,7 +2770,7 @@ SYSCALL_DEFINE5(prctl, int, option, unsigned long, arg2, unsigned long, arg3,if (arg2 || arg3 || arg4 || arg5)return -EINVAL ; - error = !!test_bit (MMF_VM_MERGE_ANY , &me->mm->flags); + error = !!mm_flags_test (MMF_VM_MERGE_ANY , me->mm);break ;#endif case PR_RISCV_V_SET_CONTROL :Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 03/10] mm: convert prctl to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 8 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>---
Signature · 3 lines
Cheers David / dhildenb
PATCH 4/10 mm: convert arch-specific code to mm_flags_*() accessors
In reply to Lorenzo StoakesAs part of the effort to move to mm->flags becoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessing mm_struct flags.
No functional change intended.
--- arch/s390/mm/mmap.c | 4 ++-- arch/sparc/kernel/sys_sparc_64.c | 4 ++-- arch/x86/mm/mmap.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)
arch/s390/mm/mmap.c +2 -2
@@ -182,10 +182,10 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)*/ if (mmap_is_legacy (rlim_stack)) { mm->mmap_base =mmap_base_legacy (random_factor); -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }else { mm->mmap_base =mmap_base (random_factor, rlim_stack); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flag_set (MMF_TOPDOWN , mm); } }
arch/sparc/kernel/sys_sparc_64.c +2 -2
@@ -309,7 +309,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack) gap == RLIM_INFINITY || sysctl_legacy_va_layout) { mm->mmap_base = TASK_UNMAPPED_BASE + random_factor; - clear_bit(MMF_TOPDOWN, &mm->flags); + mm_flags_clear(MMF_TOPDOWN, mm); } else {/* We know it's 32-bit */ unsigned long task_size =STACK_TOP32 ;
@@ -320,7 +320,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack) gap = (task_size /6 *5 ); mm->mmap_base =PAGE_ALIGN (task_size - gap - random_factor); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); } }
arch/x86/mm/mmap.c +2 -2
@@ -122,9 +122,9 @@ static void arch_pick_mmap_base(unsigned long *base, unsigned long *legacy_base,void arch_pick_mmap_layout (struct mm_struct *mm,struct rlimit *rlim_stack) {if (mmap_is_legacy ()) -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm);else -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); arch_pick_mmap_base(&mm->mmap_base, &mm->mmap_legacy_base, arch_rnd(mmap64_rnd_bits), task_size_64bit(0),
Signature · 1 line
2.50.1
Re: [PATCH 04/10] mm: convert arch-specific code to mm_flags_*() accessors
Quoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 64 lines
--- arch/s390/mm/mmap.c | 4 ++-- arch/sparc/kernel/sys_sparc_64.c | 4 ++-- arch/x86/mm/mmap.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)arch/s390/mm/mmap.c +2
-2@@ -182,10 +182,10 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)*/ if (mmap_is_legacy (rlim_stack)) { mm->mmap_base =mmap_base_legacy (random_factor); -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }else { mm->mmap_base =mmap_base (random_factor, rlim_stack); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flag_set (MMF_TOPDOWN , mm); } }arch/sparc/kernel/sys_sparc_64.c +2
-2@@ -309,7 +309,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack) gap == RLIM_INFINITY || sysctl_legacy_va_layout) { mm->mmap_base = TASK_UNMAPPED_BASE + random_factor; - clear_bit(MMF_TOPDOWN, &mm->flags); + mm_flags_clear(MMF_TOPDOWN, mm); } else {/* We know it's 32-bit */ unsigned long task_size =STACK_TOP32 ;@@ -320,7 +320,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack) gap = (task_size /6 *5 ); mm->mmap_base =PAGE_ALIGN (task_size - gap - random_factor); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); } }arch/x86/mm/mmap.c +2
-2@@ -122,9 +122,9 @@ static void arch_pick_mmap_base(unsigned long *base, unsigned long *legacy_base,void arch_pick_mmap_layout (struct mm_struct *mm,struct rlimit *rlim_stack) {if (mmap_is_legacy ()) -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm);else -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); arch_pick_mmap_base(&mm->mmap_base, &mm->mmap_legacy_base, arch_rnd(mmap64_rnd_bits), task_size_64bit(0),Signature · 1 line
2.50.1
Re: [PATCH 04/10] mm: convert arch-specific code to mm_flags_*() accessors
In reply to Lorenzo StoakesHi Andrew,
One very small fix for this, I typo'd the function name... :)
Cheers, Lorenzo
----8<----
From c2f9bc16a4ad705ac05571ac7b825d8aac5849d4 Mon Sep 17 00:00:00 2001
From: Lorenzo Stoakes <[email protected]>
Date: Wed, 13 Aug 2025 15:08:36 +0100
Subject: [PATCH] fix typo
--- arch/s390/mm/mmap.c | 2 +- 1 file changed, 1 insertion(+), 1 deletion(-)
arch/s390/mm/mmap.c +1 -1
@@ -185,7 +185,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)mm_flags_clear (MMF_TOPDOWN , mm); }else { mm->mmap_base =mmap_base (random_factor, rlim_stack); -mm_flag_set (MMF_TOPDOWN , mm); +mm_flags_set (MMF_TOPDOWN , mm); } }
--
2.50.1
Re: [PATCH 04/10] mm: convert arch-specific code to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 64 lines
--- arch/s390/mm/mmap.c | 4 ++-- arch/sparc/kernel/sys_sparc_64.c | 4 ++-- arch/x86/mm/mmap.c | 4 ++-- 3 files changed, 6 insertions(+), 6 deletions(-)arch/s390/mm/mmap.c +2
-2@@ -182,10 +182,10 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack)*/ if (mmap_is_legacy (rlim_stack)) { mm->mmap_base =mmap_base_legacy (random_factor); -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm); }else { mm->mmap_base =mmap_base (random_factor, rlim_stack); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flag_set (MMF_TOPDOWN , mm); } }arch/sparc/kernel/sys_sparc_64.c +2
-2@@ -309,7 +309,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack) gap == RLIM_INFINITY || sysctl_legacy_va_layout) { mm->mmap_base = TASK_UNMAPPED_BASE + random_factor; - clear_bit(MMF_TOPDOWN, &mm->flags); + mm_flags_clear(MMF_TOPDOWN, mm); } else {/* We know it's 32-bit */ unsigned long task_size =STACK_TOP32 ;@@ -320,7 +320,7 @@ void arch_pick_mmap_layout(struct mm_struct *mm, struct rlimit *rlim_stack) gap = (task_size /6 *5 ); mm->mmap_base =PAGE_ALIGN (task_size - gap - random_factor); -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); } }arch/x86/mm/mmap.c +2
-2@@ -122,9 +122,9 @@ static void arch_pick_mmap_base(unsigned long *base, unsigned long *legacy_base,void arch_pick_mmap_layout (struct mm_struct *mm,struct rlimit *rlim_stack) {if (mmap_is_legacy ()) -clear_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_clear (MMF_TOPDOWN , mm);else -set_bit (MMF_TOPDOWN , &mm->flags); +mm_flags_set (MMF_TOPDOWN , mm); arch_pick_mmap_base(&mm->mmap_base, &mm->mmap_legacy_base, arch_rnd(mmap64_rnd_bits), task_size_64bit(0),Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 04/10] mm: convert arch-specific code to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 8 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>---
Signature · 3 lines
Cheers David / dhildenb
PATCH 5/10 mm: convert uprobes to mm_flags_*() accessors
In reply to Lorenzo StoakesAs part of the effort to move to mm->flags becoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessing mm_struct flags.
No functional change intended.
--- kernel/events/uprobes.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)
kernel/events/uprobes.c +16 -16
@@ -1153,15 +1153,15 @@ static int install_breakpoint(struct uprobe *uprobe, struct vm_area_struct *vma,* set MMF_HAS_UPROBES in advance for uprobe_pre_sstep_notifier(), * the task can hit this breakpoint right after __replace_page(). */ - first_uprobe = !test_bit (MMF_HAS_UPROBES , &mm->flags); + first_uprobe = !mm_flags_test (MMF_HAS_UPROBES , mm);if (first_uprobe) -set_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_set (MMF_HAS_UPROBES , mm); ret =set_swbp (&uprobe->arch, vma, vaddr);if (!ret) -clear_bit (MMF_RECALC_UPROBES , &mm->flags); +mm_flags_clear (MMF_RECALC_UPROBES , mm);else if (first_uprobe) -clear_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_clear (MMF_HAS_UPROBES , mm);return ret; }
@@ -1171,7 +1171,7 @@ static int remove_breakpoint(struct uprobe *uprobe, struct vm_area_struct *vma, {struct mm_struct *mm = vma->vm_mm; -set_bit (MMF_RECALC_UPROBES , &mm->flags); +mm_flags_set (MMF_RECALC_UPROBES , mm);return set_orig_insn (&uprobe->arch, vma, vaddr); }
@@ -1303,7 +1303,7 @@ register_for_each_vma(struct uprobe *uprobe, struct uprobe_consumer *new)/* consult only the "caller", new consumer. */ if (consumer_filter (new, mm)) err =install_breakpoint (uprobe, vma, info->vaddr); - }else if (test_bit (MMF_HAS_UPROBES , &mm->flags)) { + }else if (mm_flags_test (MMF_HAS_UPROBES , mm)) {if (!filter_chain (uprobe, mm)) err |=remove_breakpoint (uprobe, vma, info->vaddr); }
@@ -1595,7 +1595,7 @@ int uprobe_mmap(struct vm_area_struct *vma)if (vma->vm_file && (vma->vm_flags & (VM_WRITE |VM_SHARED )) ==VM_WRITE && -test_bit (MMF_HAS_UPROBES , &vma->vm_mm->flags)) +mm_flags_test (MMF_HAS_UPROBES , vma->vm_mm))delayed_ref_ctr_inc (vma);if (!valid_vma (vma, true))
@@ -1655,12 +1655,12 @@ void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned lonif (!atomic_read (&vma->vm_mm->mm_users))/* called by mmput() ? */ return ; -if (!test_bit (MMF_HAS_UPROBES , &vma->vm_mm->flags) || -test_bit (MMF_RECALC_UPROBES , &vma->vm_mm->flags)) +if (!mm_flags_test (MMF_HAS_UPROBES , vma->vm_mm) || +mm_flags_test (MMF_RECALC_UPROBES , vma->vm_mm))return ;if (vma_has_uprobes (vma, start, end)) -set_bit (MMF_RECALC_UPROBES , &vma->vm_mm->flags); +mm_flags_set (MMF_RECALC_UPROBES , vma->vm_mm); } static vm_fault_t xol_fault(const struct vm_special_mapping *sm,
@@ -1823,10 +1823,10 @@ void uprobe_end_dup_mmap(void)void uprobe_dup_mmap (struct mm_struct *oldmm,struct mm_struct *newmm) { -if (test_bit (MMF_HAS_UPROBES , &oldmm->flags)) { -set_bit (MMF_HAS_UPROBES , &newmm->flags); +if (mm_flags_test (MMF_HAS_UPROBES , oldmm)) { +mm_flags_set (MMF_HAS_UPROBES , newmm);/* unconditionally, dup_mmap() skips VM_DONTCOPY vmas */ -set_bit (MMF_RECALC_UPROBES , &newmm->flags); +mm_flags_set (MMF_RECALC_UPROBES , newmm); } }
@@ -2370,7 +2370,7 @@ static void mmf_recalc_uprobes(struct mm_struct *mm)return ; } -clear_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_clear (MMF_HAS_UPROBES , mm); }static int is_trap_at_addr (struct mm_struct *mm,unsigned long vaddr)
@@ -2468,7 +2468,7 @@ static struct uprobe *find_active_uprobe_rcu(unsigned long bp_vaddr, int *is_swb *is_swbp = -EFAULT ; } -if (!uprobe &&test_and_clear_bit (MMF_RECALC_UPROBES , &mm->flags)) +if (!uprobe &&mm_flags_test_and_clear (MMF_RECALC_UPROBES , mm))mmf_recalc_uprobes (mm);mmap_read_unlock (mm);
@@ -2818,7 +2818,7 @@ int uprobe_pre_sstep_notifier(struct pt_regs *regs)if (!current->mm)return 0 ; -if (!test_bit (MMF_HAS_UPROBES , ¤t->mm->flags) && +if (!mm_flags_test (MMF_HAS_UPROBES , current->mm) && (!current->utask || !current->utask->return_instances))return 0 ;
Signature · 1 line
2.50.1
Re: [PATCH 05/10] mm: convert uprobes to mm_flags_*() accessors
Quoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 115 lines
--- kernel/events/uprobes.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)kernel/events/uprobes.c +16
-16@@ -1153,15 +1153,15 @@ static int install_breakpoint(struct uprobe *uprobe, struct vm_area_struct *vma,* set MMF_HAS_UPROBES in advance for uprobe_pre_sstep_notifier(), * the task can hit this breakpoint right after __replace_page(). */ - first_uprobe = !test_bit (MMF_HAS_UPROBES , &mm->flags); + first_uprobe = !mm_flags_test (MMF_HAS_UPROBES , mm);if (first_uprobe) -set_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_set (MMF_HAS_UPROBES , mm); ret =set_swbp (&uprobe->arch, vma, vaddr);if (!ret) -clear_bit (MMF_RECALC_UPROBES , &mm->flags); +mm_flags_clear (MMF_RECALC_UPROBES , mm);else if (first_uprobe) -clear_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_clear (MMF_HAS_UPROBES , mm);return ret; }@@ -1171,7 +1171,7 @@ static int remove_breakpoint(struct uprobe *uprobe, struct vm_area_struct *vma, {struct mm_struct *mm = vma->vm_mm; -set_bit (MMF_RECALC_UPROBES , &mm->flags); +mm_flags_set (MMF_RECALC_UPROBES , mm);return set_orig_insn (&uprobe->arch, vma, vaddr); }@@ -1303,7 +1303,7 @@ register_for_each_vma(struct uprobe *uprobe, struct uprobe_consumer *new)/* consult only the "caller", new consumer. */ if (consumer_filter (new, mm)) err =install_breakpoint (uprobe, vma, info->vaddr); - }else if (test_bit (MMF_HAS_UPROBES , &mm->flags)) { + }else if (mm_flags_test (MMF_HAS_UPROBES , mm)) {if (!filter_chain (uprobe, mm)) err |=remove_breakpoint (uprobe, vma, info->vaddr); }@@ -1595,7 +1595,7 @@ int uprobe_mmap(struct vm_area_struct *vma)if (vma->vm_file && (vma->vm_flags & (VM_WRITE |VM_SHARED )) ==VM_WRITE && -test_bit (MMF_HAS_UPROBES , &vma->vm_mm->flags)) +mm_flags_test (MMF_HAS_UPROBES , vma->vm_mm))delayed_ref_ctr_inc (vma);if (!valid_vma (vma, true))@@ -1655,12 +1655,12 @@ void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned lonif (!atomic_read (&vma->vm_mm->mm_users))/* called by mmput() ? */ return ; -if (!test_bit (MMF_HAS_UPROBES , &vma->vm_mm->flags) || -test_bit (MMF_RECALC_UPROBES , &vma->vm_mm->flags)) +if (!mm_flags_test (MMF_HAS_UPROBES , vma->vm_mm) || +mm_flags_test (MMF_RECALC_UPROBES , vma->vm_mm))return ;if (vma_has_uprobes (vma, start, end)) -set_bit (MMF_RECALC_UPROBES , &vma->vm_mm->flags); +mm_flags_set (MMF_RECALC_UPROBES , vma->vm_mm); } static vm_fault_t xol_fault(const struct vm_special_mapping *sm,@@ -1823,10 +1823,10 @@ void uprobe_end_dup_mmap(void)void uprobe_dup_mmap (struct mm_struct *oldmm,struct mm_struct *newmm) { -if (test_bit (MMF_HAS_UPROBES , &oldmm->flags)) { -set_bit (MMF_HAS_UPROBES , &newmm->flags); +if (mm_flags_test (MMF_HAS_UPROBES , oldmm)) { +mm_flags_set (MMF_HAS_UPROBES , newmm);/* unconditionally, dup_mmap() skips VM_DONTCOPY vmas */ -set_bit (MMF_RECALC_UPROBES , &newmm->flags); +mm_flags_set (MMF_RECALC_UPROBES , newmm); } }@@ -2370,7 +2370,7 @@ static void mmf_recalc_uprobes(struct mm_struct *mm)return ; } -clear_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_clear (MMF_HAS_UPROBES , mm); }static int is_trap_at_addr (struct mm_struct *mm,unsigned long vaddr)@@ -2468,7 +2468,7 @@ static struct uprobe *find_active_uprobe_rcu(unsigned long bp_vaddr, int *is_swb *is_swbp = -EFAULT ; } -if (!uprobe &&test_and_clear_bit (MMF_RECALC_UPROBES , &mm->flags)) +if (!uprobe &&mm_flags_test_and_clear (MMF_RECALC_UPROBES , mm))mmf_recalc_uprobes (mm);mmap_read_unlock (mm);@@ -2818,7 +2818,7 @@ int uprobe_pre_sstep_notifier(struct pt_regs *regs)if (!current->mm)return 0 ; -if (!test_bit (MMF_HAS_UPROBES , ¤t->mm->flags) && +if (!mm_flags_test (MMF_HAS_UPROBES , current->mm) && (!current->utask || !current->utask->return_instances))return 0 ;Signature · 1 line
2.50.1
Re: [PATCH 05/10] mm: convert uprobes to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 115 lines
--- kernel/events/uprobes.c | 32 ++++++++++++++++---------------- 1 file changed, 16 insertions(+), 16 deletions(-)kernel/events/uprobes.c +16
-16@@ -1153,15 +1153,15 @@ static int install_breakpoint(struct uprobe *uprobe, struct vm_area_struct *vma,* set MMF_HAS_UPROBES in advance for uprobe_pre_sstep_notifier(), * the task can hit this breakpoint right after __replace_page(). */ - first_uprobe = !test_bit (MMF_HAS_UPROBES , &mm->flags); + first_uprobe = !mm_flags_test (MMF_HAS_UPROBES , mm);if (first_uprobe) -set_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_set (MMF_HAS_UPROBES , mm); ret =set_swbp (&uprobe->arch, vma, vaddr);if (!ret) -clear_bit (MMF_RECALC_UPROBES , &mm->flags); +mm_flags_clear (MMF_RECALC_UPROBES , mm);else if (first_uprobe) -clear_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_clear (MMF_HAS_UPROBES , mm);return ret; }@@ -1171,7 +1171,7 @@ static int remove_breakpoint(struct uprobe *uprobe, struct vm_area_struct *vma, {struct mm_struct *mm = vma->vm_mm; -set_bit (MMF_RECALC_UPROBES , &mm->flags); +mm_flags_set (MMF_RECALC_UPROBES , mm);return set_orig_insn (&uprobe->arch, vma, vaddr); }@@ -1303,7 +1303,7 @@ register_for_each_vma(struct uprobe *uprobe, struct uprobe_consumer *new)/* consult only the "caller", new consumer. */ if (consumer_filter (new, mm)) err =install_breakpoint (uprobe, vma, info->vaddr); - }else if (test_bit (MMF_HAS_UPROBES , &mm->flags)) { + }else if (mm_flags_test (MMF_HAS_UPROBES , mm)) {if (!filter_chain (uprobe, mm)) err |=remove_breakpoint (uprobe, vma, info->vaddr); }@@ -1595,7 +1595,7 @@ int uprobe_mmap(struct vm_area_struct *vma)if (vma->vm_file && (vma->vm_flags & (VM_WRITE |VM_SHARED )) ==VM_WRITE && -test_bit (MMF_HAS_UPROBES , &vma->vm_mm->flags)) +mm_flags_test (MMF_HAS_UPROBES , vma->vm_mm))delayed_ref_ctr_inc (vma);if (!valid_vma (vma, true))@@ -1655,12 +1655,12 @@ void uprobe_munmap(struct vm_area_struct *vma, unsigned long start, unsigned lonif (!atomic_read (&vma->vm_mm->mm_users))/* called by mmput() ? */ return ; -if (!test_bit (MMF_HAS_UPROBES , &vma->vm_mm->flags) || -test_bit (MMF_RECALC_UPROBES , &vma->vm_mm->flags)) +if (!mm_flags_test (MMF_HAS_UPROBES , vma->vm_mm) || +mm_flags_test (MMF_RECALC_UPROBES , vma->vm_mm))return ;if (vma_has_uprobes (vma, start, end)) -set_bit (MMF_RECALC_UPROBES , &vma->vm_mm->flags); +mm_flags_set (MMF_RECALC_UPROBES , vma->vm_mm); } static vm_fault_t xol_fault(const struct vm_special_mapping *sm,@@ -1823,10 +1823,10 @@ void uprobe_end_dup_mmap(void)void uprobe_dup_mmap (struct mm_struct *oldmm,struct mm_struct *newmm) { -if (test_bit (MMF_HAS_UPROBES , &oldmm->flags)) { -set_bit (MMF_HAS_UPROBES , &newmm->flags); +if (mm_flags_test (MMF_HAS_UPROBES , oldmm)) { +mm_flags_set (MMF_HAS_UPROBES , newmm);/* unconditionally, dup_mmap() skips VM_DONTCOPY vmas */ -set_bit (MMF_RECALC_UPROBES , &newmm->flags); +mm_flags_set (MMF_RECALC_UPROBES , newmm); } }@@ -2370,7 +2370,7 @@ static void mmf_recalc_uprobes(struct mm_struct *mm)return ; } -clear_bit (MMF_HAS_UPROBES , &mm->flags); +mm_flags_clear (MMF_HAS_UPROBES , mm); }static int is_trap_at_addr (struct mm_struct *mm,unsigned long vaddr)@@ -2468,7 +2468,7 @@ static struct uprobe *find_active_uprobe_rcu(unsigned long bp_vaddr, int *is_swb *is_swbp = -EFAULT ; } -if (!uprobe &&test_and_clear_bit (MMF_RECALC_UPROBES , &mm->flags)) +if (!uprobe &&mm_flags_test_and_clear (MMF_RECALC_UPROBES , mm))mmf_recalc_uprobes (mm);mmap_read_unlock (mm);@@ -2818,7 +2818,7 @@ int uprobe_pre_sstep_notifier(struct pt_regs *regs)if (!current->mm)return 0 ; -if (!test_bit (MMF_HAS_UPROBES , ¤t->mm->flags) && +if (!mm_flags_test (MMF_HAS_UPROBES , current->mm) && (!current->utask || !current->utask->return_instances))return 0 ;Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 05/10] mm: convert uprobes to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 8 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>---
Signature · 3 lines
Cheers David / dhildenb
PATCH 6/10 mm: update coredump logic to correctly use bitmap mm flags
In reply to Lorenzo StoakesThe coredump logic is slightly different from other users in that it both stores mm flags and additionally sets and gets using masks.
Since the MMF_DUMPABLE_* flags must remain as they are for uABI reasons, and of course these are within the first 32-bits of the flags, it is reasonable to provide access to these in the same fashion so this logic can all still keep working as it has been.
Therefore, introduce coredump-specific helpers __mm_flags_get_dumpable() and __mm_flags_set_mask_dumpable() for this purpose, and update all core dump users of mm flags to use these.
--- fs/coredump.c | 4 +++- fs/exec.c | 2 +- fs/pidfs.c | 7 +++++-- fs/proc/base.c | 8 +++++--- include/linux/sched/coredump.h | 21 ++++++++++++++++++++- 5 files changed, 34 insertions(+), 8 deletions(-)
fs/coredump.c +3 -1
@@ -1103,8 +1103,10 @@ void vfs_coredump(const kernel_siginfo_t *siginfo)* We must use the same mm->flags while dumping core to avoid * inconsistency of bit flags, since this flag is not protected * by any locks. +* +* Note that we only care about MMF_DUMP* flags. */ - .mm_flags = mm->flags, + .mm_flags = __mm_flags_get_dumpable(mm), .vma_meta = NULL, .cpu = raw_smp_processor_id(), };
fs/exec.c +1 -1
@@ -1999,7 +1999,7 @@ void set_dumpable(struct mm_struct *mm, int value)if (WARN_ON ((unsigned )value >SUID_DUMP_ROOT ))return ; -set_mask_bits (&mm->flags,MMF_DUMPABLE_MASK , value); +__mm_flags_set_mask_dumpable (mm, value); } SYSCALL_DEFINE3(execve,
fs/pidfs.c +5 -2
@@ -357,8 +357,11 @@ static long pidfd_info(struct file *file, unsigned int cmd, unsigned long arg)if ((kinfo.mask &PIDFD_INFO_COREDUMP ) && !(kinfo.coredump_mask)) {task_lock (task); -if (task->mm) - kinfo.coredump_mask =pidfs_coredump_mask (task->mm->flags); +if (task->mm) { +unsigned long flags =__mm_flags_get_dumpable (task->mm); + + kinfo.coredump_mask =pidfs_coredump_mask (flags); + }task_unlock (task); }
fs/proc/base.c +5 -3
@@ -2962,8 +2962,10 @@ static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, ret =0 ; mm =get_task_mm (task);if (mm) { +unsigned long flags =__mm_flags_get_dumpable (mm); + len =snprintf (buffer,sizeof (buffer),"%08lx\n" , - ((mm->flags &MMF_DUMP_FILTER_MASK ) >> + ((flags &MMF_DUMP_FILTER_MASK ) >>MMF_DUMP_FILTER_SHIFT ));mmput (mm); ret =simple_read_from_buffer (buf, count, ppos, buffer, len);
@@ -3002,9 +3004,9 @@ static ssize_t proc_coredump_filter_write(struct file *file,for (i =0 , mask =1 ; i <MMF_DUMP_FILTER_BITS ; i++, mask <<=1 ) {if (val & mask) -set_bit (i +MMF_DUMP_FILTER_SHIFT , &mm->flags); +mm_flags_set (i +MMF_DUMP_FILTER_SHIFT , mm);else -clear_bit (i +MMF_DUMP_FILTER_SHIFT , &mm->flags); +mm_flags_clear (i +MMF_DUMP_FILTER_SHIFT , mm); }mmput (mm);
include/linux/sched/coredump.h +20 -1
@@ -2,12 +2,29 @@#ifndef _LINUX_SCHED_COREDUMP_H#define _LINUX_SCHED_COREDUMP_H +#include <linux/compiler_types.h> #include <linux/mm_types.h> #define SUID_DUMP_DISABLE 0/* No setuid dumping */ #define SUID_DUMP_USER 1/* Dump as user of process */ #define SUID_DUMP_ROOT 2/* Dump as root */ +static inline unsigned long __mm_flags_get_dumpable (struct mm_struct *mm) +{ +/* +* By convention, dumpable bits are contained in first 32 bits of the +* bitmap, so we can simply access this first unsigned long directly. +*/ +return __mm_flags_get_word (mm); +} + +static inline void __mm_flags_set_mask_dumpable (struct mm_struct *mm,int value) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +set_mask_bits (bitmap,MMF_DUMPABLE_MASK , value); +} +extern void set_dumpable (struct mm_struct *mm,int value);/* * This returns the actual value of the suid_dumpable flag. For things
@@ -22,7 +39,9 @@ static inline int __get_dumpable(unsigned long mm_flags)static inline int get_dumpable (struct mm_struct *mm) { -return __get_dumpable (mm->flags); +unsigned long flags =__mm_flags_get_dumpable (mm); + +return __get_dumpable (flags); }#endif /* _LINUX_SCHED_COREDUMP_H */
Signature · 1 line
2.50.1
Re: [PATCH 06/10] mm: update coredump logic to correctly use bitmap mm flags
Quoted 8 lines · Lorenzo Stoakes
The coredump logic is slightly different from other users in that it both stores mm flags and additionally sets and gets using masks.
Since the MMF_DUMPABLE_* flags must remain as they are for uABI reasons, and of course these are within the first 32-bits of the flags, it is reasonable to provide access to these in the same fashion so this logic can all still keep working as it has been.
Quoted 5 lines
Therefore, introduce coredump-specific helpers
__mm_flags_get_dumpable()and__mm_flags_set_mask_dumpable()for this purpose, and update all core dump users of mm flags to use these.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 131 lines
--- fs/coredump.c | 4 +++- fs/exec.c | 2 +- fs/pidfs.c | 7 +++++-- fs/proc/base.c | 8 +++++--- include/linux/sched/coredump.h | 21 ++++++++++++++++++++- 5 files changed, 34 insertions(+), 8 deletions(-)fs/coredump.c +3
-1@@ -1103,8 +1103,10 @@ void vfs_coredump(const kernel_siginfo_t *siginfo)* We must use the same mm->flags while dumping core to avoid * inconsistency of bit flags, since this flag is not protected * by any locks. +* +* Note that we only care about MMF_DUMP* flags. */ - .mm_flags = mm->flags, + .mm_flags = __mm_flags_get_dumpable(mm), .vma_meta = NULL, .cpu = raw_smp_processor_id(), };fs/exec.c +1
-1@@ -1999,7 +1999,7 @@ void set_dumpable(struct mm_struct *mm, int value)if (WARN_ON ((unsigned )value >SUID_DUMP_ROOT ))return ; -set_mask_bits (&mm->flags,MMF_DUMPABLE_MASK , value); +__mm_flags_set_mask_dumpable (mm, value); } SYSCALL_DEFINE3(execve,fs/pidfs.c +5
-2@@ -357,8 +357,11 @@ static long pidfd_info(struct file *file, unsigned int cmd, unsigned long arg)if ((kinfo.mask &PIDFD_INFO_COREDUMP ) && !(kinfo.coredump_mask)) {task_lock (task); -if (task->mm) - kinfo.coredump_mask =pidfs_coredump_mask (task->mm->flags); +if (task->mm) { +unsigned long flags =__mm_flags_get_dumpable (task->mm); + + kinfo.coredump_mask =pidfs_coredump_mask (flags); + }task_unlock (task); }fs/proc/base.c +5
-3@@ -2962,8 +2962,10 @@ static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, ret =0 ; mm =get_task_mm (task);if (mm) { +unsigned long flags =__mm_flags_get_dumpable (mm); + len =snprintf (buffer,sizeof (buffer),"%08lx\n" , - ((mm->flags &MMF_DUMP_FILTER_MASK ) >> + ((flags &MMF_DUMP_FILTER_MASK ) >>MMF_DUMP_FILTER_SHIFT ));mmput (mm); ret =simple_read_from_buffer (buf, count, ppos, buffer, len);@@ -3002,9 +3004,9 @@ static ssize_t proc_coredump_filter_write(struct file *file,for (i =0 , mask =1 ; i <MMF_DUMP_FILTER_BITS ; i++, mask <<=1 ) {if (val & mask) -set_bit (i +MMF_DUMP_FILTER_SHIFT , &mm->flags); +mm_flags_set (i +MMF_DUMP_FILTER_SHIFT , mm);else -clear_bit (i +MMF_DUMP_FILTER_SHIFT , &mm->flags); +mm_flags_clear (i +MMF_DUMP_FILTER_SHIFT , mm); }mmput (mm);include/linux/sched/coredump.h +20
-1@@ -2,12 +2,29 @@#ifndef _LINUX_SCHED_COREDUMP_H#define _LINUX_SCHED_COREDUMP_H +#include <linux/compiler_types.h> #include <linux/mm_types.h> #define SUID_DUMP_DISABLE 0/* No setuid dumping */ #define SUID_DUMP_USER 1/* Dump as user of process */ #define SUID_DUMP_ROOT 2/* Dump as root */ +static inline unsigned long __mm_flags_get_dumpable (struct mm_struct *mm) +{ +/* +* By convention, dumpable bits are contained in first 32 bits of the +* bitmap, so we can simply access this first unsigned long directly. +*/ +return __mm_flags_get_word (mm); +} + +static inline void __mm_flags_set_mask_dumpable (struct mm_struct *mm,int value) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +set_mask_bits (bitmap,MMF_DUMPABLE_MASK , value); +} +extern void set_dumpable (struct mm_struct *mm,int value);/* * This returns the actual value of the suid_dumpable flag. For things @@ -22,7 +39,9 @@ static inline int __get_dumpable(unsigned long mm_flags)static inline int get_dumpable (struct mm_struct *mm) { -return __get_dumpable (mm->flags); +unsigned long flags =__mm_flags_get_dumpable (mm); + +return __get_dumpable (flags); }#endif /* _LINUX_SCHED_COREDUMP_H */ Signature · 1 line
2.50.1
Re: [PATCH 06/10] mm: update coredump logic to correctly use bitmap mm flags
In reply to Lorenzo StoakesQuoted 8 lines · Lorenzo Stoakes
The coredump logic is slightly different from other users in that it both stores mm flags and additionally sets and gets using masks.
Since the MMF_DUMPABLE_* flags must remain as they are for uABI reasons, and of course these are within the first 32-bits of the flags, it is reasonable to provide access to these in the same fashion so this logic can all still keep working as it has been.
Quoted 5 lines
Therefore, introduce coredump-specific helpers
__mm_flags_get_dumpable()and__mm_flags_set_mask_dumpable()for this purpose, and update all core dump users of mm flags to use these.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 131 lines
--- fs/coredump.c | 4 +++- fs/exec.c | 2 +- fs/pidfs.c | 7 +++++-- fs/proc/base.c | 8 +++++--- include/linux/sched/coredump.h | 21 ++++++++++++++++++++- 5 files changed, 34 insertions(+), 8 deletions(-)fs/coredump.c +3
-1@@ -1103,8 +1103,10 @@ void vfs_coredump(const kernel_siginfo_t *siginfo)* We must use the same mm->flags while dumping core to avoid * inconsistency of bit flags, since this flag is not protected * by any locks. +* +* Note that we only care about MMF_DUMP* flags. */ - .mm_flags = mm->flags, + .mm_flags = __mm_flags_get_dumpable(mm), .vma_meta = NULL, .cpu = raw_smp_processor_id(), };fs/exec.c +1
-1@@ -1999,7 +1999,7 @@ void set_dumpable(struct mm_struct *mm, int value)if (WARN_ON ((unsigned )value >SUID_DUMP_ROOT ))return ; -set_mask_bits (&mm->flags,MMF_DUMPABLE_MASK , value); +__mm_flags_set_mask_dumpable (mm, value); } SYSCALL_DEFINE3(execve,fs/pidfs.c +5
-2@@ -357,8 +357,11 @@ static long pidfd_info(struct file *file, unsigned int cmd, unsigned long arg)if ((kinfo.mask &PIDFD_INFO_COREDUMP ) && !(kinfo.coredump_mask)) {task_lock (task); -if (task->mm) - kinfo.coredump_mask =pidfs_coredump_mask (task->mm->flags); +if (task->mm) { +unsigned long flags =__mm_flags_get_dumpable (task->mm); + + kinfo.coredump_mask =pidfs_coredump_mask (flags); + }task_unlock (task); }fs/proc/base.c +5
-3@@ -2962,8 +2962,10 @@ static ssize_t proc_coredump_filter_read(struct file *file, char __user *buf, ret =0 ; mm =get_task_mm (task);if (mm) { +unsigned long flags =__mm_flags_get_dumpable (mm); + len =snprintf (buffer,sizeof (buffer),"%08lx\n" , - ((mm->flags &MMF_DUMP_FILTER_MASK ) >> + ((flags &MMF_DUMP_FILTER_MASK ) >>MMF_DUMP_FILTER_SHIFT ));mmput (mm); ret =simple_read_from_buffer (buf, count, ppos, buffer, len);@@ -3002,9 +3004,9 @@ static ssize_t proc_coredump_filter_write(struct file *file,for (i =0 , mask =1 ; i <MMF_DUMP_FILTER_BITS ; i++, mask <<=1 ) {if (val & mask) -set_bit (i +MMF_DUMP_FILTER_SHIFT , &mm->flags); +mm_flags_set (i +MMF_DUMP_FILTER_SHIFT , mm);else -clear_bit (i +MMF_DUMP_FILTER_SHIFT , &mm->flags); +mm_flags_clear (i +MMF_DUMP_FILTER_SHIFT , mm); }mmput (mm);include/linux/sched/coredump.h +20
-1@@ -2,12 +2,29 @@#ifndef _LINUX_SCHED_COREDUMP_H#define _LINUX_SCHED_COREDUMP_H +#include <linux/compiler_types.h> #include <linux/mm_types.h> #define SUID_DUMP_DISABLE 0/* No setuid dumping */ #define SUID_DUMP_USER 1/* Dump as user of process */ #define SUID_DUMP_ROOT 2/* Dump as root */ +static inline unsigned long __mm_flags_get_dumpable (struct mm_struct *mm) +{ +/* +* By convention, dumpable bits are contained in first 32 bits of the +* bitmap, so we can simply access this first unsigned long directly. +*/ +return __mm_flags_get_word (mm); +} + +static inline void __mm_flags_set_mask_dumpable (struct mm_struct *mm,int value) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +set_mask_bits (bitmap,MMF_DUMPABLE_MASK , value); +} +extern void set_dumpable (struct mm_struct *mm,int value);/* * This returns the actual value of the suid_dumpable flag. For things @@ -22,7 +39,9 @@ static inline int __get_dumpable(unsigned long mm_flags)static inline int get_dumpable (struct mm_struct *mm) { -return __get_dumpable (mm->flags); +unsigned long flags =__mm_flags_get_dumpable (mm); + +return __get_dumpable (flags); }#endif /* _LINUX_SCHED_COREDUMP_H */ Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 06/10] mm: update coredump logic to correctly use bitmap mm flags
In reply to Lorenzo StoakesQuoted 10 lines · Lorenzo Stoakes
The coredump logic is slightly different from other users in that it both stores mm flags and additionally sets and gets using masks.
Since the MMF_DUMPABLE_* flags must remain as they are for uABI reasons, and of course these are within the first 32-bits of the flags, it is reasonable to provide access to these in the same fashion so this logic can all still keep working as it has been.
Therefore, introduce coredump-specific helpers
__mm_flags_get_dumpable()and__mm_flags_set_mask_dumpable()for this purpose, and update all core
Why the double underscore here? Just looks a bit ugly so if we can avoid it I would but if not:
Re: [PATCH 06/10] mm: update coredump logic to correctly use bitmap mm flags
Quoted 9 lines · Christian Brauner
Quoted 8 lines · Lorenzo Stoakes
The coredump logic is slightly different from other users in that it both stores mm flags and additionally sets and gets using masks.
Since the MMF_DUMPABLE_* flags must remain as they are for uABI reasons, and of course these are within the first 32-bits of the flags, it is reasonable to provide access to these in the same fashion so this logic can all still keep working as it has been.
Quoted 7 lines
Quoted 2 lines
Therefore, introduce coredump-specific helpers
__mm_flags_get_dumpable()and__mm_flags_set_mask_dumpable()for this purpose, and update all coreWhy the double underscore here? Just looks a bit ugly so if we can avoid it I would but if not:
Reviewed-by Christian Brauner <[email protected]>
Thanks!
The double underscore is to fit the bitops convention of bitop() is atomic, __bitop() is non-atomic. Obviously these operations were and are non-atomic so this is where this came from.
I do that because the vast majority of operations on mm flags were atomic bitops before so it is in keeping with.
Re: [PATCH 06/10] mm: update coredump logic to correctly use bitmap mm flags
In reply to Lorenzo StoakesHi Andrew,
The arc architecture with a specific randconfig does not like this, so I enclose a fix-patch to satisfy this case.
From 04c8084551dbbac3cd1716164e5a19a367be652e Mon Sep 17 00:00:00 2001
From: Lorenzo Stoakes <[email protected]>
Date: Tue, 26 Aug 2025 12:25:16 +0100
Subject: [PATCH] mm: abstract set_mask_bits() invocation to mm_types.h to
satisfy ARC
There's some horrible recursive header issue for ARCH whereby you can't even apparently include very fundamental headers like compiler_types.h in linux/sched/coredump.h.
So work around this by putting the thing that needs this (use of ACCESS_PRIVATE()) into mm_types.h which presumably in some fashion avoids this issue.
This also makes it consistent with __mm_flags_get_dumpable() so is a good change to make things more consistent and neat anyway.
--- include/linux/mm_types.h | 12 ++++++++++++ include/linux/sched/coredump.h | 5 +---- 2 files changed, 13 insertions(+), 4 deletions(-)
include/linux/mm_types.h +12 -0
@@ -1255,6 +1255,18 @@ static inline unsigned long __mm_flags_get_word(const struct mm_struct *mm)return bitmap_read (bitmap,0 ,BITS_PER_LONG ); } +/* +* Update the first system word of mm flags ONLY, applying the specified mask to +* it, then setting all flags specified by bits. +*/ +static inline void __mm_flags_set_mask_bits_word (struct mm_struct *mm, +unsigned long mask,unsigned long bits) +{ +unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); + +set_mask_bits (bitmap, mask, bits); +} +#define MM_MT_FLAGS (MT_FLAGS_ALLOC_RANGE | MT_FLAGS_LOCK_EXTERN | \ MT_FLAGS_USE_RCU)extern struct mm_struct init_mm;
include/linux/sched/coredump.h +1 -4
@@ -2,7 +2,6 @@#ifndef _LINUX_SCHED_COREDUMP_H#define _LINUX_SCHED_COREDUMP_H -#include <linux/compiler_types.h> #include <linux/mm_types.h> #define SUID_DUMP_DISABLE 0/* No setuid dumping */
@@ -20,9 +19,7 @@ static inline unsigned long __mm_flags_get_dumpable(struct mm_struct *mm)static inline void __mm_flags_set_mask_dumpable (struct mm_struct *mm,int value) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); - -set_mask_bits (bitmap,MMF_DUMPABLE_MASK , value); +__mm_flags_set_mask_bits_word (mm,MMF_DUMPABLE_MASK , value); }extern void set_dumpable (struct mm_struct *mm,int value);
--
2.50.1
Re: [PATCH 06/10] mm: update coredump logic to correctly use bitmap mm flags
In reply to Lorenzo StoakesQuoted 8 lines · Lorenzo Stoakes
The coredump logic is slightly different from other users in that it both stores mm flags and additionally sets and gets using masks.
Since the MMF_DUMPABLE_* flags must remain as they are for uABI reasons, and of course these are within the first 32-bits of the flags, it is reasonable to provide access to these in the same fashion so this logic can all still keep working as it has been.
Quoted 6 lines
Therefore, introduce coredump-specific helpers
__mm_flags_get_dumpable()and__mm_flags_set_mask_dumpable()for this purpose, and update all core dump users of mm flags to use these.Signed-off-by Lorenzo Stoakes <[email protected]>---
Incl. fixup LGTM
Signature · 3 lines
Cheers David / dhildenb
PATCH 7/10 mm: correct sign-extension issue in MMF_* flag masks
In reply to Lorenzo StoakesThere is an issue with the mask declarations in linux/mm_types.h, which naively do (1 << bit) operations. Unfortunately this results in the 1 being defaulted as a signed (32-bit) integer.
When the compiler expands the MMF_INIT_MASK bitmask it comes up with:
(((1 << 2) - 1) | (((1 << 9) - 1) << 2) | (1 << 24) | (1 << 28) | (1 << 30) | (1 << 31))
Which overflows the signed integer to -788,527,105. Implicitly casting this to an unsigned integer results in sign-expansion, and thus this value becomes 0xffffffffd10007ff, rather than the intended 0xd10007ff.
While we're limited to a maximum of 32 bits in mm->flags, this isn't an issue as the remaining bits being masked will always be zero.
However, now we are moving towards having more bits in this flag, this becomes an issue.
Simply resolve this by using the _BITUL() helper to cast the shifted value to an unsigned long.
--- include/linux/mm_types.h | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-)
include/linux/mm_types.h +9 -10
@@ -1756,7 +1756,7 @@ enum {* the modes are SUID_DUMP_* defined in linux/sched/coredump.h */ #define MMF_DUMPABLE_BITS 2 -#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1) +#define MMF_DUMPABLE_MASK (_BITUL(MMF_DUMPABLE_BITS) - 1)/* coredump filter bits */ #define MMF_DUMP_ANON_PRIVATE 2#define MMF_DUMP_ANON_SHARED 3
@@ -1771,13 +1771,13 @@ enum {#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS#define MMF_DUMP_FILTER_BITS 9#define MMF_DUMP_FILTER_MASK \ - (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) + ((_BITUL(MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)#define MMF_DUMP_FILTER_DEFAULT \ - ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\ - (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF) + (_BITUL(MMF_DUMP_ANON_PRIVATE) | _BITUL(MMF_DUMP_ANON_SHARED) | \ + _BITUL(MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS -# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS) +# define MMF_DUMP_MASK_DEFAULT_ELF _BITUL(MMF_DUMP_ELF_HEADERS)#else # define MMF_DUMP_MASK_DEFAULT_ELF 0#endif
@@ -1797,7 +1797,7 @@ enum {#define MMF_UNSTABLE 22/* mm is unstable for copy_from_user */ #define MMF_HUGE_ZERO_FOLIO 23/* mm has ever used the global huge zero folio */ #define MMF_DISABLE_THP 24/* disable THP for all VMAs */ -#define MMF_DISABLE_THP_MASK (1 << MMF_DISABLE_THP) +#define MMF_DISABLE_THP_MASK _BITUL(MMF_DISABLE_THP)#define MMF_OOM_REAP_QUEUED 25/* mm was queued for oom_reaper */ #define MMF_MULTIPROCESS 26/* mm is shared between processes */ /*
@@ -1810,16 +1810,15 @@ enum {#define MMF_HAS_PINNED 27/* FOLL_PIN has run, never cleared */ #define MMF_HAS_MDWE 28 -#define MMF_HAS_MDWE_MASK (1 << MMF_HAS_MDWE) - +#define MMF_HAS_MDWE_MASK _BITUL(MMF_HAS_MDWE)#define MMF_HAS_MDWE_NO_INHERIT 29#define MMF_VM_MERGE_ANY 30 -#define MMF_VM_MERGE_ANY_MASK (1 << MMF_VM_MERGE_ANY) +#define MMF_VM_MERGE_ANY_MASK _BITUL(MMF_VM_MERGE_ANY)#define MMF_TOPDOWN 31/* mm searches top down by default */ -#define MMF_TOPDOWN_MASK (1 << MMF_TOPDOWN) +#define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN)#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\
Signature · 1 line
2.50.1
Re: [PATCH 07/10] mm: correct sign-extension issue in MMF_* flag masks
Quoted 16 lines · Lorenzo Stoakes
There is an issue with the mask declarations in
linux/mm_types.h, which naively do (1 << bit) operations. Unfortunately this results in the 1 being defaulted as a signed (32-bit) integer.When the compiler expands the
MMF_INIT_MASKbitmask it comes up with:(((1 << 2) - 1) | (((1 << 9) - 1) << 2) | (1 << 24) | (1 << 28) | (1 << 30) | (1 << 31))
Which overflows the signed integer to -788,527,105. Implicitly casting this to an unsigned integer results in sign-expansion, and thus this value becomes
0xffffffffd10007ff, rather than the intended0xd10007ff.While we're limited to a maximum of 32 bits in
mm->flags, this isn't an issue as the remaining bits being masked will always be zero.
Quoted 7 lines
However, now we are moving towards having more bits in this flag, this becomes an issue.
Simply resolve this by using the
_BITUL()helper to cast the shifted value to an unsigned long.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 67 lines
--- include/linux/mm_types.h | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-)include/linux/mm_types.h +9
-10@@ -1756,7 +1756,7 @@ enum {* the modes are SUID_DUMP_* defined in linux/sched/coredump.h */ #define MMF_DUMPABLE_BITS 2 -#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1) +#define MMF_DUMPABLE_MASK (_BITUL(MMF_DUMPABLE_BITS) - 1)/* coredump filter bits */ #define MMF_DUMP_ANON_PRIVATE 2#define MMF_DUMP_ANON_SHARED 3@@ -1771,13 +1771,13 @@ enum {#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS#define MMF_DUMP_FILTER_BITS 9#define MMF_DUMP_FILTER_MASK \ - (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) + ((_BITUL(MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)#define MMF_DUMP_FILTER_DEFAULT \ - ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\ - (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF) + (_BITUL(MMF_DUMP_ANON_PRIVATE) | _BITUL(MMF_DUMP_ANON_SHARED) | \ + _BITUL(MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS -# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS) +# define MMF_DUMP_MASK_DEFAULT_ELF _BITUL(MMF_DUMP_ELF_HEADERS)#else # define MMF_DUMP_MASK_DEFAULT_ELF 0#endif @@ -1797,7 +1797,7 @@ enum {#define MMF_UNSTABLE 22/* mm is unstable for copy_from_user */ #define MMF_HUGE_ZERO_FOLIO 23/* mm has ever used the global huge zero folio */ #define MMF_DISABLE_THP 24/* disable THP for all VMAs */ -#define MMF_DISABLE_THP_MASK (1 << MMF_DISABLE_THP) +#define MMF_DISABLE_THP_MASK _BITUL(MMF_DISABLE_THP)#define MMF_OOM_REAP_QUEUED 25/* mm was queued for oom_reaper */ #define MMF_MULTIPROCESS 26/* mm is shared between processes */ /* @@ -1810,16 +1810,15 @@ enum {#define MMF_HAS_PINNED 27/* FOLL_PIN has run, never cleared */ #define MMF_HAS_MDWE 28 -#define MMF_HAS_MDWE_MASK (1 << MMF_HAS_MDWE) - +#define MMF_HAS_MDWE_MASK _BITUL(MMF_HAS_MDWE)#define MMF_HAS_MDWE_NO_INHERIT 29#define MMF_VM_MERGE_ANY 30 -#define MMF_VM_MERGE_ANY_MASK (1 << MMF_VM_MERGE_ANY) +#define MMF_VM_MERGE_ANY_MASK _BITUL(MMF_VM_MERGE_ANY)#define MMF_TOPDOWN 31/* mm searches top down by default */ -#define MMF_TOPDOWN_MASK (1 << MMF_TOPDOWN) +#define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN)#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\Signature · 1 line
2.50.1
Re: [PATCH 07/10] mm: correct sign-extension issue in MMF_* flag masks
In reply to Lorenzo StoakesQuoted 16 lines · Lorenzo Stoakes
There is an issue with the mask declarations in
linux/mm_types.h, which naively do (1 << bit) operations. Unfortunately this results in the 1 being defaulted as a signed (32-bit) integer.When the compiler expands the
MMF_INIT_MASKbitmask it comes up with:(((1 << 2) - 1) | (((1 << 9) - 1) << 2) | (1 << 24) | (1 << 28) | (1 << 30) | (1 << 31))
Which overflows the signed integer to -788,527,105. Implicitly casting this to an unsigned integer results in sign-expansion, and thus this value becomes
0xffffffffd10007ff, rather than the intended0xd10007ff.While we're limited to a maximum of 32 bits in
mm->flags, this isn't an issue as the remaining bits being masked will always be zero.
Quoted 7 lines
However, now we are moving towards having more bits in this flag, this becomes an issue.
Simply resolve this by using the
_BITUL()helper to cast the shifted value to an unsigned long.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 67 lines
--- include/linux/mm_types.h | 19 +++++++++---------- 1 file changed, 9 insertions(+), 10 deletions(-)include/linux/mm_types.h +9
-10@@ -1756,7 +1756,7 @@ enum {* the modes are SUID_DUMP_* defined in linux/sched/coredump.h */ #define MMF_DUMPABLE_BITS 2 -#define MMF_DUMPABLE_MASK ((1 << MMF_DUMPABLE_BITS) - 1) +#define MMF_DUMPABLE_MASK (_BITUL(MMF_DUMPABLE_BITS) - 1)/* coredump filter bits */ #define MMF_DUMP_ANON_PRIVATE 2#define MMF_DUMP_ANON_SHARED 3@@ -1771,13 +1771,13 @@ enum {#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS#define MMF_DUMP_FILTER_BITS 9#define MMF_DUMP_FILTER_MASK \ - (((1 << MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) + ((_BITUL(MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)#define MMF_DUMP_FILTER_DEFAULT \ - ((1 << MMF_DUMP_ANON_PRIVATE) | (1 << MMF_DUMP_ANON_SHARED) |\ - (1 << MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF) + (_BITUL(MMF_DUMP_ANON_PRIVATE) | _BITUL(MMF_DUMP_ANON_SHARED) | \ + _BITUL(MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS -# define MMF_DUMP_MASK_DEFAULT_ELF (1 << MMF_DUMP_ELF_HEADERS) +# define MMF_DUMP_MASK_DEFAULT_ELF _BITUL(MMF_DUMP_ELF_HEADERS)#else # define MMF_DUMP_MASK_DEFAULT_ELF 0#endif @@ -1797,7 +1797,7 @@ enum {#define MMF_UNSTABLE 22/* mm is unstable for copy_from_user */ #define MMF_HUGE_ZERO_FOLIO 23/* mm has ever used the global huge zero folio */ #define MMF_DISABLE_THP 24/* disable THP for all VMAs */ -#define MMF_DISABLE_THP_MASK (1 << MMF_DISABLE_THP) +#define MMF_DISABLE_THP_MASK _BITUL(MMF_DISABLE_THP)#define MMF_OOM_REAP_QUEUED 25/* mm was queued for oom_reaper */ #define MMF_MULTIPROCESS 26/* mm is shared between processes */ /* @@ -1810,16 +1810,15 @@ enum {#define MMF_HAS_PINNED 27/* FOLL_PIN has run, never cleared */ #define MMF_HAS_MDWE 28 -#define MMF_HAS_MDWE_MASK (1 << MMF_HAS_MDWE) - +#define MMF_HAS_MDWE_MASK _BITUL(MMF_HAS_MDWE)#define MMF_HAS_MDWE_NO_INHERIT 29#define MMF_VM_MERGE_ANY 30 -#define MMF_VM_MERGE_ANY_MASK (1 << MMF_VM_MERGE_ANY) +#define MMF_VM_MERGE_ANY_MASK _BITUL(MMF_VM_MERGE_ANY)#define MMF_TOPDOWN 31/* mm searches top down by default */ -#define MMF_TOPDOWN_MASK (1 << MMF_TOPDOWN) +#define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN)#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 07/10] mm: correct sign-extension issue in MMF_* flag masks
In reply to Lorenzo StoakesQuoted 13 lines · Lorenzo Stoakes
There is an issue with the mask declarations in
linux/mm_types.h, which naively do (1 << bit) operations. Unfortunately this results in the 1 being defaulted as a signed (32-bit) integer.When the compiler expands the
MMF_INIT_MASKbitmask it comes up with:(((1 << 2) - 1) | (((1 << 9) - 1) << 2) | (1 << 24) | (1 << 28) | (1 << 30) | (1 << 31))
Which overflows the signed integer to -788,527,105. Implicitly casting this to an unsigned integer results in sign-expansion, and thus this value becomes
0xffffffffd10007ff, rather than the intended0xd10007ff.
Quoted 8 lines
While we're limited to a maximum of 32 bits in
mm->flags, this isn't an issue as the remaining bits being masked will always be zero.However, now we are moving towards having more bits in this flag, this becomes an issue.
Simply resolve this by using the
_BITUL()helper to cast the shifted value to an unsigned long.
Hmm, I thought BIT() should be used and would just fine?
include/linux/bits.h includes <vdso/bits.h> where we have
#define BIT(nr) (UL(1) << (nr))
In contrast, _BITUL is a uapi thingy from include/uapi/linux/const.h ... as it seems.
$ git grep "_BITUL" -- include/linux/ include/linux/mm_types.h:#define MMF_DUMPABLE_MASK (_BITUL(MMF_DUMPABLE_BITS) - 1) include/linux/mm_types.h: ((_BITUL(MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) include/linux/mm_types.h: (_BITUL(MMF_DUMP_ANON_PRIVATE) | _BITUL(MMF_DUMP_ANON_SHARED) | \ include/linux/mm_types.h: _BITUL(MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF) include/linux/mm_types.h:# define MMF_DUMP_MASK_DEFAULT_ELF _BITUL(MMF_DUMP_ELF_HEADERS) include/linux/mm_types.h:#define MMF_DISABLE_THP_MASK (_BITUL(MMF_DISABLE_THP_COMPLETELY) | \ include/linux/mm_types.h: _BITUL(MMF_DISABLE_THP_EXCEPT_ADVISED)) include/linux/mm_types.h:#define MMF_HAS_MDWE_MASK _BITUL(MMF_HAS_MDWE) include/linux/mm_types.h:#define MMF_VM_MERGE_ANY_MASK _BITUL(MMF_VM_MERGE_ANY) include/linux/mm_types.h:#define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN)
Oh, hey, it's only your changes :P
We should better just be using BIT().
Signature · 3 lines
Cheers David / dhildenb
Re: [PATCH 07/10] mm: correct sign-extension issue in MMF_* flag masks
Quoted 17 lines · David Hildenbrand
Quoted 16 lines · Lorenzo Stoakes
There is an issue with the mask declarations in
linux/mm_types.h, which naively do (1 << bit) operations. Unfortunately this results in the 1 being defaulted as a signed (32-bit) integer.When the compiler expands the
MMF_INIT_MASKbitmask it comes up with:(((1 << 2) - 1) | (((1 << 9) - 1) << 2) | (1 << 24) | (1 << 28) | (1 << 30) | (1 << 31))
Which overflows the signed integer to -788,527,105. Implicitly casting this to an unsigned integer results in sign-expansion, and thus this value becomes
0xffffffffd10007ff, rather than the intended0xd10007ff.While we're limited to a maximum of 32 bits in
mm->flags, this isn't an issue as the remaining bits being masked will always be zero.
Quoted 7 lines
Quoted 5 lines
However, now we are moving towards having more bits in this flag, this becomes an issue.
Simply resolve this by using the
_BITUL()helper to cast the shifted value to an unsigned long.Hmm, I thought
BIT()should be used and would just fine?
Sure.
Re: [PATCH 07/10] mm: correct sign-extension issue in MMF_* flag masks
In reply to Lorenzo StoakesHi Andrew,
Quick fix-patch to use BIT() in favour of _BITUL() as requested by David, since this is a far more sensible way of generating a bitmask.
Thanks, Lorenzo
----8<----
From 83a10e3fe7dbbc7ab7c04312fff32b28787acf9b Mon Sep 17 00:00:00 2001
From: Lorenzo Stoakes <[email protected]>
Date: Tue, 26 Aug 2025 15:01:18 +0100
Subject: [PATCH] mm: prefer BIT() to _BITUL()
BIT() does the same thing, and is defined in actual linux headers rather than a uapi header.
--- include/linux/mm_types.h | 18 +++++++++--------- 1 file changed, 9 insertions(+), 9 deletions(-)
include/linux/mm_types.h +9 -9
@@ -1755,7 +1755,7 @@ enum {* the modes are SUID_DUMP_* defined in linux/sched/coredump.h */ #define MMF_DUMPABLE_BITS 2 -#define MMF_DUMPABLE_MASK (_BITUL(MMF_DUMPABLE_BITS) - 1) +#define MMF_DUMPABLE_MASK (BIT(MMF_DUMPABLE_BITS) - 1)/* coredump filter bits */ #define MMF_DUMP_ANON_PRIVATE 2#define MMF_DUMP_ANON_SHARED 3
@@ -1770,13 +1770,13 @@ enum {#define MMF_DUMP_FILTER_SHIFT MMF_DUMPABLE_BITS#define MMF_DUMP_FILTER_BITS 9#define MMF_DUMP_FILTER_MASK \ - ((_BITUL(MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT) + ((BIT(MMF_DUMP_FILTER_BITS) - 1) << MMF_DUMP_FILTER_SHIFT)#define MMF_DUMP_FILTER_DEFAULT \ - (_BITUL(MMF_DUMP_ANON_PRIVATE) | _BITUL(MMF_DUMP_ANON_SHARED) | \ - _BITUL(MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF) + (BIT(MMF_DUMP_ANON_PRIVATE) | BIT(MMF_DUMP_ANON_SHARED) | \ + BIT(MMF_DUMP_HUGETLB_PRIVATE) | MMF_DUMP_MASK_DEFAULT_ELF)#ifdef CONFIG_CORE_DUMP_DEFAULT_ELF_HEADERS -# define MMF_DUMP_MASK_DEFAULT_ELF _BITUL(MMF_DUMP_ELF_HEADERS) +# define MMF_DUMP_MASK_DEFAULT_ELF BIT(MMF_DUMP_ELF_HEADERS)#else # define MMF_DUMP_MASK_DEFAULT_ELF 0#endif
@@ -1796,7 +1796,7 @@ enum {#define MMF_UNSTABLE 22/* mm is unstable for copy_from_user */ #define MMF_HUGE_ZERO_FOLIO 23/* mm has ever used the global huge zero folio */ #define MMF_DISABLE_THP 24/* disable THP for all VMAs */ -#define MMF_DISABLE_THP_MASK _BITUL(MMF_DISABLE_THP) +#define MMF_DISABLE_THP_MASK BIT(MMF_DISABLE_THP)#define MMF_OOM_REAP_QUEUED 25/* mm was queued for oom_reaper */ #define MMF_MULTIPROCESS 26/* mm is shared between processes */ /*
@@ -1809,15 +1809,15 @@ enum {#define MMF_HAS_PINNED 27/* FOLL_PIN has run, never cleared */ #define MMF_HAS_MDWE 28 -#define MMF_HAS_MDWE_MASK _BITUL(MMF_HAS_MDWE) +#define MMF_HAS_MDWE_MASK BIT(MMF_HAS_MDWE)#define MMF_HAS_MDWE_NO_INHERIT 29#define MMF_VM_MERGE_ANY 30 -#define MMF_VM_MERGE_ANY_MASK _BITUL(MMF_VM_MERGE_ANY) +#define MMF_VM_MERGE_ANY_MASK BIT(MMF_VM_MERGE_ANY)#define MMF_TOPDOWN 31/* mm searches top down by default */ -#define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) +#define MMF_TOPDOWN_MASK BIT(MMF_TOPDOWN)#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\
--
2.50.1
PATCH 8/10 mm: update fork mm->flags initialisation to use bitmap
In reply to Lorenzo StoakesWe now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in mm_init() on a per-flag basis.
We ensure we clear the entire bitmap prior to setting it, and use __mm_flags_get_word() and __mm_flags_set_word() to manipulate these legacy fields efficiently.
--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)
include/linux/mm_types.h +10 -3
@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX ); + +/* +* Initialise legacy flags according to masks, propagating selected flags on +* fork. Further flag manipulation can be performed by the caller. +*/ +static inline unsigned long mmf_init_legacy_flags (unsigned long flags) {if (flags & (1UL <<MMF_HAS_MDWE_NO_INHERIT )) flags &= ~((1UL <<MMF_HAS_MDWE ) | (1UL <<MMF_HAS_MDWE_NO_INHERIT )); -return flags &MMF_INIT_MASK ; +return flags &MMF_INIT_LEGACY_MASK ; }#endif /* _LINUX_MM_TYPES_H */
kernel/fork.c +5 -2
@@ -1056,11 +1056,14 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p,mm_init_uprobes_state (mm);hugetlb_count_init (mm); +mm_flags_clear_all (mm);if (current->mm) { - mm->flags =mmf_init_flags (current->mm->flags); +unsigned long flags =__mm_flags_get_word (current->mm); + +__mm_flags_set_word (mm,mmf_init_legacy_flags (flags)); mm->def_flags = current->mm->def_flags &VM_INIT_DEF_MASK ; }else { - mm->flags = default_dump_filter; +__mm_flags_set_word (mm, default_dump_filter); mm->def_flags =0 ; }
Signature · 1 line
2.50.1
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 6 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
Quoted 8 lines
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 60 lines
--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)include/linux/mm_types.h +10
-3@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX ); + +/* +* Initialise legacy flags according to masks, propagating selected flags on +* fork. Further flag manipulation can be performed by the caller. +*/ +static inline unsigned long mmf_init_legacy_flags (unsigned long flags) {if (flags & (1UL <<MMF_HAS_MDWE_NO_INHERIT )) flags &= ~((1UL <<MMF_HAS_MDWE ) | (1UL <<MMF_HAS_MDWE_NO_INHERIT )); -return flags &MMF_INIT_MASK ; +return flags &MMF_INIT_LEGACY_MASK ; }#endif /* _LINUX_MM_TYPES_H */ kernel/fork.c +5
-2@@ -1056,11 +1056,14 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p,mm_init_uprobes_state (mm);hugetlb_count_init (mm); +mm_flags_clear_all (mm);if (current->mm) { - mm->flags =mmf_init_flags (current->mm->flags); +unsigned long flags =__mm_flags_get_word (current->mm); + +__mm_flags_set_word (mm,mmf_init_legacy_flags (flags)); mm->def_flags = current->mm->def_flags &VM_INIT_DEF_MASK ; }else { - mm->flags = default_dump_filter; +__mm_flags_set_word (mm, default_dump_filter); mm->def_flags =0 ; }Signature · 1 line
2.50.1
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
In reply to Lorenzo StoakesQuoted 6 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
Quoted 8 lines
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 60 lines
--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)include/linux/mm_types.h +10
-3@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX ); + +/* +* Initialise legacy flags according to masks, propagating selected flags on +* fork. Further flag manipulation can be performed by the caller. +*/ +static inline unsigned long mmf_init_legacy_flags (unsigned long flags) {if (flags & (1UL <<MMF_HAS_MDWE_NO_INHERIT )) flags &= ~((1UL <<MMF_HAS_MDWE ) | (1UL <<MMF_HAS_MDWE_NO_INHERIT )); -return flags &MMF_INIT_MASK ; +return flags &MMF_INIT_LEGACY_MASK ; }#endif /* _LINUX_MM_TYPES_H */ kernel/fork.c +5
-2@@ -1056,11 +1056,14 @@ static struct mm_struct *mm_init(struct mm_struct *mm, struct task_struct *p,mm_init_uprobes_state (mm);hugetlb_count_init (mm); +mm_flags_clear_all (mm);if (current->mm) { - mm->flags =mmf_init_flags (current->mm->flags); +unsigned long flags =__mm_flags_get_word (current->mm); + +__mm_flags_set_word (mm,mmf_init_legacy_flags (flags)); mm->def_flags = current->mm->def_flags &VM_INIT_DEF_MASK ; }else { - mm->flags = default_dump_filter; +__mm_flags_set_word (mm, default_dump_filter); mm->def_flags =0 ; }Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
In reply to Lorenzo StoakesQuoted 25 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)include/linux/mm_types.h +0
-0@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */
include/linux/mm_types.h enum { · line 1828
Quoted 10 lines
include/linux/mm_types.h +3
-2#define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX );
Why not use the magic number 32 you are mentioning in the comment? :)
static_assert((u32)MMF_INIT_LEGACY_MASK != MMF_INIT_LEGACY_MASK);
include/linux/mm_types.h enum { · line 1832
Quoted 4 lines
include/linux/mm_types.h +4
-0+ +/* +* Initialise legacy flags according to masks, propagating selected flags on +* fork. Further flag manipulation can be performed by the caller.
It's weird not reading "initialize", but I am afraid the kernel is already tainted :P
t14s: ~/git/linux nth_page $ git grep "initialise" | wc -l 1778
t14s: ~/git/linux nth_page $ git grep "initialize" | wc -l 22043
Besides the assert simplification
Signature · 3 lines
Cheers David / dhildenb
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 20 lines · David Hildenbrand
Quoted 19 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)
Quoted 16 lines
Quoted 5 lines
include/linux/mm_types.h +0
-0include/linux/mm_types.h enum { · line 1826
Quoted 9 lines
include/linux/mm_types.h +3
-2@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX );Why not use the magic number 32 you are mentioning in the comment? :)
Meh I mean UINT_MAX works as a good 'any bit' mask and this will work on both 32-bit and 64-bit systems.
Quoted 2 lines
static_assert((u32)MMF_INIT_LEGACY_MASK != MMF_INIT_LEGACY_MASK);
On 32-bit that'd not work would it?
Kinda the point here is that the issue would get picked up on either.
I think with the comment above it's fine as-is! :)
Quoted 9 lines
include/linux/mm_types.h enum { · line 1832
Quoted 5 lines
include/linux/mm_types.h +4
-0+ +/* +* Initialise legacy flags according to masks, propagating selected flags on +* fork. Further flag manipulation can be performed by the caller. It's weird not reading "initialize", but I am afraid the kernel is already tainted :P
Quoted 4 lines
t14s: ~/git/linux
nth_page$ git grep "initialise" | wc -l 1778
t14s: ~/git/linuxnth_page$ git grep "initialize" | wc -l 22043
British English in the kernel will survive if I have anything to do with it ;)
Quoted 4 lines
Besides the assert simplification
Thanks!
Quoted 6 lines
--
CheersDavid / dhildenb
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 38 lines · Lorenzo Stoakes
Quoted 20 lines · David Hildenbrand
Quoted 19 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)Quoted 16 lines
Quoted 5 lines
include/linux/mm_types.h +0
-0include/linux/mm_types.h enum { · line 1826
Quoted 9 lines
include/linux/mm_types.h +3
-2@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX );Why not use the magic number 32 you are mentioning in the comment? :)
Quoted 7 lines
Meh I mean
UINT_MAXworks as a good 'any bit' mask and this will work on both 32-bit and 64-bit systems.Quoted 2 lines
static_assert((u32)MMF_INIT_LEGACY_MASK != MMF_INIT_LEGACY_MASK);On 32-bit that'd not work would it?
On 32bit, BIT(32) would exceed the shift width of unsigned long -> undefined behavior.
The compiler should naturally complain.
Signature · 3 lines
Cheers David / dhildenb
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 43 lines · David Hildenbrand
Quoted 42 lines · Lorenzo Stoakes
Quoted 20 lines · David Hildenbrand
Quoted 19 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)Quoted 16 lines
Quoted 5 lines
include/linux/mm_types.h +0
-0include/linux/mm_types.h enum { · line 1826
Quoted 9 lines
include/linux/mm_types.h +3
-2@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX );Why not use the magic number 32 you are mentioning in the comment? :)
Meh I mean
UINT_MAXworks as a good 'any bit' mask and this will work on both 32-bit and 64-bit systems.Quoted 1 line
Quoted 8 lines
Quoted 3 lines
Quoted 1 line
static_assert((u32)MMF_INIT_LEGACY_MASK != MMF_INIT_LEGACY_MASK);On 32-bit that'd not work would it?
On 32bit, BIT(32) would exceed the shift width of unsigned long -> undefined behavior.
The compiler should naturally complain.
Yeah, I don't love that sorry. Firstly it's a warning, so you may well miss it (I just tried), and secondly you're making the static assert not have any meaning except that you expect to trigger a compiler warning, it's a bit bizarre.
My solution works (unless you can see a reason it shouldn't) and I don't find this approach any simpler.
Quoted 6 lines
--
CheersDavid / dhildenb
Cheers, Lorenzo
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 48 lines · Lorenzo Stoakes
Quoted 47 lines · David Hildenbrand
Quoted 45 lines · Lorenzo Stoakes
Quoted 20 lines · David Hildenbrand
Quoted 19 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)Quoted 16 lines
Quoted 5 lines
include/linux/mm_types.h +0
-0include/linux/mm_types.h enum { · line 1826
Quoted 9 lines
include/linux/mm_types.h +3
-2@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX );Why not use the magic number 32 you are mentioning in the comment? :)
Meh I mean
UINT_MAXworks as a good 'any bit' mask and this will work on both 32-bit and 64-bit systems.Quoted 2 lines
static_assert((u32)MMF_INIT_LEGACY_MASK != MMF_INIT_LEGACY_MASK);On 32-bit that'd not work would it?
Quoted 7 lines
Quoted 4 lines
On 32bit, BIT(32) would exceed the shift width of unsigned long -> undefined behavior.
The compiler should naturally complain.
Yeah, I don't love that sorry. Firstly it's a warning, so you may well miss it (I just tried),
Upstream bots usually complain at you for warnings :P
Quoted 3 lines
and secondly you're making the static assert not have any meaning except that you expect to trigger a compiler warning, it's a bit bizarre.
On 64 bit where BIT(32) *makes any sense* it triggers as expected, no?
Quoted 3 lines
My solution works (unless you can see a reason it shouldn't) and I don't find this approach any simpler.
Please explain to me like I am a 5 yo how your approach works with BIT(32) on 32bit when the behavior on 32bit is undefined. :P
Signature · 3 lines
Cheers David / dhildenb
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 52 lines · David Hildenbrand
Quoted 51 lines · Lorenzo Stoakes
Quoted 50 lines · David Hildenbrand
Quoted 38 lines · Lorenzo Stoakes
Quoted 20 lines · David Hildenbrand
Quoted 19 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)Quoted 16 lines
Quoted 5 lines
include/linux/mm_types.h +0
-0include/linux/mm_types.h enum { · line 1826
Quoted 9 lines
include/linux/mm_types.h +3
-2@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX );Why not use the magic number 32 you are mentioning in the comment? :)
Quoted 7 lines
Meh I mean
UINT_MAXworks as a good 'any bit' mask and this will work on both 32-bit and 64-bit systems.Quoted 2 lines
static_assert((u32)MMF_INIT_LEGACY_MASK != MMF_INIT_LEGACY_MASK);On 32-bit that'd not work would it?
On 32bit, BIT(32) would exceed the shift width of unsigned long -> undefined behavior.
Quoted 6 lines
Quoted 4 lines
Quoted 1 line
The compiler should naturally complain.
Yeah, I don't love that sorry. Firstly it's a warning, so you may well miss it (I just tried),
Upstream bots usually complain at you for warnings :P
Fine, but it's not a static assert and they can be delayed.
Quoted 6 lines
Quoted 4 lines
and secondly you're making the static assert not have any meaning except that you expect to trigger a compiler warning, it's a bit bizarre.
On 64 bit where BIT(32) *makes any sense* it triggers as expected, no?
It's not a static assert.
Quoted 7 lines
Quoted 4 lines
My solution works (unless you can see a reason it shouldn't) and I don't find this approach any simpler.
Please explain to me like I am a 5 yo how your approach works with BIT(32) on 32bit when the behavior on 32bit is undefined. :P
OK right I see, in both cases BIT(32) is going to cause a warning on 32-bit.
I was wrong in thinking (u64)(1UL << 32) would get fixed up because of the outer cast I guess.
This was the mistake here, so fine, we could do it this way.
I guess I'll have to respin the series at this point.
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 79 lines · Lorenzo Stoakes
Quoted 52 lines · David Hildenbrand
Quoted 51 lines · Lorenzo Stoakes
Quoted 50 lines · David Hildenbrand
Quoted 38 lines · Lorenzo Stoakes
Quoted 20 lines · David Hildenbrand
Quoted 19 lines · Lorenzo Stoakes
We now need to account for flag initialisation on fork. We retain the existing logic as much as we can, but dub the existing flag mask legacy.
These flags are therefore required to fit in the first 32-bits of the flags field.
However, further flag propagation upon fork can be implemented in
mm_init()on a per-flag basis.We ensure we clear the entire bitmap prior to setting it, and use
__mm_flags_get_word()and__mm_flags_set_word()to manipulate these legacy fields efficiently.Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm_types.h | 13 ++++++++++--- kernel/fork.c | 7 +++++-- 2 files changed, 15 insertions(+), 5 deletions(-)Quoted 16 lines
Quoted 5 lines
include/linux/mm_types.h +0
-0include/linux/mm_types.h enum { · line 1826
Quoted 9 lines
include/linux/mm_types.h +3
-2@@ -1820,16 +1820,23 @@ enum {#define MMF_TOPDOWN 31/* mm searches top down by default */ #define MMF_TOPDOWN_MASK _BITUL(MMF_TOPDOWN) -#define MMF_INIT_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ +#define MMF_INIT_LEGACY_MASK (MMF_DUMPABLE_MASK | MMF_DUMP_FILTER_MASK |\ MMF_DISABLE_THP_MASK | MMF_HAS_MDWE_MASK |\ MMF_VM_MERGE_ANY_MASK | MMF_TOPDOWN_MASK) -static inline unsigned long mmf_init_flags (unsigned long flags) +/* Legacy flags must fit within 32 bits. */ +static_assert ((u64 )MMF_INIT_LEGACY_MASK <= (u64 )UINT_MAX );Why not use the magic number 32 you are mentioning in the comment? :)
Quoted 7 lines
Meh I mean
UINT_MAXworks as a good 'any bit' mask and this will work on both 32-bit and 64-bit systems.Quoted 2 lines
static_assert((u32)MMF_INIT_LEGACY_MASK != MMF_INIT_LEGACY_MASK);On 32-bit that'd not work would it?
On 32bit, BIT(32) would exceed the shift width of unsigned long -> undefined behavior.
Quoted 6 lines
Quoted 4 lines
Quoted 1 line
The compiler should naturally complain.
Yeah, I don't love that sorry. Firstly it's a warning, so you may well miss it (I just tried),
Upstream bots usually complain at you for warnings :P
Fine, but it's not a static assert and they can be delayed.
Quoted 6 lines
Quoted 4 lines
and secondly you're making the static assert not have any meaning except that you expect to trigger a compiler warning, it's a bit bizarre.
On 64 bit where BIT(32) *makes any sense* it triggers as expected, no?
It's not a static assert.
Quoted 7 lines
Quoted 4 lines
My solution works (unless you can see a reason it shouldn't) and I don't find this approach any simpler.
Please explain to me like I am a 5 yo how your approach works with BIT(32) on 32bit when the behavior on 32bit is undefined. :P
Quoted 8 lines
OK right I see, in both cases BIT(32) is going to cause a warning on 32-bit.
I was wrong in thinking (u64)(1UL << 32) would get fixed up because of the outer cast I guess.
This was the mistake here, so fine, we could do it this way.
I guess I'll have to respin the series at this point.
Let me think again: assuming someone would mess up the BIT() thing and convert back to 1 << NR, your variant would catch it on 32bit I guess.
So given I was primarily confused by the "u64" when talking about 32it, no need for a full resend of this series just to clean this up.
Signature · 3 lines
Cheers David / dhildenb
Re: [PATCH 08/10] mm: update fork mm->flags initialisation to use bitmap
Quoted 11 lines · David Hildenbrand
Quoted 8 lines
OK right I see, in both cases BIT(32) is going to cause a warning on 32-bit.
I was wrong in thinking (u64)(1UL << 32) would get fixed up because of the outer cast I guess.
This was the mistake here, so fine, we could do it this way.
I guess I'll have to respin the series at this point.
Let me think again: assuming someone would mess up the
BIT()thing and convert back to 1 << NR, your variant would catch it on 32bit I guess.
Yeah and it should also catch the BIT() case albeit via warning :P
Quoted 3 lines
So given I was primarily confused by the "u64" when talking about 32it, no need for a full resend of this series just to clean this up.
Yeah this isn't _terrible_ I don't think, although I was labouring under a misapprehension (understandable - hopefully :) in the way the casting would work, but of course you're right the ub would happen _prior_ to the u64 cast.
Anyway I think net we're getting the same result, and the comment makes clear the intent, so I think yeah sort of fine as-is.
But I take your point absolutely :)
Cheers, Lorenzo
PATCH 9/10 mm: convert remaining users to mm_flags_*() accessors
In reply to Lorenzo StoakesAs part of the effort to move to mm->flags becoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessing mm_struct flags.
No functional change intended.
--- fs/proc/array.c | 2 +- fs/proc/base.c | 4 ++-- fs/proc/task_mmu.c | 2 +- kernel/fork.c | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-)
fs/proc/array.c +1 -1
@@ -422,7 +422,7 @@ static inline void task_thp_status(struct seq_file *m, struct mm_struct *mm)bool thp_enabled =IS_ENABLED (CONFIG_TRANSPARENT_HUGEPAGE );if (thp_enabled) - thp_enabled = !test_bit (MMF_DISABLE_THP , &mm->flags); + thp_enabled = !mm_flags_test (MMF_DISABLE_THP , mm);seq_printf (m,"THP_enabled:\t%d\n" , thp_enabled); }
fs/proc/base.c +2 -2
@@ -1163,7 +1163,7 @@ static int __set_oom_adj(struct file *file, int oom_adj, bool legacy)struct task_struct *p =find_lock_task_mm (task);if (p) { -if (test_bit (MMF_MULTIPROCESS , &p->mm->flags)) { +if (mm_flags_test (MMF_MULTIPROCESS , p->mm)) { mm = p->mm;mmgrab (mm); }
@@ -3276,7 +3276,7 @@ static int proc_pid_ksm_stat(struct seq_file *m, struct pid_namespace *ns,seq_printf (m,"ksm_merging_pages %lu\n" , mm->ksm_merging_pages);seq_printf (m,"ksm_process_profit %ld\n" ,ksm_process_profit (mm));seq_printf (m,"ksm_merge_any: %s\n" , -test_bit (MMF_VM_MERGE_ANY , &mm->flags) ?"yes" :"no" ); +mm_flags_test (MMF_VM_MERGE_ANY , mm) ?"yes" :"no" ); ret =mmap_read_lock_killable (mm);if (ret) {mmput (mm);
fs/proc/task_mmu.c +1 -1
@@ -1592,7 +1592,7 @@ static inline bool pte_is_pinned(struct vm_area_struct *vma, unsigned long addr,return false;if (!is_cow_mapping (vma->vm_flags))return false; -if (likely (!test_bit (MMF_HAS_PINNED , &vma->vm_mm->flags))) +if (likely (!mm_flags_test (MMF_HAS_PINNED , vma->vm_mm)))return false; folio =vm_normal_folio (vma, addr, pte);if (!folio)
kernel/fork.c +1 -1
@@ -1887,7 +1887,7 @@ static void copy_oom_score_adj(u64 clone_flags, struct task_struct *tsk)/* We need to synchronize with __set_oom_adj */ mutex_lock (&oom_adj_mutex); -set_bit (MMF_MULTIPROCESS , &tsk->mm->flags); +mm_flags_set (MMF_MULTIPROCESS , tsk->mm);/* Update the values in case they were changed after copy_signal */ tsk->signal->oom_score_adj = current->signal->oom_score_adj; tsk->signal->oom_score_adj_min = current->signal->oom_score_adj_min;
Signature · 1 line
2.50.1
Re: [PATCH 09/10] mm: convert remaining users to mm_flags_*() accessors
Quoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 71 lines
--- fs/proc/array.c | 2 +- fs/proc/base.c | 4 ++-- fs/proc/task_mmu.c | 2 +- kernel/fork.c | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-)fs/proc/array.c +1
-1@@ -422,7 +422,7 @@ static inline void task_thp_status(struct seq_file *m, struct mm_struct *mm)bool thp_enabled =IS_ENABLED (CONFIG_TRANSPARENT_HUGEPAGE );if (thp_enabled) - thp_enabled = !test_bit (MMF_DISABLE_THP , &mm->flags); + thp_enabled = !mm_flags_test (MMF_DISABLE_THP , mm);seq_printf (m,"THP_enabled:\t%d\n" , thp_enabled); }fs/proc/base.c +2
-2@@ -1163,7 +1163,7 @@ static int __set_oom_adj(struct file *file, int oom_adj, bool legacy)struct task_struct *p =find_lock_task_mm (task);if (p) { -if (test_bit (MMF_MULTIPROCESS , &p->mm->flags)) { +if (mm_flags_test (MMF_MULTIPROCESS , p->mm)) { mm = p->mm;mmgrab (mm); }@@ -3276,7 +3276,7 @@ static int proc_pid_ksm_stat(struct seq_file *m, struct pid_namespace *ns,seq_printf (m,"ksm_merging_pages %lu\n" , mm->ksm_merging_pages);seq_printf (m,"ksm_process_profit %ld\n" ,ksm_process_profit (mm));seq_printf (m,"ksm_merge_any: %s\n" , -test_bit (MMF_VM_MERGE_ANY , &mm->flags) ?"yes" :"no" ); +mm_flags_test (MMF_VM_MERGE_ANY , mm) ?"yes" :"no" ); ret =mmap_read_lock_killable (mm);if (ret) {mmput (mm);fs/proc/task_mmu.c +1
-1@@ -1592,7 +1592,7 @@ static inline bool pte_is_pinned(struct vm_area_struct *vma, unsigned long addr,return false;if (!is_cow_mapping (vma->vm_flags))return false; -if (likely (!test_bit (MMF_HAS_PINNED , &vma->vm_mm->flags))) +if (likely (!mm_flags_test (MMF_HAS_PINNED , vma->vm_mm)))return false; folio =vm_normal_folio (vma, addr, pte);if (!folio)kernel/fork.c +1
-1@@ -1887,7 +1887,7 @@ static void copy_oom_score_adj(u64 clone_flags, struct task_struct *tsk)/* We need to synchronize with __set_oom_adj */ mutex_lock (&oom_adj_mutex); -set_bit (MMF_MULTIPROCESS , &tsk->mm->flags); +mm_flags_set (MMF_MULTIPROCESS , tsk->mm);/* Update the values in case they were changed after copy_signal */ tsk->signal->oom_score_adj = current->signal->oom_score_adj; tsk->signal->oom_score_adj_min = current->signal->oom_score_adj_min;Signature · 1 line
2.50.1
Re: [PATCH 09/10] mm: convert remaining users to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 7 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 71 lines
--- fs/proc/array.c | 2 +- fs/proc/base.c | 4 ++-- fs/proc/task_mmu.c | 2 +- kernel/fork.c | 2 +- 4 files changed, 5 insertions(+), 5 deletions(-)fs/proc/array.c +1
-1@@ -422,7 +422,7 @@ static inline void task_thp_status(struct seq_file *m, struct mm_struct *mm)bool thp_enabled =IS_ENABLED (CONFIG_TRANSPARENT_HUGEPAGE );if (thp_enabled) - thp_enabled = !test_bit (MMF_DISABLE_THP , &mm->flags); + thp_enabled = !mm_flags_test (MMF_DISABLE_THP , mm);seq_printf (m,"THP_enabled:\t%d\n" , thp_enabled); }fs/proc/base.c +2
-2@@ -1163,7 +1163,7 @@ static int __set_oom_adj(struct file *file, int oom_adj, bool legacy)struct task_struct *p =find_lock_task_mm (task);if (p) { -if (test_bit (MMF_MULTIPROCESS , &p->mm->flags)) { +if (mm_flags_test (MMF_MULTIPROCESS , p->mm)) { mm = p->mm;mmgrab (mm); }@@ -3276,7 +3276,7 @@ static int proc_pid_ksm_stat(struct seq_file *m, struct pid_namespace *ns,seq_printf (m,"ksm_merging_pages %lu\n" , mm->ksm_merging_pages);seq_printf (m,"ksm_process_profit %ld\n" ,ksm_process_profit (mm));seq_printf (m,"ksm_merge_any: %s\n" , -test_bit (MMF_VM_MERGE_ANY , &mm->flags) ?"yes" :"no" ); +mm_flags_test (MMF_VM_MERGE_ANY , mm) ?"yes" :"no" ); ret =mmap_read_lock_killable (mm);if (ret) {mmput (mm);fs/proc/task_mmu.c +1
-1@@ -1592,7 +1592,7 @@ static inline bool pte_is_pinned(struct vm_area_struct *vma, unsigned long addr,return false;if (!is_cow_mapping (vma->vm_flags))return false; -if (likely (!test_bit (MMF_HAS_PINNED , &vma->vm_mm->flags))) +if (likely (!mm_flags_test (MMF_HAS_PINNED , vma->vm_mm)))return false; folio =vm_normal_folio (vma, addr, pte);if (!folio)kernel/fork.c +1
-1@@ -1887,7 +1887,7 @@ static void copy_oom_score_adj(u64 clone_flags, struct task_struct *tsk)/* We need to synchronize with __set_oom_adj */ mutex_lock (&oom_adj_mutex); -set_bit (MMF_MULTIPROCESS , &tsk->mm->flags); +mm_flags_set (MMF_MULTIPROCESS , tsk->mm);/* Update the values in case they were changed after copy_signal */ tsk->signal->oom_score_adj = current->signal->oom_score_adj; tsk->signal->oom_score_adj_min = current->signal->oom_score_adj_min;Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 09/10] mm: convert remaining users to mm_flags_*() accessors
In reply to Lorenzo StoakesQuoted 8 lines · Lorenzo Stoakes
As part of the effort to move to
mm->flagsbecoming a bitmap field, convert existing users to making use of the mm_flags_*() accessors which will, when the conversion is complete, be the only means of accessingmm_structflags.No functional change intended.
Signed-off-by Lorenzo Stoakes <[email protected]>---
Signature · 3 lines
Cheers David / dhildenb
PATCH 10/10 mm: replace mm->flags with bitmap entirely and set to 64 bits
In reply to Lorenzo StoakesNow we have updated all users of mm->flags to use the bitmap accessors, repalce it with the bitmap version entirely.
We are then able to move to having 64 bits of mm->flags on both 32-bit and 64-bit architectures.
We also update the VMA userland tests to ensure that everything remains functional there.
No functional changes intended, other than there now being 64 bits of available mm_struct flags.
--- include/linux/mm.h | 12 ++++++------ include/linux/mm_types.h | 14 +++++--------- include/linux/sched/coredump.h | 2 +- tools/testing/vma/vma_internal.h | 19 +++++++++++++++++-- 4 files changed, 29 insertions(+), 18 deletions(-)
include/linux/mm.h +6 -6
@@ -724,32 +724,32 @@ static inline void assert_fault_locked(struct vm_fault *vmf)static inline bool mm_flags_test (int flag,const struct mm_struct *mm) { -return test_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline bool mm_flags_test_and_set (int flag,struct mm_struct *mm) { -return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline bool mm_flags_test_and_clear (int flag,struct mm_struct *mm) { -return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_set (int flag,struct mm_struct *mm) { -set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +set_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_clear (int flag,struct mm_struct *mm) { -clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +clear_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_clear_all (struct mm_struct *mm) { -bitmap_zero (ACCESS_PRIVATE (&mm->_flags, __mm_flags),NUM_MM_FLAG_BITS ); +bitmap_zero (ACCESS_PRIVATE (&mm->flags, __mm_flags),NUM_MM_FLAG_BITS ); }extern const struct vm_operations_struct vma_dummy_vm_ops;
include/linux/mm_types.h +5 -9
@@ -932,7 +932,7 @@ struct mm_cid {* Opaque type representing current mm_struct flag state. Must be accessed via * mm_flags_xxx() helper functions. */ -#define NUM_MM_FLAG_BITS BITS_PER_LONG +#define NUM_MM_FLAG_BITS (64)typedef struct { __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); }mm_flags_t ;
@@ -1119,11 +1119,7 @@ struct mm_struct {/* Architecture-specific MM context */ mm_context_t context; -/* Temporary union while we convert users to mm_flags_t. */ -union { -unsigned long flags;/* Must use atomic bitops to access */ -mm_flags_t _flags;/* Must use mm_flags_* helpers to access */ - }; +mm_flags_t flags;/* Must use mm_flags_* hlpers to access */ #ifdef CONFIG_AIO spinlock_t ioctx_lock;
@@ -1236,7 +1232,7 @@ struct mm_struct {/* Read the first system word of mm flags, non-atomically. */ static inline unsigned long __mm_flags_get_word (struct mm_struct *mm) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);return bitmap_read (bitmap,0 ,BITS_PER_LONG ); }
@@ -1245,7 +1241,7 @@ static inline unsigned long __mm_flags_get_word(struct mm_struct *mm)static inline void __mm_flags_set_word (struct mm_struct *mm,unsigned long value) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);bitmap_copy (bitmap, &value,BITS_PER_LONG ); }
@@ -1253,7 +1249,7 @@ static inline void __mm_flags_set_word(struct mm_struct *mm,/* Obtain a read-only view of the bitmap. */ static inline const unsigned long *__mm_flags_get_bitmap (const struct mm_struct *mm) { -return (const unsigned long *)ACCESS_PRIVATE (&mm->_flags, __mm_flags); +return (const unsigned long *)ACCESS_PRIVATE (&mm->flags, __mm_flags); }#define MM_MT_FLAGS (MT_FLAGS_ALLOC_RANGE | MT_FLAGS_LOCK_EXTERN | \
include/linux/sched/coredump.h +1 -1
@@ -20,7 +20,7 @@ static inline unsigned long __mm_flags_get_dumpable(struct mm_struct *mm)static inline void __mm_flags_set_mask_dumpable (struct mm_struct *mm,int value) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);set_mask_bits (bitmap,MMF_DUMPABLE_MASK , value); }
tools/testing/vma/vma_internal.h +17 -2
@@ -249,6 +249,14 @@ struct mutex {};#define DEFINE_MUTEX (mutexname) \ struct mutex mutexname = {} +#define DECLARE_BITMAP (name, bits) \ + unsigned long name[BITS_TO_LONGS(bits)] + +#define NUM_MM_FLAG_BITS (64) +typedef struct { + __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); +}mm_flags_t ; +struct mm_struct {struct maple_tree mm_mt;int map_count;/* number of VMAs */
@@ -260,7 +268,7 @@ struct mm_struct {unsigned long def_flags; -unsigned long flags;/* Must use atomic bitops to access */ +mm_flags_t flags;/* Must use mm_flags_* helpers to access */ };struct vm_area_struct ;
@@ -1333,6 +1341,13 @@ static inline void userfaultfd_unmap_complete(struct mm_struct *mm, { } +# define ACCESS_PRIVATE (p, member) ((p)->member) + +static inline bool mm_flags_test (int flag,const struct mm_struct *mm) +{ +return test_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); +} +/* * Denies creating a writable executable mapping or gaining executable permissions. *
@@ -1363,7 +1378,7 @@ static inline void userfaultfd_unmap_complete(struct mm_struct *mm,static inline bool map_deny_write_exec (unsigned long old,unsigned long new) {/* If MDWE is disabled, we have nothing to deny. */ -if (!test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE , current->mm))return false;/* If the new VMA is not executable, we have nothing to deny. */
Signature · 1 line
2.50.1
Re: [PATCH 10/10] mm: replace mm->flags with bitmap entirely and set to 64 bits
Quoted 6 lines · Lorenzo Stoakes
Now we have updated all users of
mm->flagsto use the bitmap accessors, repalce it with the bitmap version entirely.We are then able to move to having 64 bits of
mm->flagson both 32-bit and 64-bit architectures.
Quoted 7 lines
We also update the VMA userland tests to ensure that everything remains functional there.
No functional changes intended, other than there now being 64 bits of available
mm_structflags.Signed-off-by Lorenzo Stoakes <[email protected]>
A nit below, but..
Quoted 122 lines
--- include/linux/mm.h | 12 ++++++------ include/linux/mm_types.h | 14 +++++--------- include/linux/sched/coredump.h | 2 +- tools/testing/vma/vma_internal.h | 19 +++++++++++++++++-- 4 files changed, 29 insertions(+), 18 deletions(-)include/linux/mm.h +6
-6@@ -724,32 +724,32 @@ static inline void assert_fault_locked(struct vm_fault *vmf)static inline bool mm_flags_test (int flag,const struct mm_struct *mm) { -return test_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline bool mm_flags_test_and_set (int flag,struct mm_struct *mm) { -return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline bool mm_flags_test_and_clear (int flag,struct mm_struct *mm) { -return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_set (int flag,struct mm_struct *mm) { -set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +set_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_clear (int flag,struct mm_struct *mm) { -clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +clear_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_clear_all (struct mm_struct *mm) { -bitmap_zero (ACCESS_PRIVATE (&mm->_flags, __mm_flags),NUM_MM_FLAG_BITS ); +bitmap_zero (ACCESS_PRIVATE (&mm->flags, __mm_flags),NUM_MM_FLAG_BITS ); }extern const struct vm_operations_struct vma_dummy_vm_ops;include/linux/mm_types.h +5
-9@@ -932,7 +932,7 @@ struct mm_cid {* Opaque type representing current mm_struct flag state. Must be accessed via * mm_flags_xxx() helper functions. */ -#define NUM_MM_FLAG_BITS BITS_PER_LONG +#define NUM_MM_FLAG_BITS (64)typedef struct { __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); }mm_flags_t ;@@ -1119,11 +1119,7 @@ struct mm_struct {/* Architecture-specific MM context */ mm_context_t context; -/* Temporary union while we convert users to mm_flags_t. */ -union { -unsigned long flags;/* Must use atomic bitops to access */ -mm_flags_t _flags;/* Must use mm_flags_* helpers to access */ - }; +mm_flags_t flags;/* Must use mm_flags_* hlpers to access */ #ifdef CONFIG_AIO spinlock_t ioctx_lock;@@ -1236,7 +1232,7 @@ struct mm_struct {/* Read the first system word of mm flags, non-atomically. */ static inline unsigned long __mm_flags_get_word (struct mm_struct *mm) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);return bitmap_read (bitmap,0 ,BITS_PER_LONG ); }@@ -1245,7 +1241,7 @@ static inline unsigned long __mm_flags_get_word(struct mm_struct *mm)static inline void __mm_flags_set_word (struct mm_struct *mm,unsigned long value) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);bitmap_copy (bitmap, &value,BITS_PER_LONG ); }@@ -1253,7 +1249,7 @@ static inline void __mm_flags_set_word(struct mm_struct *mm,/* Obtain a read-only view of the bitmap. */ static inline const unsigned long *__mm_flags_get_bitmap (const struct mm_struct *mm) { -return (const unsigned long *)ACCESS_PRIVATE (&mm->_flags, __mm_flags); +return (const unsigned long *)ACCESS_PRIVATE (&mm->flags, __mm_flags); }#define MM_MT_FLAGS (MT_FLAGS_ALLOC_RANGE | MT_FLAGS_LOCK_EXTERN | \include/linux/sched/coredump.h +1
-1@@ -20,7 +20,7 @@ static inline unsigned long __mm_flags_get_dumpable(struct mm_struct *mm)static inline void __mm_flags_set_mask_dumpable (struct mm_struct *mm,int value) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);set_mask_bits (bitmap,MMF_DUMPABLE_MASK , value); }tools/testing/vma/vma_internal.h +0
-0@@ -249,6 +249,14 @@ struct mutex {};#define DEFINE_MUTEX (mutexname) \
tools/testing/vma/vma_internal.h struct mutex {}; · line 259
Quoted 10 lines
tools/testing/vma/vma_internal.h +8
-0struct mutex mutexname = {} +#define DECLARE_BITMAP (name, bits) \ + unsigned long name[BITS_TO_LONGS(bits)] + +#define NUM_MM_FLAG_BITS (64) +typedef struct { + __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); +}mm_flags_t ; +
nit, This might be better in common test code? Probably just leave it here until it's needed elsewhere.
Quoted 38 lines
tools/testing/vma/vma_internal.h +9
-2struct mm_struct {struct maple_tree mm_mt;int map_count;/* number of VMAs */ @@ -260,7 +268,7 @@ struct mm_struct {unsigned long def_flags; -unsigned long flags;/* Must use atomic bitops to access */ +mm_flags_t flags;/* Must use mm_flags_* helpers to access */ };struct vm_area_struct ;@@ -1333,6 +1341,13 @@ static inline void userfaultfd_unmap_complete(struct mm_struct *mm, { } +# define ACCESS_PRIVATE (p, member) ((p)->member) + +static inline bool mm_flags_test (int flag,const struct mm_struct *mm) +{ +return test_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); +} +/* * Denies creating a writable executable mapping or gaining executable permissions. * @@ -1363,7 +1378,7 @@ static inline void userfaultfd_unmap_complete(struct mm_struct *mm,static inline bool map_deny_write_exec (unsigned long old,unsigned long new) {/* If MDWE is disabled, we have nothing to deny. */ -if (!test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE , current->mm))return false;/* If the new VMA is not executable, we have nothing to deny. */ Signature · 1 line
2.50.1
Re: [PATCH 10/10] mm: replace mm->flags with bitmap entirely and set to 64 bits
Quoted 10 lines · Liam R. Howlett
Quoted 9 lines · Lorenzo Stoakes
Now we have updated all users of
mm->flagsto use the bitmap accessors, repalce it with the bitmap version entirely.We are then able to move to having 64 bits of
mm->flagson both 32-bit and 64-bit architectures.We also update the VMA userland tests to ensure that everything remains functional there.
Quoted 8 lines
Quoted 4 lines
No functional changes intended, other than there now being 64 bits of available
mm_structflags.Signed-off-by Lorenzo Stoakes <[email protected]>A nit below, but..
Reviewed-by Liam R. Howlett <[email protected]>
Thanks!
[snip]
Quoted 8 lines
Quoted 8 lines
tools/testing/vma/vma_internal.h +0
-0@@ -249,6 +249,14 @@ struct mutex {};#define DEFINE_MUTEX (mutexname) \ struct mutex mutexname = {}
Quoted 11 lines
tools/testing/vma/vma_internal.h struct mutex {}; · line 259
Quoted 8 lines
tools/testing/vma/vma_internal.h +8
-0+#define DECLARE_BITMAP (name, bits) \ + unsigned long name[BITS_TO_LONGS(bits)] + +#define NUM_MM_FLAG_BITS (64) +typedef struct { + __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); +}mm_flags_t ; +nit, This might be better in common test code? Probably just leave it here until it's needed elsewhere.
Yeah, I think we need to figure this out in a more sensible way so we keep things vaguely synced for this stuff more generally. I'll add a todo for this!
I think fine for now, key point here is keeping the tests working.
Cheers, Lorenzo
Re: [PATCH 10/10] mm: replace mm->flags with bitmap entirely and set to 64 bits
In reply to Lorenzo StoakesQuoted 6 lines · Lorenzo Stoakes
Now we have updated all users of
mm->flagsto use the bitmap accessors, repalce it with the bitmap version entirely.We are then able to move to having 64 bits of
mm->flagson both 32-bit and 64-bit architectures.
Quoted 7 lines
We also update the VMA userland tests to ensure that everything remains functional there.
No functional changes intended, other than there now being 64 bits of available
mm_structflags.Signed-off-by Lorenzo Stoakes <[email protected]>
Quoted 170 lines
--- include/linux/mm.h | 12 ++++++------ include/linux/mm_types.h | 14 +++++--------- include/linux/sched/coredump.h | 2 +- tools/testing/vma/vma_internal.h | 19 +++++++++++++++++-- 4 files changed, 29 insertions(+), 18 deletions(-)include/linux/mm.h +6
-6@@ -724,32 +724,32 @@ static inline void assert_fault_locked(struct vm_fault *vmf)static inline bool mm_flags_test (int flag,const struct mm_struct *mm) { -return test_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline bool mm_flags_test_and_set (int flag,struct mm_struct *mm) { -return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_and_set_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline bool mm_flags_test_and_clear (int flag,struct mm_struct *mm) { -return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +return test_and_clear_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_set (int flag,struct mm_struct *mm) { -set_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +set_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_clear (int flag,struct mm_struct *mm) { -clear_bit (flag,ACCESS_PRIVATE (&mm->_flags, __mm_flags)); +clear_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); }static inline void mm_flags_clear_all (struct mm_struct *mm) { -bitmap_zero (ACCESS_PRIVATE (&mm->_flags, __mm_flags),NUM_MM_FLAG_BITS ); +bitmap_zero (ACCESS_PRIVATE (&mm->flags, __mm_flags),NUM_MM_FLAG_BITS ); }extern const struct vm_operations_struct vma_dummy_vm_ops;include/linux/mm_types.h +5
-9@@ -932,7 +932,7 @@ struct mm_cid {* Opaque type representing current mm_struct flag state. Must be accessed via * mm_flags_xxx() helper functions. */ -#define NUM_MM_FLAG_BITS BITS_PER_LONG +#define NUM_MM_FLAG_BITS (64)typedef struct { __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); }mm_flags_t ;@@ -1119,11 +1119,7 @@ struct mm_struct {/* Architecture-specific MM context */ mm_context_t context; -/* Temporary union while we convert users to mm_flags_t. */ -union { -unsigned long flags;/* Must use atomic bitops to access */ -mm_flags_t _flags;/* Must use mm_flags_* helpers to access */ - }; +mm_flags_t flags;/* Must use mm_flags_* hlpers to access */ #ifdef CONFIG_AIO spinlock_t ioctx_lock;@@ -1236,7 +1232,7 @@ struct mm_struct {/* Read the first system word of mm flags, non-atomically. */ static inline unsigned long __mm_flags_get_word (struct mm_struct *mm) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);return bitmap_read (bitmap,0 ,BITS_PER_LONG ); }@@ -1245,7 +1241,7 @@ static inline unsigned long __mm_flags_get_word(struct mm_struct *mm)static inline void __mm_flags_set_word (struct mm_struct *mm,unsigned long value) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);bitmap_copy (bitmap, &value,BITS_PER_LONG ); }@@ -1253,7 +1249,7 @@ static inline void __mm_flags_set_word(struct mm_struct *mm,/* Obtain a read-only view of the bitmap. */ static inline const unsigned long *__mm_flags_get_bitmap (const struct mm_struct *mm) { -return (const unsigned long *)ACCESS_PRIVATE (&mm->_flags, __mm_flags); +return (const unsigned long *)ACCESS_PRIVATE (&mm->flags, __mm_flags); }#define MM_MT_FLAGS (MT_FLAGS_ALLOC_RANGE | MT_FLAGS_LOCK_EXTERN | \include/linux/sched/coredump.h +1
-1@@ -20,7 +20,7 @@ static inline unsigned long __mm_flags_get_dumpable(struct mm_struct *mm)static inline void __mm_flags_set_mask_dumpable (struct mm_struct *mm,int value) { -unsigned long *bitmap =ACCESS_PRIVATE (&mm->_flags, __mm_flags); +unsigned long *bitmap =ACCESS_PRIVATE (&mm->flags, __mm_flags);set_mask_bits (bitmap,MMF_DUMPABLE_MASK , value); }tools/testing/vma/vma_internal.h +17
-2@@ -249,6 +249,14 @@ struct mutex {};#define DEFINE_MUTEX (mutexname) \ struct mutex mutexname = {} +#define DECLARE_BITMAP (name, bits) \ + unsigned long name[BITS_TO_LONGS(bits)] + +#define NUM_MM_FLAG_BITS (64) +typedef struct { + __private DECLARE_BITMAP(__mm_flags, NUM_MM_FLAG_BITS); +}mm_flags_t ; +struct mm_struct {struct maple_tree mm_mt;int map_count;/* number of VMAs */ @@ -260,7 +268,7 @@ struct mm_struct {unsigned long def_flags; -unsigned long flags;/* Must use atomic bitops to access */ +mm_flags_t flags;/* Must use mm_flags_* helpers to access */ };struct vm_area_struct ;@@ -1333,6 +1341,13 @@ static inline void userfaultfd_unmap_complete(struct mm_struct *mm, { } +# define ACCESS_PRIVATE (p, member) ((p)->member) + +static inline bool mm_flags_test (int flag,const struct mm_struct *mm) +{ +return test_bit (flag,ACCESS_PRIVATE (&mm->flags, __mm_flags)); +} +/* * Denies creating a writable executable mapping or gaining executable permissions. * @@ -1363,7 +1378,7 @@ static inline void userfaultfd_unmap_complete(struct mm_struct *mm,static inline bool map_deny_write_exec (unsigned long old,unsigned long new) {/* If MDWE is disabled, we have nothing to deny. */ -if (!test_bit (MMF_HAS_MDWE , ¤t->mm->flags)) +if (mm_flags_test (MMF_HAS_MDWE , current->mm))return false;/* If the new VMA is not executable, we have nothing to deny. */ Signature · 1 line
2.50.1
Signature · 2 lines
Sincerely yours, Mike.
Re: [PATCH 10/10] mm: replace mm->flags with bitmap entirely and set to 64 bits
In reply to Lorenzo StoakesQuoted 12 lines · Lorenzo Stoakes
Now we have updated all users of
mm->flagsto use the bitmap accessors, repalce it with the bitmap version entirely.We are then able to move to having 64 bits of
mm->flagson both 32-bit and 64-bit architectures.We also update the VMA userland tests to ensure that everything remains functional there.
No functional changes intended, other than there now being 64 bits of available
mm_structflags.
Quoted 7 lines
Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm.h | 12 ++++++------ include/linux/mm_types.h | 14 +++++--------- include/linux/sched/coredump.h | 2 +- tools/testing/vma/vma_internal.h | 19 +++++++++++++++++-- 4 files changed, 29 insertions(+), 18 deletions(-)
The vma test code duplication is still making me sad ... but I'll get over it I'm sure.
Signature · 3 lines
Cheers David / dhildenb
Re: [PATCH 10/10] mm: replace mm->flags with bitmap entirely and set to 64 bits
Quoted 21 lines · David Hildenbrand
Quoted 12 lines · Lorenzo Stoakes
Now we have updated all users of
mm->flagsto use the bitmap accessors, repalce it with the bitmap version entirely.We are then able to move to having 64 bits of
mm->flagson both 32-bit and 64-bit architectures.We also update the VMA userland tests to ensure that everything remains functional there.
No functional changes intended, other than there now being 64 bits of available
mm_structflags.Quoted 7 lines
Signed-off-by Lorenzo Stoakes <[email protected]>--- include/linux/mm.h | 12 ++++++------ include/linux/mm_types.h | 14 +++++--------- include/linux/sched/coredump.h | 2 +- tools/testing/vma/vma_internal.h | 19 +++++++++++++++++-- 4 files changed, 29 insertions(+), 18 deletions(-)
Quoted 2 lines
The vma test code duplication is still making me sad ... but I'll get over it I'm sure.
Yeah ;) I do want to work on seeing if I can do something more about this in future as I intend to do more with those tests but all time-dependent obviously!
Quoted 2 lines
Cheers!
Quoted 6 lines
--
CheersDavid / dhildenb
Quoted 7 lines · On Tue, 12 Aug 2025 16:44:09 +0100 Lorenzo Stoakes…
We are currently in the bizarre situation where we are constrained on the number of flags we can set in an
mm_structbased on whether this is a 32-bit or 64-bit kernel.This is because
mm->flagsis an unsigned long field, which is 32-bits on a 32-bit system and 64-bits on a 64-bit system.
Quoted 6 lines
In order to keep things functional across both architectures, we do not permit mm flag bits to be set above flag 31 (i.e. the 32nd bit).
This is a silly situation, especially given how profligate we are in storing metadata in
mm_struct, so let's convertmm->flagsinto a bitmap and allow ourselves as many bits as we like.
I like this conversion.
[...]
Quoted 3 lines
In order to execute this change, we introduce a new opaque type -
mm_flags_t- which wraps a bitmap.
I have no strong opinion here, but I think coding-style.rst[1] has one? To quote,
Please don't use things like ``vps_t``.
It's a **mistake** to use typedef for structures and pointers.
checkpatch.pl also complains similarly.
Again, I have no strong opinion, but I think adding a clarification about why we use typedef despite of the documented recommendation here might be nice?
[...]
Quoted 2 lines
For
mm->flagsinitialisation on fork, we adjust the logic to ensure all bits are cleared correctly, and then adjust the existing intialisation
Nit. s/intialisation/initialisation/ ?
[...]
[1] https://docs.kernel.org/process/coding-style.html#typedefs
Thanks,
SJ
Quoted 9 lines · SeongJae Park
Quoted 7 lines · On Tue, 12 Aug 2025 16:44:09 +0100 Lorenzo Stoakes…
We are currently in the bizarre situation where we are constrained on the number of flags we can set in an
mm_structbased on whether this is a 32-bit or 64-bit kernel.This is because
mm->flagsis an unsigned long field, which is 32-bits on a 32-bit system and 64-bits on a 64-bit system.
Quoted 8 lines
Quoted 6 lines
In order to keep things functional across both architectures, we do not permit mm flag bits to be set above flag 31 (i.e. the 32nd bit).
This is a silly situation, especially given how profligate we are in storing metadata in
mm_struct, so let's convertmm->flagsinto a bitmap and allow ourselves as many bits as we like.I like this conversion.
Thanks!
Quoted 11 lines
[...]
Quoted 3 lines
In order to execute this change, we introduce a new opaque type -
mm_flags_t- which wraps a bitmap.I have no strong opinion here, but I think coding-style.rst[1] has one? To quote,
Please don't use things like ``vps_t``.
It's a **mistake** to use typedef for structures and pointers.
You stopped reading the relevant section in [1] :) Keep going and you see:
Lots of people think that typedefs help readability. Not so. They are useful only for: totally opaque objects (where the typedef is actively used to hide what the object is). Example: pte_t etc. opaque objects that you can only access using the proper accessor functions.
So this is what this is.
The point is that it's opaque, that is you aren't supposed to know about or care about what's inside, you use the accessors.
This means we can extend the size of this thing as we like, and can enforce atomicity through the accessors.
We further highlight the opaqueness through the use of the __private.
Quoted 5 lines
checkpatch.pl also complains similarly.
Again, I have no strong opinion, but I think adding a clarification about why we use typedef despite of the documented recommendation here might be nice?
I already gave one, I clearly indicate it's opaque.
Quoted 6 lines
[...]
Quoted 2 lines
For
mm->flagsinitialisation on fork, we adjust the logic to ensure all bits are cleared correctly, and then adjust the existing intialisationNit. s/intialisation/initialisation/ ?
Ack thanks!
Quoted 8 lines
[...]
[1] https://docs.kernel.org/process/coding-style.html#typedefs
Thanks,
SJ
Quoted 2 lines · On Wed, 13 Aug 2025 05:18:31 +0100 Lorenzo Stoakes…
Quoted 1 line · SeongJae Park
On Tue, 12 Aug 2025 16:44:09 +0100 Lorenzo Stoakes <[email protected]> wrote:
[...]
Quoted 28 lines
Quoted 8 lines
Quoted 2 lines
In order to execute this change, we introduce a new opaque type -
mm_flags_t- which wraps a bitmap.I have no strong opinion here, but I think coding-style.rst[1] has one? To quote,
Please don't use things like ``vps_t``.
It's a **mistake** to use typedef for structures and pointers.You stopped reading the relevant section in [1] :) Keep going and you see:
Lots of people think that typedefs help readability. Not so. They are useful only for: totally opaque objects (where the typedef is actively used to hide what the object is). Example:
pte_tetc. opaque objects that you can only access using the proper accessor functions.So this is what this is.
The point is that it's opaque, that is you aren't supposed to know about or care about what's inside, you use the accessors.
This means we can extend the size of this thing as we like, and can enforce atomicity through the accessors.
We further highlight the opaqueness through the use of the
__private.Quoted 1 line
Quoted 6 lines
Quoted 4 lines
checkpatch.pl also complains similarly.
Again, I have no strong opinion, but I think adding a clarification about why we use typedef despite of the documented recommendation here might be nice?
I already gave one, I clearly indicate it's opaque.
You're completely right and I agree all the points. Thank you for kindly enlightening me :)
Thanks,
SJ
[...]