make VM_SOFTDIRTY a sticky VMA flag
Subsystems (5)
v2 cover make VM_SOFTDIRTY a sticky VMA flag
Currently we set VM_SOFTDIRTY when a new mapping is set up (whether by establishing a new VMA, or via merge) as implemented in __mmap_complete() and do_brk_flags().
However, when performing a merge of existing mappings such as when performing mprotect(), we may lose the VM_SOFTDIRTY flag.
Now we have the concept of making VMA flags 'sticky', that is that they both don't prevent merge and, importantly, are propagated to merged VMAs, this seems a sensible alternative to the existing special-casing of VM_SOFTDIRTY.
We additionally add a self-test that demonstrates that this logic behaves as expected.
v2:
* Propagated tags (thanks David, Pedro!)
* Corrected comments and added ASCII diagrams as per David.
* Expanded self-test to check for mprotect() case.
* Updated incomplete cover letter.
* Updated commit messages accordingly.
v1:
https://lore.kernel.org/all/[email protected]/
Lorenzo Stoakes (2):
mm: propagate VM_SOFTDIRTY on merge testing/selftests/mm: add soft-dirty merge self-test
include/linux/mm.h | 23 ++--- tools/testing/selftests/mm/soft-dirty.c | 127 +++++++++++++++++++++++- tools/testing/vma/vma_internal.h | 23 ++--- 3 files changed, 148 insertions(+), 25 deletions(-)
--
2.51.0
PATCH v2 1/2 mm: propagate VM_SOFTDIRTY on merge
Currently we set VM_SOFTDIRTY when a new mapping is set up (whether by establishing a new VMA, or via merge) as implemented in __mmap_complete() and do_brk_flags().
However, when performing a merge of existing mappings such as when performing mprotect(), we may lose the VM_SOFTDIRTY flag.
This is because currently we simply ignore VM_SOFTDIRTY for the purposes of merge, so one VMA may possess the flag and another not, and whichever happens to be the target VMA will be the one upon which the merge is performed which may or may not have VM_SOFTDIRTY set.
Now we have the concept of 'sticky' VMA flags, let's make VM_SOFTDIRTY one which solves this issue.
Additionally update VMA userland tests to propagate changes.
--- include/linux/mm.h | 23 +++++++++++------------ tools/testing/vma/vma_internal.h | 23 +++++++++++------------ 2 files changed, 22 insertions(+), 24 deletions(-)
include/linux/mm.h +11 -12
@@ -532,29 +532,28 @@ extern unsigned int kobjsize(const void *objp);* possesses it but the other does not, the merged VMA should nonetheless have * applied to it: * +* VM_SOFTDIRTY - if a VMA is marked soft-dirty, that is has not had its +* references cleared via /proc/$pid/clear_refs, any merged VMA +* should be considered soft-dirty also as it operates at a VMA +* granularity. +* * VM_MAYBE_GUARD - If a VMA may have guard regions in place it implies that * mapped page tables may contain metadata not described by the * VMA and thus any merged VMA may also contain this metadata, * and thus we must make this flag sticky. */ -#define VM_STICKY VM_MAYBE_GUARD +#define VM_STICKY (VM_SOFTDIRTY | VM_MAYBE_GUARD)/* * VMA flags we ignore for the purposes of merge, i.e. one VMA possessing one * of these flags and the other not does not preclude a merge. * -* VM_SOFTDIRTY - Should not prevent from VMA merging, if we match the flags but -* dirty bit -- the caller should mark merged VMA as dirty. If -* dirty bit won't be excluded from comparison, we increase -* pressure on the memory system forcing the kernel to generate -* new VMAs when old one could be extended instead. -* -* VM_STICKY - If one VMA has flags which most be 'sticky', that is ones -* which should propagate to all VMAs, but the other does not, -* the merge should still proceed with the merge logic applying -* sticky flags to the final VMA. +* VM_STICKY - If one VMA has flags which most be 'sticky', that is ones +* which should propagate to all VMAs, but the other does not, +* the merge should still proceed with the merge logic applying +* sticky flags to the final VMA. */ -#define VM_IGNORE_MERGE (VM_SOFTDIRTY | VM_STICKY) +#define VM_IGNORE_MERGE VM_STICKY/* * Flags which should result in page tables being copied on fork. These are
tools/testing/vma/vma_internal.h +11 -12
@@ -122,29 +122,28 @@ extern unsigned long dac_mmap_min_addr;* possesses it but the other does not, the merged VMA should nonetheless have * applied to it: * +* VM_SOFTDIRTY - if a VMA is marked soft-dirty, that is has not had its +* references cleared via /proc/$pid/clear_refs, any merged VMA +* should be considered soft-dirty also as it operates at a VMA +* granularity. +* * VM_MAYBE_GUARD - If a VMA may have guard regions in place it implies that * mapped page tables may contain metadata not described by the * VMA and thus any merged VMA may also contain this metadata, * and thus we must make this flag sticky. */ -#define VM_STICKY VM_MAYBE_GUARD +#define VM_STICKY (VM_SOFTDIRTY | VM_MAYBE_GUARD)/* * VMA flags we ignore for the purposes of merge, i.e. one VMA possessing one * of these flags and the other not does not preclude a merge. * -* VM_SOFTDIRTY - Should not prevent from VMA merging, if we match the flags but -* dirty bit -- the caller should mark merged VMA as dirty. If -* dirty bit won't be excluded from comparison, we increase -* pressure on the memory system forcing the kernel to generate -* new VMAs when old one could be extended instead. -* -* VM_STICKY - If one VMA has flags which most be 'sticky', that is ones -* which should propagate to all VMAs, but the other does not, -* the merge should still proceed with the merge logic applying -* sticky flags to the final VMA. +* VM_STICKY - If one VMA has flags which most be 'sticky', that is ones +* which should propagate to all VMAs, but the other does not, +* the merge should still proceed with the merge logic applying +* sticky flags to the final VMA. */ -#define VM_IGNORE_MERGE (VM_SOFTDIRTY | VM_STICKY) +#define VM_IGNORE_MERGE VM_STICKY/* * Flags which should result in page tables being copied on fork. These are
--
2.51.0
Re: [PATCH v2 1/2] mm: propagate VM_SOFTDIRTY on merge
Quoted 16 lines · Lorenzo Stoakes
Currently we set
VM_SOFTDIRTYwhen a new mapping is set up (whether by establishing a new VMA, or via merge) as implemented in__mmap_complete()anddo_brk_flags().However, when performing a merge of existing mappings such as when performing
mprotect(), we may lose theVM_SOFTDIRTYflag.This is because currently we simply ignore
VM_SOFTDIRTYfor the purposes of merge, so one VMA may possess the flag and another not, and whichever happens to be the target VMA will be the one upon which the merge is performed which may or may not haveVM_SOFTDIRTYset.Now we have the concept of 'sticky' VMA flags, let's make
VM_SOFTDIRTYone which solves this issue.
Quoted 6 lines
Additionally update VMA userland tests to propagate changes.
Signed-off-by Lorenzo Stoakes <[email protected]>Suggested-by Vlastimil Babka <[email protected]>Reviewed-by Pedro Falcato <[email protected]>
Thanks,
Andrei
Re: [PATCH v2 1/2] mm: propagate VM_SOFTDIRTY on merge
Quoted 18 lines · Andrei Vagin
Quoted 16 lines · Lorenzo Stoakes
Currently we set
VM_SOFTDIRTYwhen a new mapping is set up (whether by establishing a new VMA, or via merge) as implemented in__mmap_complete()anddo_brk_flags().However, when performing a merge of existing mappings such as when performing
mprotect(), we may lose theVM_SOFTDIRTYflag.This is because currently we simply ignore
VM_SOFTDIRTYfor the purposes of merge, so one VMA may possess the flag and another not, and whichever happens to be the target VMA will be the one upon which the merge is performed which may or may not haveVM_SOFTDIRTYset.Now we have the concept of 'sticky' VMA flags, let's make
VM_SOFTDIRTYone which solves this issue.
Quoted 8 lines
Quoted 6 lines
Additionally update VMA userland tests to propagate changes.
Signed-off-by Lorenzo Stoakes <[email protected]>Suggested-by Vlastimil Babka <[email protected]>Reviewed-by Pedro Falcato <[email protected]>Acked-by Andrey Vagin <[email protected]>
Thanks :)
Quoted 3 lines
Thanks,
Andrei
Andrew Morton
maintainerRe: [PATCH v2 1/2] mm: propagate VM_SOFTDIRTY on merge
In reply to Lorenzo StoakesQuoted 12 lines · On Mon, 17 Nov 2025 17:33:38 +0000 Lorenzo Stoakes…
Currently we set
VM_SOFTDIRTYwhen a new mapping is set up (whether by establishing a new VMA, or via merge) as implemented in__mmap_complete()anddo_brk_flags().However, when performing a merge of existing mappings such as when performing
mprotect(), we may lose theVM_SOFTDIRTYflag.This is because currently we simply ignore
VM_SOFTDIRTYfor the purposes of merge, so one VMA may possess the flag and another not, and whichever happens to be the target VMA will be the one upon which the merge is performed which may or may not haveVM_SOFTDIRTYset.
Quoted 5 lines
Now we have the concept of 'sticky' VMA flags, let's make
VM_SOFTDIRTYone which solves this issue.Additionally update VMA userland tests to propagate changes.
Oh. This patch messes with the comments which mm-implement-sticky-vma-flags-fix-2.patch just altered. Not sure what you intend here, so I left it as below - please advise.
(also, I fixed a typo: s/most/must/, both files)
include/linux/mm.h renamed from include/linux/mm.h~mm-propagate-vm_softdirty-on-merge +11 -11
@@ -532,28 +532,28 @@ extern unsigned int kobjsize(const void* possesses it but the other does not, the merged VMA should nonetheless have * applied to it: * +* VM_SOFTDIRTY - if a VMA is marked soft-dirty, that is has not had its +* references cleared via /proc/$pid/clear_refs, any merged VMA +* should be considered soft-dirty also as it operates at a VMA +* granularity. +* * VM_MAYBE_GUARD - If a VMA may have guard regions in place it implies that * mapped page tables may contain metadata not described by the * VMA and thus any merged VMA may also contain this metadata, * and thus we must make this flag sticky. */ -#define VM_STICKY VM_MAYBE_GUARD +#define VM_STICKY (VM_SOFTDIRTY | VM_MAYBE_GUARD)/* * VMA flags we ignore for the purposes of merge, i.e. one VMA possessing one * of these flags and the other not does not preclude a merge. * -* VM_SOFTDIRTY - Should not prevent from VMA merging, if we match the flags but -* dirty bit -- the caller should mark merged VMA as dirty. If -* dirty bit won't be excluded from comparison, we increase -* pressure on the memory system forcing the kernel to generate -* new VMAs when old one could be extended instead. -* -* VM_STICKY - When merging VMAs, VMA flags must match, unless they are -* 'sticky'. If any sticky flags exist in either VMA, we simply -* set all of them on the merged VMA. +* VM_STICKY - If one VMA has flags which must be 'sticky', that is ones +* which should propagate to all VMAs, but the other does not, +* the merge should still proceed with the merge logic applying +* sticky flags to the final VMA. */ -#define VM_IGNORE_MERGE (VM_SOFTDIRTY | VM_STICKY) +#define VM_IGNORE_MERGE VM_STICKY/* * Flags which should result in page tables being copied on fork. These are
tools/testing/vma/vma_internal.h renamed from tools/testing/vma/vma_internal.h~mm-propagate-vm_softdirty-on-merge +10 -15
@@ -122,28 +122,23 @@ extern unsigned long dac_mmap_min_addr;* possesses it but the other does not, the merged VMA should nonetheless have * applied to it: * -* VM_MAYBE_GUARD - If a VMA may have guard regions in place it implies that -* mapped page tables may contain metadata not described by the -* VMA and thus any merged VMA may also contain this metadata, -* and thus we must make this flag sticky. +* VM_SOFTDIRTY - if a VMA is marked soft-dirty, that is has not had its +* references cleared via /proc/$pid/clear_refs, any merged VMA +* should be considered soft-dirty also as it operates at a VMA +* granularity. */ -#define VM_STICKY VM_MAYBE_GUARD +#define VM_STICKY (VM_SOFTDIRTY | VM_MAYBE_GUARD)/* * VMA flags we ignore for the purposes of merge, i.e. one VMA possessing one * of these flags and the other not does not preclude a merge. * -* VM_SOFTDIRTY - Should not prevent from VMA merging, if we match the flags but -* dirty bit -- the caller should mark merged VMA as dirty. If -* dirty bit won't be excluded from comparison, we increase -* pressure on the memory system forcing the kernel to generate -* new VMAs when old one could be extended instead. -* -* VM_STICKY - When merging VMAs, VMA flags must match, unless they are -* 'sticky'. If any sticky flags exist in either VMA, we simply -* set all of them on the merged VMA. +* VM_STICKY - If one VMA has flags which most be 'sticky', that is ones +* which should propagate to all VMAs, but the other does not, +* the merge should still proceed with the merge logic applying +* sticky flags to the final VMA. */ -#define VM_IGNORE_MERGE (VM_SOFTDIRTY | VM_STICKY) +#define VM_IGNORE_MERGE VM_STICKY/* * Flags which should result in page tables being copied on fork. These are
_
Re: [PATCH v2 1/2] mm: propagate VM_SOFTDIRTY on merge
Quoted 17 lines · Andrew Morton
Quoted 15 lines · On Mon, 17 Nov 2025 17:33:38 +0000 Lorenzo Stoakes…
Currently we set
VM_SOFTDIRTYwhen a new mapping is set up (whether by establishing a new VMA, or via merge) as implemented in__mmap_complete()anddo_brk_flags().However, when performing a merge of existing mappings such as when performing
mprotect(), we may lose theVM_SOFTDIRTYflag.This is because currently we simply ignore
VM_SOFTDIRTYfor the purposes of merge, so one VMA may possess the flag and another not, and whichever happens to be the target VMA will be the one upon which the merge is performed which may or may not haveVM_SOFTDIRTYset.Now we have the concept of 'sticky' VMA flags, let's make
VM_SOFTDIRTYone which solves this issue.
Quoted 6 lines
Quoted 2 lines
Additionally update VMA userland tests to propagate changes.
Oh. This patch messes with the comments which mm-implement-sticky-vma-flags-fix-2.patch just altered. Not sure what you intend here, so I left it as below - please advise.
Ah sorry, missed this!
Yes a couple things to fixup below, sorry to be a pain!
Quoted 29 lines
(also, I fixed a typo: s/most/must/, both files)
include/linux/mm.h renamed from include/linux/mm.h~mm-propagate-vm_softdirty-on-merge +6
-4@@ -532,28 +532,28 @@ extern unsigned int kobjsize(const void* possesses it but the other does not, the merged VMA should nonetheless have * applied to it: * +* VM_SOFTDIRTY - if a VMA is marked soft-dirty, that is has not had its +* references cleared via /proc/$pid/clear_refs, any merged VMA +* should be considered soft-dirty also as it operates at a VMA +* granularity. +* * VM_MAYBE_GUARD - If a VMA may have guard regions in place it implies that * mapped page tables may contain metadata not described by the * VMA and thus any merged VMA may also contain this metadata, * and thus we must make this flag sticky. */ -#define VM_STICKY VM_MAYBE_GUARD +#define VM_STICKY (VM_SOFTDIRTY | VM_MAYBE_GUARD)/* * VMA flags we ignore for the purposes of merge, i.e. one VMA possessing one * of these flags and the other not does not preclude a merge. * -* VM_SOFTDIRTY - Should not prevent from VMA merging, if we match the flags but -* dirty bit -- the caller should mark merged VMA as dirty. If -* dirty bit won't be excluded from comparison, we increase
include/linux/mm.h extern unsigned int kobjsize(const void · line 554
Quoted 10 lines
include/linux/mm.h renamed from include/linux/mm.h~mm-propagate-vm_softdirty-on-merge +4
-6-* pressure on the memory system forcing the kernel to generate -* new VMAs when old one could be extended instead. -* -* VM_STICKY - When merging VMAs, VMA flags must match, unless they are -* 'sticky'. If any sticky flags exist in either VMA, we simply -* set all of them on the merged VMA. +* VM_STICKY - If one VMA has flags which must be 'sticky', that is ones +* which should propagate to all VMAs, but the other does not, +* the merge should still proceed with the merge logic applying +* sticky flags to the final VMA.
Could we fix this up actually? Sorry to be a pain but better to have the new wording:
+ * VM_STICKY - When merging VMAs, VMA flags must match, unless they are
+ * 'sticky'. If any sticky flags exist in either VMA, we simply
+ * set all of them on the merged VMA.
Quoted 31 lines
include/linux/mm.h renamed from include/linux/mm.h~mm-propagate-vm_softdirty-on-merge +1
-1*/ -#define VM_IGNORE_MERGE (VM_SOFTDIRTY | VM_STICKY) +#define VM_IGNORE_MERGE VM_STICKY/* * Flags which should result in page tables being copied on fork. These are tools/testing/vma/vma_internal.h renamed from tools/testing/vma/vma_internal.h~mm-propagate-vm_softdirty-on-merge +5
-8@@ -122,28 +122,23 @@ extern unsigned long dac_mmap_min_addr;* possesses it but the other does not, the merged VMA should nonetheless have * applied to it: * -* VM_MAYBE_GUARD - If a VMA may have guard regions in place it implies that -* mapped page tables may contain metadata not described by the -* VMA and thus any merged VMA may also contain this metadata, -* and thus we must make this flag sticky. +* VM_SOFTDIRTY - if a VMA is marked soft-dirty, that is has not had its +* references cleared via /proc/$pid/clear_refs, any merged VMA +* should be considered soft-dirty also as it operates at a VMA +* granularity. */ -#define VM_STICKY VM_MAYBE_GUARD +#define VM_STICKY (VM_SOFTDIRTY | VM_MAYBE_GUARD)/* * VMA flags we ignore for the purposes of merge, i.e. one VMA possessing one * of these flags and the other not does not preclude a merge. * -* VM_SOFTDIRTY - Should not prevent from VMA merging, if we match the flags but -* dirty bit -- the caller should mark merged VMA as dirty. If -* dirty bit won't be excluded from comparison, we increase
tools/testing/vma/vma_internal.h extern unsigned long dac_mmap_min_addr; · line 139
Quoted 10 lines
tools/testing/vma/vma_internal.h renamed from tools/testing/vma/vma_internal.h~mm-propagate-vm_softdirty-on-merge +4
-6-* pressure on the memory system forcing the kernel to generate -* new VMAs when old one could be extended instead. -* -* VM_STICKY - When merging VMAs, VMA flags must match, unless they are -* 'sticky'. If any sticky flags exist in either VMA, we simply -* set all of them on the merged VMA. +* VM_STICKY - If one VMA has flags which most be 'sticky', that is ones +* which should propagate to all VMAs, but the other does not, +* the merge should still proceed with the merge logic applying +* sticky flags to the final VMA.
Also could we do the same here?
+ * VM_STICKY - When merging VMAs, VMA flags must match, unless they are
+ * 'sticky'. If any sticky flags exist in either VMA, we simply
+ * set all of them on the merged VMA.
Quoted 8 lines
tools/testing/vma/vma_internal.h renamed from tools/testing/vma/vma_internal.h~mm-propagate-vm_softdirty-on-merge +1
-1*/ -#define VM_IGNORE_MERGE (VM_SOFTDIRTY | VM_STICKY) +#define VM_IGNORE_MERGE VM_STICKY/* * Flags which should result in page tables being copied on fork. These are _
Thanks, Lorenzo
Re: [PATCH v2 1/2] mm: propagate VM_SOFTDIRTY on merge
In reply to Lorenzo StoakesQuoted 15 lines · Lorenzo Stoakes
Currently we set
VM_SOFTDIRTYwhen a new mapping is set up (whether by establishing a new VMA, or via merge) as implemented in__mmap_complete()anddo_brk_flags().However, when performing a merge of existing mappings such as when performing
mprotect(), we may lose theVM_SOFTDIRTYflag.This is because currently we simply ignore
VM_SOFTDIRTYfor the purposes of merge, so one VMA may possess the flag and another not, and whichever happens to be the target VMA will be the one upon which the merge is performed which may or may not haveVM_SOFTDIRTYset.Now we have the concept of 'sticky' VMA flags, let's make
VM_SOFTDIRTYone which solves this issue.
Quoted 6 lines
Additionally update VMA userland tests to propagate changes.
Signed-off-by Lorenzo Stoakes <[email protected]>Suggested-by Vlastimil Babka <[email protected]>Reviewed-by Pedro Falcato <[email protected]>
Seems it's been like that since 34228d473efe ("mm: ignore VM_SOFTDIRTY on VMA merging") (unless it was in the meanwhile fixed and broken again) but as was discussed, not urgent for stable.
PATCH v2 2/2 testing/selftests/mm: add soft-dirty merge self-test
In reply to Lorenzo StoakesAssert that we correctly merge VMAs containing VM_SOFTDIRTY flags now that we correctly handle these as sticky.
In order to do so, we have to account for the fact the pagemap interface checks soft dirty PTEs and additionally that newly merged VMAs are marked VM_SOFTDIRTY.
We do this by using use unfaulted anon VMAs, establishing one and clearing references on that one, before establishing another and merging the two before checking that soft-dirty is propagated as expected.
We check that this functions correctly with mremap() and mprotect() as sample cases, because VMA merge of adjacent newly mapped VMAs will automatically be made soft-dirty due to existing logic which does so.
We are therefore exercising other means of merging VMAs.
--- tools/testing/selftests/mm/soft-dirty.c | 127 +++++++++++++++++++++++- 1 file changed, 126 insertions(+), 1 deletion(-)
tools/testing/selftests/mm/soft-dirty.c +126 -1
@@ -184,6 +184,130 @@ static void test_mprotect(int pagemap_fd, int pagesize, bool anon)close (test_fd); } +static void test_merge (int pagemap_fd,int pagesize) +{ +char *reserved, *map, *map2; + +/* +* Reserve space for tests: +* +* ---padding to --- +* | avoid adj. | +* v merge v +* |---|---|---|---|---| +* | | 1 | 2 | 3 | | +* |---|---|---|---|---| +*/ + reserved =mmap (NULL ,5 * pagesize,PROT_NONE , +MAP_ANON |MAP_PRIVATE ,-1 ,0 ); +if (reserved ==MAP_FAILED ) +ksft_exit_fail_msg ("mmap failed\n" ); +munmap (reserved,4 * pagesize); + +/* +* Establish initial VMA: +* +* S/D +* |---|---|---|---|---| +* | | 1 | | | | +* |---|---|---|---|---| +*/ + map =mmap (&reserved[pagesize], pagesize,PROT_READ |PROT_WRITE , +MAP_ANON |MAP_PRIVATE |MAP_FIXED ,-1 ,0 ); +if (map ==MAP_FAILED ) +ksft_exit_fail_msg ("mmap failed\n" ); + +/* This will clear VM_SOFTDIRTY too. */ +clear_softdirty (); + +/* +* Now place a new mapping which will be marked VM_SOFTDIRTY. Away from +* map: +* +* - S/D +* |---|---|---|---|---| +* | | 1 | | 2 | | +* |---|---|---|---|---| +*/ + map2 =mmap (&reserved[3 * pagesize], pagesize,PROT_READ |PROT_WRITE , +MAP_ANON |MAP_PRIVATE |MAP_FIXED ,-1 ,0 ); +if (map2 ==MAP_FAILED ) +ksft_exit_fail_msg ("mmap failed\n" ); + +/* +* Now remap it immediately adjacent to map, if the merge correctly +* propagates VM_SOFTDIRTY, we should then observe the VMA as a whole +* being marked soft-dirty: +* +* merge +* S/D +* |---|-------|---|---| +* | | 1 | | | +* |---|-------|---|---| +*/ + map2 =mremap (map2, pagesize, pagesize,MREMAP_FIXED |MREMAP_MAYMOVE , + &reserved[2 * pagesize]); +if (map2 ==MAP_FAILED ) +ksft_exit_fail_msg ("mremap failed\n" ); +ksft_test_result (pagemap_is_softdirty (pagemap_fd, map) ==1 , +"Test %s-anon soft-dirty after remap merge 1st pg\n" , + __func__); +ksft_test_result (pagemap_is_softdirty (pagemap_fd, map2) ==1 , +"Test %s-anon soft-dirty after remap merge 2nd pg\n" , + __func__); + +munmap (map,2 * pagesize); + +/* +* Now establish another VMA: +* +* S/D +* |---|---|---|---|---| +* | | 1 | | | | +* |---|---|---|---|---| +*/ + map =mmap (&reserved[pagesize], pagesize,PROT_READ |PROT_WRITE , +MAP_ANON |MAP_PRIVATE |MAP_FIXED ,-1 ,0 ); +if (map ==MAP_FAILED ) +ksft_exit_fail_msg ("mmap failed\n" ); + +/* Clear VM_SOFTDIRTY... */ +clear_softdirty (); +/* ...and establish incompatible adjacent VMA: +* +* - S/D +* |---|---|---|---|---| +* | | 1 | 2 | | | +* |---|---|---|---|---| +*/ + map2 =mmap (&reserved[2 * pagesize], pagesize, +PROT_READ |PROT_WRITE |PROT_EXEC , +MAP_ANON |MAP_PRIVATE |MAP_FIXED ,-1 ,0 ); +if (map2 ==MAP_FAILED ) +ksft_exit_fail_msg ("mmap failed\n" ); + +/* +* Now mprotect() VMA 1 so it's compatible with 2 and therefore merges: +* +* merge +* S/D +* |---|-------|---|---| +* | | 1 | | | +* |---|-------|---|---| +*/ +if (mprotect (map, pagesize,PROT_READ |PROT_WRITE |PROT_EXEC )) +ksft_exit_fail_msg ("mprotect failed\n" ); + +ksft_test_result (pagemap_is_softdirty (pagemap_fd, map) ==1 , +"Test %s-anon soft-dirty after mprotect merge 1st pg\n" , + __func__); +ksft_test_result (pagemap_is_softdirty (pagemap_fd, map2) ==1 , +"Test %s-anon soft-dirty after mprotect merge 2nd pg\n" , + __func__); + +munmap (map,2 * pagesize); +} +static void test_mprotect_anon (int pagemap_fd,int pagesize) {test_mprotect (pagemap_fd, pagesize, true);
@@ -204,7 +328,7 @@ int main(int argc, char **argv)if (!softdirty_supported ())ksft_exit_skip ("soft-dirty is not support\n" ); -ksft_set_plan (15 ); +ksft_set_plan (19 ); pagemap_fd =open (PAGEMAP_FILE_PATH ,O_RDONLY );if (pagemap_fd <0 )ksft_exit_fail_msg ("Failed to open %s\n" ,PAGEMAP_FILE_PATH );
@@ -216,6 +340,7 @@ int main(int argc, char **argv)test_hugepage (pagemap_fd, pagesize);test_mprotect_anon (pagemap_fd, pagesize);test_mprotect_file (pagemap_fd, pagesize); +test_merge (pagemap_fd, pagesize);close (pagemap_fd);
--
2.51.0