selftests/mm: assorted fixes for hmm-tests
v2 cover selftests/mm: assorted fixes for hmm-tests
Hi all,
This series fixes a few issues in hmm-tests that show up when page-size and huge-page configuration differ from the hardcoded assumptions the tests were written for (PMD/THP sizing, default hugepage size, and related cases).
It also includes a fix to exclusive_cow: the test ignored the return value of fork(), so both parent and child ran the same teardown path.
v1: https://lore.kernel.org/all/[email protected]/
Changes in v2:
- Patches 1 and 3 are unchanged.
- Patch 2: fall back to TWOMEG when read_pmd_pagesize() returns zero, use a fixed-size array to avoid non-constant initialisers, and skip benchmark sizes that exceed INT_MAX instead of capping the THP count at runtime.
Please let us know if you have any comments.
Thanks,
Aboorva
Aboorva Devarajan (1):
selftests/mm: fix exclusive_cow test fork() handling
Sayali Patil (2):
selftests/mm: allow PUD-level entries in compound testcase of hmm
tests
selftests/mm: remove hardcoded THP sizing assumptions in hmm tests
tools/testing/selftests/mm/hmm-tests.c | 104 ++++++++++++++++++------- 1 file changed, 76 insertions(+), 28 deletions(-)
Signature · 1 line
2.54.0
PATCH v2 1/3 selftests/mm: allow PUD-level entries in compound testcase of hmm tests
From: Sayali Patil <[email protected]>
The HMM compound testcase currently assume only PMD-level mappings and fail on systems when default_hugepagesz=1G is set. Extend the checks to accept PUD-level protections as well, avoiding false failures.
--- tools/testing/selftests/mm/hmm-tests.c | 12 ++++++------ 1 file changed, 6 insertions(+), 6 deletions(-)
tools/testing/selftests/mm/hmm-tests.c +6 -6
@@ -1602,8 +1602,8 @@ TEST_F(hmm2, snapshot) }/* -* Test the hmm_range_fault() HMM_PFN_PMD flag for large pages that -* should be mapped by a large page table entry. +* Test the hmm_range_fault() handling of large pages (PMD or PUD) +* that should be mapped by a large page table entry. */ TEST_F(hmm, compound) {
@@ -1651,8 +1651,8 @@ TEST_F(hmm, compound)/* Check what the device saw. */ m = buffer->mirror;for (i =0 ; i < npages; ++i) -ASSERT_EQ (m[i],HMM_DMIRROR_PROT_WRITE | -HMM_DMIRROR_PROT_PMD ); +ASSERT_TRUE ((m[i] == (HMM_DMIRROR_PROT_WRITE |HMM_DMIRROR_PROT_PMD )) || + (m[i] == (HMM_DMIRROR_PROT_WRITE |HMM_DMIRROR_PROT_PUD )));/* Make the region read-only. */ ret =mprotect (buffer->ptr, size,PROT_READ );
@@ -1666,8 +1666,8 @@ TEST_F(hmm, compound)/* Check what the device saw. */ m = buffer->mirror;for (i =0 ; i < npages; ++i) -ASSERT_EQ (m[i],HMM_DMIRROR_PROT_READ | -HMM_DMIRROR_PROT_PMD ); +ASSERT_TRUE ((m[i] == (HMM_DMIRROR_PROT_READ |HMM_DMIRROR_PROT_PMD )) || + (m[i] == (HMM_DMIRROR_PROT_READ |HMM_DMIRROR_PROT_PUD )));munmap (buffer->ptr, buffer->size); buffer->ptr =NULL ;
Signature · 1 line
2.54.0
PATCH v2 2/3 selftests/mm: remove hardcoded THP sizing assumptions in hmm tests
In reply to Aboorva DevarajanFrom: Sayali Patil <[email protected]>
migrate_partial_unmap_fault() and migrate_remap_fault() use hardcoded offsets based on a 2MB PMD size. Similarly, benchmark_thp_migration() assumes a fixed 2MB THP size when generating test buffer sizes.
Derive offsets and test sizes from the runtime PMD page size returned by read_pmd_pagesize(). If unavailable, fall back to TWOMEG. This allows the tests to adapt correctly on systems where PMD-sized THP differs from 2MB. Also replace the fixed 1MB unmap size with a PMD-relative value derived from the runtime PMD size.
On systems with larger PMD sizes, computed test buffer sizes can exceed INT_MAX. Skip such test cases to avoid overflow.
--- tools/testing/selftests/mm/hmm-tests.c | 62 ++++++++++++++++++-------- 1 file changed, 43 insertions(+), 19 deletions(-)
tools/testing/selftests/mm/hmm-tests.c +43 -19
@@ -22,6 +22,7 @@#include <strings.h> #include <time.h> #include <pthread.h> +#include <limits.h> #include <sys/types.h> #include <sys/stat.h> #include <sys/mman.h>
@@ -2334,12 +2335,21 @@ TEST_F(hmm, migrate_partial_unmap_fault)struct hmm_buffer *buffer;unsigned long npages;unsigned long size =read_pmd_pagesize (); +unsigned long unmap_size; +unsigned long offsets[3 ];unsigned long i;void *old_ptr;void *map;int *ptr;int ret, j, use_thp; -int offsets[] = {0 ,512 *ONEKB ,ONEMEG }; + +if (!size) + size =TWOMEG ; + + unmap_size = size /2 ; + offsets[0 ] =0 ; + offsets[1 ] = size /4 ; + offsets[2 ] = size /2 ;for (use_thp =0 ; use_thp <2 ; ++use_thp) {for (j =0 ; j <ARRAY_SIZE (offsets); ++j) {
@@ -2381,12 +2391,12 @@ TEST_F(hmm, migrate_partial_unmap_fault)for (i =0 , ptr = buffer->mirror; i < size /sizeof (*ptr); ++i)ASSERT_EQ (ptr[i], i); -munmap (buffer->ptr + offsets[j],ONEMEG ); +munmap (buffer->ptr + offsets[j], unmap_size);/* Fault pages back to system memory and check them. */ for (i =0 , ptr = buffer->ptr; i < size /sizeof (*ptr); ++i)if (i *sizeof (int ) < offsets[j] || - i *sizeof (int ) >= offsets[j] +ONEMEG ) + i *sizeof (int ) >= offsets[j] + unmap_size)ASSERT_EQ (ptr[i], i); buffer->ptr = old_ptr;
@@ -2400,12 +2410,19 @@ TEST_F(hmm, migrate_remap_fault)struct hmm_buffer *buffer;unsigned long npages;unsigned long size =read_pmd_pagesize (); +unsigned long offsets[3 ];unsigned long i;void *old_ptr, *new_ptr =NULL ;void *map;int *ptr;int ret, j, use_thp, dont_unmap, before; -int offsets[] = {0 ,512 *ONEKB ,ONEMEG }; + +if (!size) + size =TWOMEG ; + + offsets[0 ] =0 ; + offsets[1 ] = size /4 ; + offsets[2 ] = size /2 ;for (before =0 ; before <2 ; ++before) {for (dont_unmap =0 ; dont_unmap <2 ; ++dont_unmap) {
@@ -2808,38 +2825,45 @@ static inline int run_migration_benchmark(int fd, int use_thp, size_t buffer_siz TEST_F_TIMEOUT(hmm, benchmark_thp_migration, 120) {struct benchmark_results thp_results, regular_results; -size_t thp_size =2 *1024 *1024 ;/* 2MB - typical THP size */ +size_t thp_size =read_pmd_pagesize ();int iterations =5 ; +if (!thp_size) + thp_size =TWOMEG ; +printf ("\nHMM THP Migration Benchmark\n" );printf ("---------------------------\n" );printf ("System page size: %ld bytes\n" ,sysconf (_SC_PAGESIZE));/* Test different buffer sizes */ size_t test_sizes[] = { - thp_size /4 ,/* 512KB - smaller than THP */ - thp_size /2 ,/* 1MB - half THP */ - thp_size,/* 2MB - single THP */ - thp_size *2 ,/* 4MB - two THPs */ - thp_size *4 ,/* 8MB - four THPs */ - thp_size *8 ,/* 16MB - eight THPs */ - thp_size *128 ,/* 256MB - one twenty eight THPs */ + thp_size /4 ,/* quarter THP */ + thp_size /2 ,/* half THP */ + thp_size,/* single THP */ + thp_size *2 ,/* two THPs */ + thp_size *4 ,/* four THPs */ + thp_size *8 ,/* eight THPs */ + thp_size *128 ,/* one twenty eight THPs */ };static const char *const test_names[] = { -"Small Buffer (512KB)" , -"Half THP Size (1MB)" , -"Single THP Size (2MB)" , -"Two THP Size (4MB)" , -"Four THP Size (8MB)" , -"Eight THP Size (16MB)" , -"One twenty eight THP Size (256MB)" +"Small Buffer" , +"Half THP Size" , +"Single THP Size" , +"Two THP Size" , +"Four THP Size" , +"Eight THP Size" , +"One twenty eight THP Size" };int num_tests =ARRAY_SIZE (test_sizes);/* Run all tests */ for (int i =0 ; i < num_tests; i++) { +/* Skip test sizes exceeding INT_MAX to avoid overflow */ +if (test_sizes[i] >INT_MAX ) +break ; +/* Test with THP */ ASSERT_EQ (run_migration_benchmark (self->fd,1 , test_sizes[i], iterations, &thp_results),0 );
Signature · 1 line
2.54.0
PATCH v2 3/3 selftests/mm: fix exclusive_cow test fork() handling
In reply to Aboorva DevarajanThe test ignores the return value of fork(), so both the parent and the (newly created) child run the COW verification loops and then call hmm_buffer_free() before returning into the kselftest harness, which _exit()s each side. This duplicated teardown sequence has been observed to manifest as a SIGSEGV in the test child, e.g.:
hmm-tests[360141]: segfault (11) at 0 nip 10006964 lr 1000ac3c code 1 in hmm-tests[6964,10000000+30000]
Fix this by adopting the same fork()-then-wait pattern already used by the nearby anon_write_child / anon_write_child_shared tests in this file: the child performs the COW verification and then _exit(0)s so it does not run the test teardown, while the parent independently verifies COW, waits for the child, and only then frees the buffer.
--- tools/testing/selftests/mm/hmm-tests.c | 30 +++++++++++++++++++++++--- 1 file changed, 27 insertions(+), 3 deletions(-)
tools/testing/selftests/mm/hmm-tests.c +27 -3
@@ -1868,6 +1868,8 @@ TEST_F(hmm, exclusive_cow)unsigned long i;int *ptr;int ret; +pid_t pid; +int status; npages =ALIGN (HMM_BUFFER_SIZE , self->page_size) >> self->page_shift;ASSERT_NE (npages,0 );
@@ -1896,14 +1898,36 @@ TEST_F(hmm, exclusive_cow)ASSERT_EQ (ret,0 );ASSERT_EQ (buffer->cpages, npages); -fork (); + pid =fork (); +if (pid ==-1 ) +ASSERT_EQ (pid,0 ); -/* Fault pages back to system memory and check them. */ +if (pid ==0 ) { +/* +* Child: fault pages back and verify COW, then _exit(). +* On ASSERT failure the harness calls abort(); the parent +* reports it via the WIFEXITED/WEXITSTATUS checks below. +*/ +for (i =0 , ptr = buffer->ptr; i < size /sizeof (*ptr); ++i) +ASSERT_EQ (ptr[i]++, i); + +for (i =0 , ptr = buffer->ptr; i < size /sizeof (*ptr); ++i) +ASSERT_EQ (ptr[i], i +1 ); + +_exit (0 ); + } + +/* Parent: also increment to verify COW works for both processes. */ for (i =0 , ptr = buffer->ptr; i < size /sizeof (*ptr); ++i)ASSERT_EQ (ptr[i]++, i);for (i =0 , ptr = buffer->ptr; i < size /sizeof (*ptr); ++i) -ASSERT_EQ (ptr[i], i+1 ); +ASSERT_EQ (ptr[i], i +1 ); + +/* Parent: wait for child and then free the buffer. */ +ASSERT_EQ (waitpid (pid, &status,0 ), pid); +ASSERT_TRUE (WIFEXITED (status)); +ASSERT_EQ (WEXITSTATUS (status),0 );hmm_buffer_free (buffer); }
Signature · 1 line
2.54.0
Andrew Morton
maintainerQuoted 7 lines · On Tue, 19 May 2026 09:36:21 +0530 Aboorva Devarajan <[email protected]>…
This series fixes a few issues in hmm-tests that show up when page-size and huge-page configuration differ from the hardcoded assumptions the tests were written for (PMD/THP sizing, default hugepage size, and related cases).
It also includes a fix to
exclusive_cow: the test ignored the return value offork(), so both parent and child ran the same teardown path.
Thanks.
A lot of people weren't cc'ed. get_maintainer tells me
Jason and Leon, particularly.
Also, get_maintainer isn't super precise. A scan of the `git blame' output indicates that Ralph, Balbir, Alex, Matthew and Alistair might appreciate a cc.
AI review asked one question:
https://sashiko.dev/#/patchset/[email protected]
Quoted 26 lines · Andrew Morton
Quoted 7 lines · On Tue, 19 May 2026 09:36:21 +0530 Aboorva Devarajan <[email protected]>…
This series fixes a few issues in hmm-tests that show up when page-size and huge-page configuration differ from the hardcoded assumptions the tests were written for (PMD/THP sizing, default hugepage size, and related cases).
It also includes a fix to
exclusive_cow: the test ignored the return value offork(), so both parent and child ran the same teardown path.Thanks.
A lot of people weren't cc'ed.
get_maintainertells meCc Jason Gunthorpe <[email protected]>Cc Leon Romanovsky <[email protected]>Cc Andrew Morton <[email protected]>Cc David Hildenbrand <[email protected]>Cc Lorenzo Stoakes <[email protected]>Cc "Liam R. Howlett" <[email protected]>Cc Vlastimil Babka <[email protected]>Cc Mike Rapoport <[email protected]>Cc Suren Baghdasaryan <[email protected]>Cc Michal Hocko <[email protected]>Cc Shuah Khan <[email protected]>
Quoted 9 lines
Jason and Leon, particularly.
Also,
get_maintainerisn't super precise. A scan of the `git blame' output indicates that Ralph, Balbir, Alex, Matthew and Alistair might appreciate a cc.AI review asked one question:
https://sashiko.dev/#/patchset/[email protected]
Hi Andrew,
Thanks for the feedback,
We have addressed the AI review comments and sent a v3 expanding the CC list.
https://lore.kernel.org/all/[email protected]/
Thanks,
Aboorva