selftests/mm: skip hugetlb_dio tests when DIO alignment is incompatible
Subsystems (4)
PATCH v3 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 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
---
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(-)
tools/testing/selftests/mm/hugetlb_dio.c +45 -17
@@ -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 (); }
Signature · 1 line
2.53.0
David Hildenbrand (Arm)
maintainerQuoted 117 lines · Li Wang
hugetlb_diotest 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 viastatx(STATX_DIOALIGN)and pass it torun_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_testand 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:0Signed-off-by Li Wang <[email protected]>---
Notes:
v3:
- Adopt statx raw syscall to build on older glibc.
- add buf offset alignment check as well
v2:
- Passdio_alignas a parameter torun_dio_using_hugetlb()instead of generally page_size/2 alignment check.
- AddO_DIRECTflag back to the firstopen().
- Addstx_dio_offset_alignzero check.tools/testing/selftests/mm/hugetlb_dio.c | 62 +++++++++++++++++------- 1 file changed, 45 insertions(+), 17 deletions(-)tools/testing/selftests/mm/hugetlb_dio.c +38
-1@@ -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 ();
tools/testing/selftests/mm/hugetlb_dio.c void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off) · line 79
Quoted 3 lines
tools/testing/selftests/mm/hugetlb_dio.c +0
-0@@ -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.
tools/testing/selftests/mm/hugetlb_dio.c void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off) · line 130
Quoted 13 lines
tools/testing/selftests/mm/hugetlb_dio.c +3
-3- 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.
tools/testing/selftests/mm/hugetlb_dio.c void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off) · line 101
Quoted 8 lines
tools/testing/selftests/mm/hugetlb_dio.c +0
-5ksft_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);
Quoted 28 lines
tools/testing/selftests/mm/hugetlb_dio.c +4
-8-/* 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 (); }
Signature · 3 lines
Cheers, David
Quoted 4 lines · David Hildenbrand (Arm)
Quoted 1 line
/* 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
Quoted 8 lines
tools/testing/selftests/mm/hugetlb_dio.c void run_dio_using_hugetlb(unsigned int start_off, unsigned int end_off) · line 130
Quoted 6 lines
int main(void)
{tools/testing/selftests/mm/hugetlb_dio.c +2
-2-size_t pagesize =0 ; -int fd; +size_t pagesize =psize (); +unsigned int dio_align =get_dio_alignment ();Both could be const.
+1
Quoted 8 lines
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!
Signature · 2 lines
Regards, Li Wang
Quoted 10 lines
Quoted 8 lines
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));}
Signature · 2 lines
Regards, Li Wang
David Hildenbrand (Arm)
maintainerQuoted 30 lines · Li Wang
Quoted 10 lines
Quoted 8 lines
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);}
Quoted 8 lines
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.
Signature · 3 lines
Cheers, David
Quoted 11 lines
Quoted 8 lines
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;
}Signature · 2 lines
Regards, Li Wang
Quoted 11 lines · Li Wang
Quoted 11 lines
Quoted 8 lines
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);
}Signature · 2 lines
Regards, Li Wang
Reply to Sashiko:
Quoted 7 lines
tools/testing/selftests/mm/hugetlb_dio.c +6
-0+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 ; + }
Quoted 6 lines
Does
start_offrepresent 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_aligninstead ofstx_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.
Signature · 2 lines
Regards, Li Wang