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

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

[Li Wang]

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 */
-	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();
 
 	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);
-
 	/* 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();
 }
-- 
2.53.0

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

[David Hildenbrand (Arm)]

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

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

[Li Wang]

On Mon, Mar 30, 2026 at 08:02:01AM +0200, David Hildenbrand (Arm) wrote:

> >  	/* 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.

+1

> >  int main(void)
> >  {
> > -	size_t pagesize = 0;
> > -	int fd;
> > +	size_t pagesize = psize();
> > +	unsigned int dio_align = get_dio_alignment();
> 
> Both could be const.

+1

> 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));

Yes, apparently this is a good suggestion. Thanks!

-- 
Regards,
Li Wang

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

[Li Wang]

> > 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));
> 
> Yes, apparently this is a good suggestion. Thanks!

And, to make the test elegant, I'm going to add check_dio_alignment() dedicated
to alignment checking. Then we don't need to pass too many args.

Tell me your thoughts if you don't like this:

  static int get_dio_alignment(int fd)
  {...}
  
  static bool check_dio_alignment(unsigned int start_off, unsigned int end_off)
  {...}
  
  static void run_test(int fd, unsigned int start_off, unsigned int end_off)
  {
      if (!check_dio_alignment(start_off, end_off))
          return;
  
      run_dio_using_hugetlb(fd, start_off, end_off);
  }
  
  int main(void)
  {
      ... 
      fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
      if (fd < 0)
          ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
  
      if (get_dio_alignment(fd) < 0)
          ...
  
      run_test(fd, 0, (pagesize * 3));
  }

-- 
Regards,
Li Wang

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

[David Hildenbrand (Arm)]

On 3/30/26 12:10, Li Wang wrote:
>>> 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));
>>
>> Yes, apparently this is a good suggestion. Thanks!
> 
> And, to make the test elegant, I'm going to add check_dio_alignment() dedicated
> to alignment checking. Then we don't need to pass too many args.
> 
> Tell me your thoughts if you don't like this:
> 
>   static int get_dio_alignment(int fd)
>   {...}
>   
>   static bool check_dio_alignment(unsigned int start_off, unsigned int end_off)
>   {...}
>   
>   static void run_test(int fd, unsigned int start_off, unsigned int end_off)
>   {
>       if (!check_dio_alignment(start_off, end_off))
>           return;
>   
>       run_dio_using_hugetlb(fd, start_off, end_off);
>   }
>   
>   int main(void)
>   {
>       ... 
>       fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
>       if (fd < 0)
>           ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
>   
>       if (get_dio_alignment(fd) < 0)

I would suggest that you query the alignment only once, and forward it
to the test.

-- 
Cheers,

David

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

[Li Wang]

> >   int main(void)
> >   {
> >       ... 
> >       fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
> >       if (fd < 0)
> >           ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
> >   
> >       if (get_dio_alignment(fd) < 0)
> 
> I would suggest that you query the alignment only once, and forward it
> to the test.

Sure thing, I declare a global variable 'dio_offset_align' to get the value
only once via get_dio_alignment(fd).

(sorry for not posting in the above email)

static unsigned int dio_offset_align;

static int get_dio_alignment(int fd)
{
	struct statx stx;
	int ret;

	ret = syscall(__NR_statx, fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &stx);
	if (ret < 0)
		return -1;

	if (!(stx.stx_mask & STATX_DIOALIGN) || !stx.stx_dio_offset_align)
		dio_offset_align = 1;
	else
		dio_offset_align = stx.stx_dio_offset_align;

	return 0;
}


-- 
Regards,
Li Wang

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

[Li Wang]

On Mon, Mar 30, 2026 at 07:35:50PM +0800, Li Wang wrote:
> > >   int main(void)
> > >   {
> > >       ... 
> > >       fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
> > >       if (fd < 0)
> > >           ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
> > >   
> > >       if (get_dio_alignment(fd) < 0)
> > 
> > I would suggest that you query the alignment only once, and forward it
> > to the test.

Oh, I suddenly realized that you meant to store it in a local and forward
it through to check_dio_alignment() and run_test() as an explicit argument.  

Sure, I'm ok with that minor change:

int main(void)
{
        ...

        alignment = get_dio_alignment(fd);
        if (alignment < 0)
                ksft_exit_skip(...);

        run_test(fd, start_off, end_off, alignment);
}


-- 
Regards,
Li Wang

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

[Li Wang]

Reply to Sashiko:

> +	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;
> +	}

> Does start_off represent the memory buffer alignment rather than the file
> offset alignment?

> If it represents the memory buffer offset within the page-aligned hugepage,
> should it be validated against stx_dio_mem_align instead of
> stx_dio_offset_align?

Hmm, I don't believe this unless you give me strong evidence here!

After looking though Filesystems for handling the direct IO process, I just
found that Btrfs does the buffer-address alignment check but it uses the
dio_offset_align rather than dio_mem_align.

And, the check_direct_IO() does not actually distinguish between the two
alignments in its fast-path check. It applies dio_offset_align uniformly
to pos, length, and buffer address.

Also, I tried the reproducer on Btrfs, ext2/3/4, xfs, vfat, ntfs, all get
passed with this patch. So I'd keep the patch not check for dio_mem_align.

-- 
Regards,
Li Wang