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 get_dio_alignment() to query the filesystem's required DIO alignment
via statx(STATX_DIOALIGN) and skip individual test cases whose file offset
or write size is not a multiple of that alignment.  Aligned cases continue
to run so the core coverage is preserved.

While here, open the temporary file once in main() and share the fd across
all test cases instead of reopening it in each invocation.

=== 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

Link: https://lore.kernel.org/20260401090520.24018-1-liwang@redhat.com
Signed-off-by: Li Wang <liwang@redhat.com>
Suggested-by: Mike Rapoport <rppt@kernel.org>
Suggested-by: David Hildenbrand <david@kernel.org>
Acked-by: David Hildenbrand (Arm) <david@kernel.org>
Cc: Liam Howlett <liam.howlett@oracle.com>
Cc: Lorenzo Stoakes (Oracle) <ljs@kernel.org>
Cc: Michal Hocko <mhocko@suse.com>
Cc: Mike Rapoport <rppt@kernel.org>
Cc: Shuah Khan <shuah@kernel.org>
Cc: Suren Baghdasaryan <surenb@google.com>
Cc: Vlastimil Babka <vbabka@kernel.org>
Signed-off-by: Andrew Morton <akpm@linux-foundation.org>

diff --git a/tools/testing/selftests/mm/hugetlb_dio.c b/tools/testing/selftests/mm/hugetlb_dio.c
index 9ac62eb4c97d4a77eb61866e63b001277a8a5ba4..31a054fa813484fb0ca78e214e76ada33d2918ae 100644 (file)
--- a/tools/testing/selftests/mm/hugetlb_dio.c
+++ b/tools/testing/selftests/mm/hugetlb_dio.c
@@ -17,12 +17,57 @@
 #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)
+#ifndef STATX_DIOALIGN
+#define STATX_DIOALIGN         0x00002000U
+#endif
+
+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 STATX_DIOALIGN is unsupported, assume no alignment
+        * constraint and let the test proceed.
+        */
+       if (!(stx.stx_mask & STATX_DIOALIGN) || !stx.stx_dio_offset_align)
+               return 1;
+
+       return stx.stx_dio_offset_align;
+}
+
+static bool check_dio_alignment(unsigned int start_off,
+                               unsigned int end_off, unsigned int align)
+{
+       unsigned int writesize = end_off - start_off;
+
+       /*
+        * The kernel's DIO path checks that file offset, length, and
+        * buffer address are all multiples of dio_offset_align.  When
+        * this test case's parameters don't satisfy that, the write
+        * would fail with -EINVAL before exercising the hugetlb unpin
+        * path, so skip.
+        */
+       if (start_off % align != 0 || writesize % align != 0) {
+               ksft_test_result_skip("DIO align=%u incompatible with offset %u writesize %u\n",
+                               align, start_off, writesize);
+               return false;
+       }
+
+       return true;
+}
+
+static void run_dio_using_hugetlb(int fd, unsigned int start_off,
+                               unsigned int end_off, unsigned int align)
 {
-       int fd;
        char *buffer =  NULL;
        char *orig_buffer = NULL;
        size_t h_pagesize = 0;
@@ -32,6 +77,9 @@ void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
        const int mmap_flags = MAP_PRIVATE | MAP_ANONYMOUS | MAP_HUGETLB;
        const int mmap_prot  = PROT_READ | PROT_WRITE;
 
+       if (!check_dio_alignment(start_off, end_off, align))
+               return;
+
        writesize = end_off - start_off;
 
        /* Get the default huge page size */
@@ -39,10 +87,9 @@ void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
        if (!h_pagesize)
                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);
-       if (fd < 0)
-               ksft_exit_fail_perror("Error opening file\n");
+       /* Reset file position since fd is shared across tests */
+       if (lseek(fd, 0, SEEK_SET) < 0)
+               ksft_exit_fail_perror("lseek failed\n");
 
        /* Get the free huge pages before allocation */
        free_hpage_b = get_free_hugepages();
@@ -71,7 +118,6 @@ void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
 
        /* unmap the huge page */
        munmap(orig_buffer, h_pagesize);
-       close(fd);
 
        /* Get the free huge pages after unmap*/
        free_hpage_a = get_free_hugepages();
@@ -89,37 +135,38 @@ void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off)
 
 int main(void)
 {
-       size_t pagesize = 0;
-       int fd;
+       int fd, align;
+       const 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 if huge pages are free */
        if (!get_free_hugepages())
                ksft_exit_skip("No free hugepage, exiting\n");
 
-       ksft_set_plan(4);
+       fd = open("/tmp", O_TMPFILE | O_RDWR | O_DIRECT, 0664);
+       if (fd < 0)
+               ksft_exit_skip("Unable to allocate file: %s\n", strerror(errno));
 
-       /* Get base page size */
-       pagesize  = psize();
+       align = get_dio_alignment(fd);
+       if (align < 0)
+               ksft_exit_skip("Unable to obtain DIO alignment: %s\n",
+                               strerror(errno));
+       ksft_set_plan(4);
 
        /* start and end is aligned to pagesize */
-       run_dio_using_hugetlb(0, (pagesize * 3));
+       run_dio_using_hugetlb(fd, 0, (pagesize * 3), align);
 
        /* start is aligned but end is not aligned */
-       run_dio_using_hugetlb(0, (pagesize * 3) - (pagesize / 2));
+       run_dio_using_hugetlb(fd, 0, (pagesize * 3) - (pagesize / 2), align);
 
        /* start is unaligned and end is aligned */
-       run_dio_using_hugetlb(pagesize / 2, (pagesize * 3));
+       run_dio_using_hugetlb(fd, pagesize / 2, (pagesize * 3), align);
 
        /* both start and end are unaligned */
-       run_dio_using_hugetlb(pagesize / 2, (pagesize * 3) + (pagesize / 2));
+       run_dio_using_hugetlb(fd, pagesize / 2, (pagesize * 3) + (pagesize / 2), align);
+
+       close(fd);
 
        ksft_finished();
 }