Skip to content

Commit 6bc0987

Browse files
Lorenzo Stoakes (Oracle)akpm00
Lorenzo Stoakes (Oracle)
authored and
akpm00
committed
mm/vma: add vma_flags_empty(), vma_flags_and(), vma_flags_diff_pair()
Patch series "mm/vma: convert vm_flags_t to vma_flags_t in vma code", v4. This series converts a lot of the existing use of the legacy vm_flags_t data type to the new vma_flags_t type which replaces it. In order to do so it adds a number of additional helpers: * vma_flags_empty() - Determines whether a vma_flags_t value has no bits set. * vma_flags_and() - Performs a bitwise AND between two vma_flags_t values. * vma_flags_diff_pair() - Determines which flags are not shared between a pair of VMA flags (typically non-constant values) * append_vma_flags() - Similar to mk_vma_flags(), but allows a vma_flags_t value to be specified (typically a constant value) which will be copied and appended to to create a new vma_flags_t value, with additional flags specified to append to it. * vma_flags_same() - Determines if a vma_flags_t value is exactly equal to a set of VMA flags. * vma_flags_same_mask() - Determines if a vma_flags_t value is eactly equal to another vma_flags_t value (typically constant). * vma_flags_same_pair() - Determines if a pair of vma_flags_t values are exactly equal to one another (typically both non-constant). * vma_flags_to_legacy() - Converts a vma_flags_t value to a vm_flags_t value, used to enable more iterative introduction of the use of vma_flags_t. * legacy_to_vma_flags() - Converts a vm_flags_t value to a vma_flags-t value, for the same purpose. * vma_flags_test_single_mask() - Tests whether a vma_flags_t value contain the single flag specified in an input vma_flags_t flag mask, or if that flag mask is empty, is defined to return false. Useful for config-predicated VMA flag mask defines. * vma_test() - Tests whether a VMA's flags contain a specific singular VMA flag. * vma_test_any() - Tests whether a VMA's flags contain any of a set of VMA flags. * vma_test_any_mask() - Tests whether a VMA's flags contain any of the flags specified in another, typically constant, vma_flags_t value. * vma_test_single_mask() - Tests whether a VMA's flags contain the single flag specified in an input vma_flags_t flag mask, or if that flag mask is empty, is defined to return false. Useful for config-predicated VMA flag mask defines. * vma_clear_flags() - Clears a specific set of VMA flags from a vma_flags_t value. * vma_clear_flags_mask() - Clears those flag set in a vma_flags_t value (typically constant) from a (typically not constant) vma_flags_t value. The series mostly focuses on the the VMA specific code, especially that contained in mm/vma.c and mm/vma.h. It updates both brk() and mmap() logic to utils vma_flags_t values as much as is practiaclly possible at this point, changing surrounding logic to be able to do so. It also updates the vma_modify_xxx() functions where they interact with VMA flags directly to use vm_flags_t values where possible. There is extensive testing added in the VMA userland tests to assert that all of these new VMA flag functions work correctly. This patch (of 25): Firstly, add the ability to determine if VMA flags are empty, that is no flags are set in a vma_flags_t value. Next, add the ability to obtain the equivalent of the bitwise and of two vma_flags_t values, via vma_flags_and_mask(). Next, add the ability to obtain the difference between two sets of VMA flags, that is the equivalent to the exclusive bitwise OR of the two sets of flags, via vma_flags_diff_pair(). vma_flags_xxx_mask() typically operates on a pointer to a vma_flags_t value, which is assumed to be an lvalue of some kind (such as a field in a struct or a stack variable) and an rvalue of some kind (typically a constant set of VMA flags obtained e.g. via mk_vma_flags() or equivalent). However vma_flags_diff_pair() is intended to operate on two lvalues, so use the _pair() suffix to make this clear. Finally, update VMA userland tests to add these helpers. We also port bitmap_xor() and __bitmap_xor() to the tools/ headers and source to allow the tests to work with vma_flags_diff_pair(). Link: https://lkml.kernel.org/r/cover.1774034900.git.ljs@kernel.org Link: https://lkml.kernel.org/r/53ab55b7da91425775e42c03177498ad6de88ef4.1774034900.git.ljs@kernel.org Signed-off-by: Lorenzo Stoakes (Oracle) <ljs@kernel.org> Acked-by: Vlastimil Babka (SUSE) <vbabka@kernel.org> Cc: Albert Ou <aou@eecs.berkeley.edu> Cc: Alexander Gordeev <agordeev@linux.ibm.com> Cc: Alexandre Ghiti <alex@ghiti.fr> Cc: Al Viro <viro@zeniv.linux.org.uk> Cc: Anton Ivanov <anton.ivanov@cambridgegreys.com> Cc: "Borislav Petkov (AMD)" <bp@alien8.de> Cc: Catalin Marinas <catalin.marinas@arm.com> Cc: Chengming Zhou <chengming.zhou@linux.dev> Cc: Christian Borntraeger <borntraeger@linux.ibm.com> Cc: Christian Brauner <brauner@kernel.org> Cc: David Hildenbrand <david@kernel.org> Cc: Dinh Nguyen <dinguyen@kernel.org> Cc: Heiko Carstens <hca@linux.ibm.com> Cc: "H. Peter Anvin" <hpa@zytor.com> Cc: Huacai Chen <chenhuacai@kernel.org> Cc: Ingo Molnar <mingo@redhat.com> Cc: Jan Kara <jack@suse.cz> Cc: Jann Horn <jannh@google.com> Cc: Johannes Berg <johannes@sipsolutions.net> Cc: Kees Cook <kees@kernel.org> Cc: Liam Howlett <liam.howlett@oracle.com> Cc: Madhavan Srinivasan <maddy@linux.ibm.com> Cc: Michael Ellerman <mpe@ellerman.id.au> Cc: Michal Hocko <mhocko@suse.com> Cc: Mike Rapoport <rppt@kernel.org> Cc: Nicholas Piggin <npiggin@gmail.com> Cc: Ondrej Mosnacek <omosnace@redhat.com> Cc: Palmer Dabbelt <palmer@dabbelt.com> Cc: Paul Moore <paul@paul-moore.com> Cc: Pedro Falcato <pfalcato@suse.de> Cc: Richard Weinberger <richard@nod.at> Cc: Russell King <linux@armlinux.org.uk> Cc: Stephen Smalley <stephen.smalley.work@gmail.com> Cc: Suren Baghdasaryan <surenb@google.com> Cc: Sven Schnelle <svens@linux.ibm.com> Cc: Thomas Bogendoerfer <tsbogend@alpha.franken.de> Cc: Vasily Gorbik <gor@linux.ibm.com> Cc: Vineet Gupta <vgupta@kernel.org> Cc: WANG Xuerui <kernel@xen0n.name> Cc: Will Deacon <will@kernel.org> Cc: xu xin <xu.xin16@zte.com.cn> Signed-off-by: Andrew Morton <akpm@linux-foundation.org>
1 parent 5ac9c7c commit 6bc0987

5 files changed

Lines changed: 117 additions & 10 deletions

File tree

‎include/linux/mm.h‎

Lines changed: 51 additions & 9 deletions
Original file line numberDiff line numberDiff line change
@@ -1048,6 +1048,19 @@ static __always_inline vma_flags_t __mk_vma_flags(size_t count,
10481048
return flags;
10491049
}
10501050

1051+
/*
1052+
* Helper macro which bitwise-or combines the specified input flags into a
1053+
* vma_flags_t bitmap value. E.g.:
1054+
*
1055+
* vma_flags_t flags = mk_vma_flags(VMA_IO_BIT, VMA_PFNMAP_BIT,
1056+
* VMA_DONTEXPAND_BIT, VMA_DONTDUMP_BIT);
1057+
*
1058+
* The compiler cleverly optimises away all of the work and this ends up being
1059+
* equivalent to aggregating the values manually.
1060+
*/
1061+
#define mk_vma_flags(...) __mk_vma_flags(COUNT_ARGS(__VA_ARGS__), \
1062+
(const vma_flag_t []){__VA_ARGS__})
1063+
10511064
/*
10521065
* Test whether a specific VMA flag is set, e.g.:
10531066
*
@@ -1062,17 +1075,30 @@ static __always_inline bool vma_flags_test(const vma_flags_t *flags,
10621075
}
10631076

10641077
/*
1065-
* Helper macro which bitwise-or combines the specified input flags into a
1066-
* vma_flags_t bitmap value. E.g.:
1067-
*
1068-
* vma_flags_t flags = mk_vma_flags(VMA_IO_BIT, VMA_PFNMAP_BIT,
1069-
* VMA_DONTEXPAND_BIT, VMA_DONTDUMP_BIT);
1078+
* Obtain a set of VMA flags which contain the overlapping flags contained
1079+
* within flags and to_and.
1080+
*/
1081+
static __always_inline vma_flags_t vma_flags_and_mask(const vma_flags_t *flags,
1082+
vma_flags_t to_and)
1083+
{
1084+
vma_flags_t dst;
1085+
unsigned long *bitmap_dst = dst.__vma_flags;
1086+
const unsigned long *bitmap = flags->__vma_flags;
1087+
const unsigned long *bitmap_to_and = to_and.__vma_flags;
1088+
1089+
bitmap_and(bitmap_dst, bitmap, bitmap_to_and, NUM_VMA_FLAG_BITS);
1090+
return dst;
1091+
}
1092+
1093+
/*
1094+
* Obtain a set of VMA flags which contains the specified overlapping flags,
1095+
* e.g.:
10701096
*
1071-
* The compiler cleverly optimises away all of the work and this ends up being
1072-
* equivalent to aggregating the values manually.
1097+
* vma_flags_t read_flags = vma_flags_and(&flags, VMA_READ_BIT,
1098+
* VMA_MAY_READ_BIT);
10731099
*/
1074-
#define mk_vma_flags(...) __mk_vma_flags(COUNT_ARGS(__VA_ARGS__), \
1075-
(const vma_flag_t []){__VA_ARGS__})
1100+
#define vma_flags_and(flags, ...) \
1101+
vma_flags_and_mask(flags, mk_vma_flags(__VA_ARGS__))
10761102

10771103
/* Test each of to_test flags in flags, non-atomically. */
10781104
static __always_inline bool vma_flags_test_any_mask(const vma_flags_t *flags,
@@ -1146,6 +1172,22 @@ static __always_inline void vma_flags_clear_mask(vma_flags_t *flags,
11461172
#define vma_flags_clear(flags, ...) \
11471173
vma_flags_clear_mask(flags, mk_vma_flags(__VA_ARGS__))
11481174

1175+
/*
1176+
* Obtain a VMA flags value containing those flags that are present in flags or
1177+
* flags_other but not in both.
1178+
*/
1179+
static __always_inline vma_flags_t vma_flags_diff_pair(const vma_flags_t *flags,
1180+
const vma_flags_t *flags_other)
1181+
{
1182+
vma_flags_t dst;
1183+
const unsigned long *bitmap_other = flags_other->__vma_flags;
1184+
const unsigned long *bitmap = flags->__vma_flags;
1185+
unsigned long *bitmap_dst = dst.__vma_flags;
1186+
1187+
bitmap_xor(bitmap_dst, bitmap, bitmap_other, NUM_VMA_FLAG_BITS);
1188+
return dst;
1189+
}
1190+
11491191
/*
11501192
* Helper to test that ALL specified flags are set in a VMA.
11511193
*

‎include/linux/mm_types.h‎

Lines changed: 8 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -870,6 +870,14 @@ typedef struct {
870870

871871
#define EMPTY_VMA_FLAGS ((vma_flags_t){ })
872872

873+
/* Are no flags set in the specified VMA flags? */
874+
static __always_inline bool vma_flags_empty(const vma_flags_t *flags)
875+
{
876+
const unsigned long *bitmap = flags->__vma_flags;
877+
878+
return bitmap_empty(bitmap, NUM_VMA_FLAG_BITS);
879+
}
880+
873881
/*
874882
* Describes a VMA that is about to be mmap()'ed. Drivers may choose to
875883
* manipulate mutable fields which will cause those fields to be updated in the

‎tools/include/linux/bitmap.h‎

Lines changed: 13 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -28,6 +28,8 @@ bool __bitmap_subset(const unsigned long *bitmap1,
2828
const unsigned long *bitmap2, unsigned int nbits);
2929
bool __bitmap_andnot(unsigned long *dst, const unsigned long *bitmap1,
3030
const unsigned long *bitmap2, unsigned int nbits);
31+
void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
32+
const unsigned long *bitmap2, unsigned int nbits);
3133

3234
#define BITMAP_FIRST_WORD_MASK(start) (~0UL << ((start) & (BITS_PER_LONG - 1)))
3335
#define BITMAP_LAST_WORD_MASK(nbits) (~0UL >> (-(nbits) & (BITS_PER_LONG - 1)))
@@ -209,4 +211,15 @@ static inline void bitmap_clear(unsigned long *map, unsigned int start,
209211
else
210212
__bitmap_clear(map, start, nbits);
211213
}
214+
215+
static __always_inline
216+
void bitmap_xor(unsigned long *dst, const unsigned long *src1,
217+
const unsigned long *src2, unsigned int nbits)
218+
{
219+
if (small_const_nbits(nbits))
220+
*dst = *src1 ^ *src2;
221+
else
222+
__bitmap_xor(dst, src1, src2, nbits);
223+
}
224+
212225
#endif /* _TOOLS_LINUX_BITMAP_H */

‎tools/lib/bitmap.c‎

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -169,3 +169,13 @@ bool __bitmap_subset(const unsigned long *bitmap1,
169169
return false;
170170
return true;
171171
}
172+
173+
void __bitmap_xor(unsigned long *dst, const unsigned long *bitmap1,
174+
const unsigned long *bitmap2, unsigned int bits)
175+
{
176+
unsigned int k;
177+
unsigned int nr = BITS_TO_LONGS(bits);
178+
179+
for (k = 0; k < nr; k++)
180+
dst[k] = bitmap1[k] ^ bitmap2[k];
181+
}

‎tools/testing/vma/include/dup.h‎

Lines changed: 35 additions & 1 deletion
Original file line numberDiff line numberDiff line change
@@ -422,6 +422,13 @@ struct vma_iterator {
422422
#define MAPCOUNT_ELF_CORE_MARGIN (5)
423423
#define DEFAULT_MAX_MAP_COUNT (USHRT_MAX - MAPCOUNT_ELF_CORE_MARGIN)
424424

425+
static __always_inline bool vma_flags_empty(const vma_flags_t *flags)
426+
{
427+
const unsigned long *bitmap = flags->__vma_flags;
428+
429+
return bitmap_empty(bitmap, NUM_VMA_FLAG_BITS);
430+
}
431+
425432
/* What action should be taken after an .mmap_prepare call is complete? */
426433
enum mmap_action_type {
427434
MMAP_NOTHING, /* Mapping is complete, no further action. */
@@ -855,6 +862,21 @@ static __always_inline bool vma_flags_test(const vma_flags_t *flags,
855862
return test_bit((__force int)bit, bitmap);
856863
}
857864

865+
static __always_inline vma_flags_t vma_flags_and_mask(const vma_flags_t *flags,
866+
vma_flags_t to_and)
867+
{
868+
vma_flags_t dst;
869+
unsigned long *bitmap_dst = dst.__vma_flags;
870+
const unsigned long *bitmap = flags->__vma_flags;
871+
const unsigned long *bitmap_to_and = to_and.__vma_flags;
872+
873+
bitmap_and(bitmap_dst, bitmap, bitmap_to_and, NUM_VMA_FLAG_BITS);
874+
return dst;
875+
}
876+
877+
#define vma_flags_and(flags, ...) \
878+
vma_flags_and_mask(flags, mk_vma_flags(__VA_ARGS__))
879+
858880
static __always_inline bool vma_flags_test_any_mask(const vma_flags_t *flags,
859881
vma_flags_t to_test)
860882
{
@@ -901,8 +923,20 @@ static __always_inline void vma_flags_clear_mask(vma_flags_t *flags, vma_flags_t
901923
#define vma_flags_clear(flags, ...) \
902924
vma_flags_clear_mask(flags, mk_vma_flags(__VA_ARGS__))
903925

926+
static __always_inline vma_flags_t vma_flags_diff_pair(const vma_flags_t *flags,
927+
const vma_flags_t *flags_other)
928+
{
929+
vma_flags_t dst;
930+
const unsigned long *bitmap_other = flags_other->__vma_flags;
931+
const unsigned long *bitmap = flags->__vma_flags;
932+
unsigned long *bitmap_dst = dst.__vma_flags;
933+
934+
bitmap_xor(bitmap_dst, bitmap, bitmap_other, NUM_VMA_FLAG_BITS);
935+
return dst;
936+
}
937+
904938
static inline bool vma_test_all_mask(const struct vm_area_struct *vma,
905-
vma_flags_t flags)
939+
vma_flags_t flags)
906940
{
907941
return vma_flags_test_all_mask(&vma->flags, flags);
908942
}

0 commit comments

Comments
 (0)