1. Patchew
  2. linux
  3. View series

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

Li Wang posted 1 patch 6 days, 12 hours ago
There is a newer version of this series
tools/testing/selftests/mm/hugetlb_dio.c | 37 +++++++++++++++++-------
1 file changed, 27 insertions(+), 10 deletions(-)
[PATCH] selftests/mm: skip hugetlb_dio tests when DIO alignment is incompatible
Posted by Li Wang 6 days, 12 hours ago 
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 check_dio_alignment() which queries the filesystem's DIO alignment
requirement via statx(STATX_DIOALIGN) and skips the test early if the
sub-page offset used by the test is not compatible with the alignment
constraint.

=== 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>
---
 tools/testing/selftests/mm/hugetlb_dio.c | 37 +++++++++++++++++-------
 1 file changed, 27 insertions(+), 10 deletions(-)

diff --git a/tools/testing/selftests/mm/hugetlb_dio.c b/tools/testing/selftests/mm/hugetlb_dio.c
index 9ac62eb4c97d..afcca50d190e 100644
--- a/tools/testing/selftests/mm/hugetlb_dio.c
+++ b/tools/testing/selftests/mm/hugetlb_dio.c
@@ -20,6 +20,31 @@
 #include "vm_util.h"
 #include "kselftest.h"
 
+#ifndef STATX_DIOALIGN
+#define STATX_DIOALIGN		0x00002000U
+#endif
+
+void check_dio_alignment(size_t pagesize)
+{
+	int fd;
+	struct statx stx;
+	unsigned int dio_align = 1;
+
+	fd = open("/tmp", O_TMPFILE | O_RDWR, 0664);
+	if (fd < 0)
+		ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
+
+	if (statx(fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &stx) == 0 &&
+				(stx.stx_mask & STATX_DIOALIGN))
+		dio_align = stx.stx_dio_offset_align;
+
+	close(fd);
+
+	if ((pagesize / 2) % dio_align != 0)
+		ksft_exit_skip("DIO alignment (%u) incompatible with sub-page offset %lu\n",
+				dio_align, pagesize / 2);
+}
+
 void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
 {
 	int fd;
@@ -89,16 +114,11 @@ 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();
 
 	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_dio_alignment(pagesize);
 
 	/* Check if huge pages are free */
 	if (!get_free_hugepages())
@@ -106,9 +126,6 @@ int main(void)
 
 	ksft_set_plan(4);
 
-	/* Get base page size */
-	pagesize  = psize();
-
 	/* start and end is aligned to pagesize */
 	run_dio_using_hugetlb(0, (pagesize * 3));
 
-- 
2.53.0
Re: [PATCH] selftests/mm: skip hugetlb_dio tests when DIO alignment is incompatible
Posted by Andrew Morton 5 days, 21 hours ago 
On Fri, 27 Mar 2026 11:12:43 +0800 Li Wang <liwang@redhat.com> 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 check_dio_alignment() which queries the filesystem's DIO alignment
> requirement via statx(STATX_DIOALIGN) and skips the test early if the
> sub-page offset used by the test is not compatible with the alignment
> constraint.

AI review askes questions:
	https://sashiko.dev/#/patchset/20260327031243.15903-1-liwang@redhat.com

The glibc one is worthwhile, I suppose.  glibc-2.37 was released Feb
2023.

I'd ignore the filesystem-doesn't-support-directio ones.  If someone's
running a dio test against such a filesystem then Don't Do That.

And yes please, %zu.
Re: [PATCH] selftests/mm: skip hugetlb_dio tests when DIO alignment is incompatible
Posted by Mike Rapoport 6 days, 8 hours ago 
On Fri, Mar 27, 2026 at 11:12:43AM +0800, 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 check_dio_alignment() which queries the filesystem's DIO alignment
> requirement via statx(STATX_DIOALIGN) and skips the test early if the
> sub-page offset used by the test is not compatible with the alignment
> constraint.
> 
> === 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>
> ---
>  tools/testing/selftests/mm/hugetlb_dio.c | 37 +++++++++++++++++-------
>  1 file changed, 27 insertions(+), 10 deletions(-)
> 
> diff --git a/tools/testing/selftests/mm/hugetlb_dio.c b/tools/testing/selftests/mm/hugetlb_dio.c
> index 9ac62eb4c97d..afcca50d190e 100644
> --- a/tools/testing/selftests/mm/hugetlb_dio.c
> +++ b/tools/testing/selftests/mm/hugetlb_dio.c
> @@ -20,6 +20,31 @@
>  #include "vm_util.h"
>  #include "kselftest.h"
>  
> +#ifndef STATX_DIOALIGN
> +#define STATX_DIOALIGN		0x00002000U
> +#endif
> +
> +void check_dio_alignment(size_t pagesize)
> +{
> +	int fd;
> +	struct statx stx;
> +	unsigned int dio_align = 1;
> +
> +	fd = open("/tmp", O_TMPFILE | O_RDWR, 0664);
> +	if (fd < 0)
> +		ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
> +
> +	if (statx(fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &stx) == 0 &&
> +				(stx.stx_mask & STATX_DIOALIGN))
> +		dio_align = stx.stx_dio_offset_align;
> +
> +	close(fd);
> +
> +	if ((pagesize / 2) % dio_align != 0)
> +		ksft_exit_skip("DIO alignment (%u) incompatible with sub-page offset %lu\n",
> +				dio_align, pagesize / 2);

This also needlessly skips the test with aligned offsets.

I'd suggest detecting dio_align here, passing it to run_dio_using_hugetlb()
and moving the check that skips a test there.

> +}
> +
>  void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
>  {
>  	int fd;

-- 
Sincerely yours,
Mike.
Re: [PATCH] selftests/mm: skip hugetlb_dio tests when DIO alignment is incompatible
Posted by Li Wang 6 days, 5 hours ago 
> > --- a/tools/testing/selftests/mm/hugetlb_dio.c
> > +++ b/tools/testing/selftests/mm/hugetlb_dio.c
> > @@ -20,6 +20,31 @@
> >  #include "vm_util.h"
> >  #include "kselftest.h"
> >  
> > +#ifndef STATX_DIOALIGN
> > +#define STATX_DIOALIGN		0x00002000U
> > +#endif
> > +
> > +void check_dio_alignment(size_t pagesize)
> > +{
> > +	int fd;
> > +	struct statx stx;
> > +	unsigned int dio_align = 1;
> > +
> > +	fd = open("/tmp", O_TMPFILE | O_RDWR, 0664);
> > +	if (fd < 0)
> > +		ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
> > +
> > +	if (statx(fd, "", AT_EMPTY_PATH, STATX_DIOALIGN, &stx) == 0 &&
> > +				(stx.stx_mask & STATX_DIOALIGN))
> > +		dio_align = stx.stx_dio_offset_align;
> > +
> > +	close(fd);
> > +
> > +	if ((pagesize / 2) % dio_align != 0)
> > +		ksft_exit_skip("DIO alignment (%u) incompatible with sub-page offset %lu\n",
> > +				dio_align, pagesize / 2);
> 
> This also needlessly skips the test with aligned offsets.
> 
> I'd suggest detecting dio_align here, passing it to run_dio_using_hugetlb()
> and moving the check that skips a test there.

Good point, as the first test case use 'pagesize * 3' is fully aligned
and would work fine. But apparently I overlooked that.

Also, Sashiko reminder few minor issues, which I would fix them in next
version as well.
  https://sashiko.dev/#/patchset/20260327031243.15903-1-liwang%40redhat.com

-- 
Regards,
Li Wang

Patchew 2.1-devel-ea86937

© 2016 - 2026 Red Hat, Inc.