Re: [PATCH v3] selftests/mm: skip hugetlb_dio tests when DIO alignment is incompatible

["David Hildenbrand (Arm)" <david@kernel.org>]

On 3/30/26 07:39, Li Wang wrote:
> hugetlb_dio test uses sub-page offsets (pagesize / 2) to verify that
> hugepages used as DIO user buffers are correctly unpinned at completion.
> 
> However, on filesystems with a logical block size larger than half the
> page size (e.g., 4K-sector block devices), these unaligned DIO writes
> are rejected with -EINVAL, causing the test to fail unexpectedly.
> 
> Add get_dio_alignment() to query the filesystem's required DIO alignment
> via statx(STATX_DIOALIGN) and pass it to run_dio_using_hugetlb(). Skip
> individual test cases whose writesize/buf-offset is not a multiple of the
> alignment, so that aligned cases are still tested.
> 
> === Reproduce Steps ===
> 
>   # dd if=/dev/zero of=/tmp/test.img bs=1M count=512
>   # losetup --sector-size 4096 /dev/loop0 /tmp/test.img
>   # mkfs.xfs /dev/loop0
>   # mkdir -p /mnt/dio_test
>   # mount /dev/loop0 /mnt/dio_test
> 
>   // Modify test to open /mnt/dio_test and rebuild it:
>   -       fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
>   +       fd = open("/mnt/dio_test", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
> 
>   # getconf PAGESIZE
>   4096
> 
>   # echo 100 >/proc/sys/vm/nr_hugepages
> 
>   # ./hugetlb_dio
>   TAP version 13
>   1..4
>   # No. Free pages before allocation : 100
>   # No. Free pages after munmap : 100
>   ok 1 free huge pages from 0-12288
>   Bail out! Error writing to file
>   : Invalid argument (22)
>   # Planned tests != run tests (4 != 1)
>   # Totals: pass:1 fail:0 xfail:0 xpass:0 skip:0 error:0
> 
> Signed-off-by: Li Wang <liwang@redhat.com>
> ---
> 
> Notes:
>     v3:
>     	- Adopt statx raw syscall to build on older glibc.
>     	- add buf offset alignment check as well
>     v2:
>     	- Pass dio_align as a parameter to run_dio_using_hugetlb()
>     	  instead of generally page_size/2 alignment check.
>     	- Add O_DIRECT flag back to the first open().
>     	- Add stx_dio_offset_align zero check.
> 
>  tools/testing/selftests/mm/hugetlb_dio.c | 62 +++++++++++++++++-------
>  1 file changed, 45 insertions(+), 17 deletions(-)
> 
> diff --git a/tools/testing/selftests/mm/hugetlb_dio.c b/tools/testing/selftests/mm/hugetlb_dio.c
> index 9ac62eb4c97d..b125092fc6c1 100644
> --- a/tools/testing/selftests/mm/hugetlb_dio.c
> +++ b/tools/testing/selftests/mm/hugetlb_dio.c
> @@ -17,10 +17,41 @@
>  #include <unistd.h>
>  #include <string.h>
>  #include <sys/mman.h>
> +#include <sys/syscall.h>
>  #include "vm_util.h"
>  #include "kselftest.h"
>  
> -void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
> +#define HP_DIO_TMPDIR "/tmp"
> +
> +#ifndef STATX_DIOALIGN
> +#define STATX_DIOALIGN		0x00002000U
> +#endif
> +
> +unsigned int get_dio_alignment(void)
> +{
> +	int fd, ret;
> +	struct statx stx;
> +	unsigned int dio_align = 1;
> +
> +	fd = open(HP_DIO_TMPDIR, O_TMPFILE | O_RDWR | O_DIRECT, 0664);
> +	if (fd < 0)
> +		ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
> +
> +	ret = syscall(__NR_statx, fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &stx);
> +	if (ret < 0) {
> +		ksft_perror("statx() failed");
> +	} else if ((stx.stx_mask & STATX_DIOALIGN) &&
> +			stx.stx_dio_offset_align) {
> +		dio_align = stx.stx_dio_offset_align;
> +	}
> +
> +	close(fd);
> +
> +	return dio_align;
> +}
> +
> +void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off,
> +			unsigned int dio_align)
>  {
>  	int fd;
>  	char *buffer =  NULL;
> @@ -33,6 +64,12 @@ void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
>  	const int mmap_prot  = PROT_READ | PROT_WRITE;
>  
>  	writesize = end_off - start_off;
> +	if (start_off % dio_align != 0 || writesize % dio_align != 0) {
> +		ksft_test_result_skip("DIO alignment (%u) incompatible with "
> +				"buf offset %u and writesize %zu\n",
> +				dio_align, start_off, writesize);
> +		return;
> +	}
>  
>  	/* Get the default huge page size */
>  	h_pagesize = default_huge_page_size();
> @@ -40,7 +77,7 @@ void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
>  		ksft_exit_fail_msg("Unable to determine huge page size\n");
>  
>  	/* Open the file to DIO */

This comment is misleading as we are not opening "the" file, but we create a new one.
See below, maybe we should clean that up.

> -	fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
> +	fd = open(HP_DIO_TMPDIR, O_TMPFILE | O_RDWR | O_DIRECT, 0664);
>  	if (fd < 0)
>  		ksft_exit_fail_perror("Error opening file\n");
>  
> @@ -89,37 +126,28 @@ void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
>  
>  int main(void)
>  {
> -	size_t pagesize = 0;
> -	int fd;
> +	size_t pagesize = psize();
> +	unsigned int dio_align = get_dio_alignment();

Both could be const.

>  
>  	ksft_print_header();
>  
> -	/* Open the file to DIO */
> -	fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
> -	if (fd < 0)
> -		ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
> -	close(fd);


Why can't we simply open the file once and pass the fd to run_dio_using_hugetlb()?

fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
if (fd < 0)
	ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
dio_align = get_dio_alignment(fd);
if (dio_align <= 0)
	ksft_exit_skip("Unable to obtain DIO alignment: %s\n", strerror(errno));

...

run_dio_using_hugetlb(fd, 0, (pagesize * 3), dio_align);

> -
>  	/* Check if huge pages are free */
>  	if (!get_free_hugepages())
>  		ksft_exit_skip("No free hugepage, exiting\n");
>  
>  	ksft_set_plan(4);
>  
> -	/* Get base page size */
> -	pagesize  = psize();
> -
>  	/* start and end is aligned to pagesize */
> -	run_dio_using_hugetlb(0, (pagesize * 3));
> +	run_dio_using_hugetlb(0, (pagesize * 3), dio_align);
>  
>  	/* start is aligned but end is not aligned */
> -	run_dio_using_hugetlb(0, (pagesize * 3) - (pagesize / 2));
> +	run_dio_using_hugetlb(0, (pagesize * 3) - (pagesize / 2), dio_align);
>  
>  	/* start is unaligned and end is aligned */
> -	run_dio_using_hugetlb(pagesize / 2, (pagesize * 3));
> +	run_dio_using_hugetlb(pagesize / 2, (pagesize * 3), dio_align);
>  
>  	/* both start and end are unaligned */
> -	run_dio_using_hugetlb(pagesize / 2, (pagesize * 3) + (pagesize / 2));
> +	run_dio_using_hugetlb(pagesize / 2, (pagesize * 3) + (pagesize / 2), dio_align);
>  
>  	ksft_finished();
>  }


-- 
Cheers,

David