Skip to contentSkip to conversation

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

PATCH Superseded Li Wang 3 participants 4 messages Mar 27

Subsystems (3)

v1 of 5 Superseded Latest is v5 →

lore
Share & tools
lore

Li Wang

author
#0 lore raw

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

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
---
 tools/testing/selftests/mm/hugetlb_dio.c | 37 +++++++++++++++++-------
 1 file changed, 27 insertions(+), 10 deletions(-)
tools/testing/selftests/mm/hugetlb_dio.c +27 -10
index 9ac62eb4c97d..afcca50d190e 100644
@@ -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));
 
Signature · 1 line
2.53.0
reviewer
#1 lore raw
Quoted 66 lines · 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 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
---
 tools/testing/selftests/mm/hugetlb_dio.c | 37 +++++++++++++++++-------
 1 file changed, 27 insertions(+), 10 deletions(-)
tools/testing/selftests/mm/hugetlb_dio.c +13 -0
index 9ac62eb4c97d..afcca50d190e 100644
@@ -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));

tools/testing/selftests/mm/hugetlb_dio.c line 45

Quoted 10 lines
tools/testing/selftests/mm/hugetlb_dio.c +10 -0
+
+	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.

Quoted 5 lines
tools/testing/selftests/mm/hugetlb_dio.c +2 -0
+}
+
 void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
 {
 	int fd;
Signature · 2 lines
Sincerely yours,
Mike.
author
#2 lore raw
Quoted 32 lines
Quoted 19 lines
tools/testing/selftests/mm/hugetlb_dio.c +13 -0
@@ -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));

tools/testing/selftests/mm/hugetlb_dio.c line 45

Quoted 10 lines
tools/testing/selftests/mm/hugetlb_dio.c +10 -0
+
+	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.

Quoted 2 lines

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

Signature · 2 lines
Regards,
Li Wang
maintainer
#3 lore raw
In reply to Li Wang
Quoted 11 lines · On Fri, 27 Mar 2026 11:12:43 +0800 Li Wang <[email protected]> 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/[email protected]

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.