xfs/842: test close() deadlocks on frozen filesystems
PATCH 1/1 xfs/842: test close() deadlocks on frozen filesystems
From: Aditya Prakash Srivastava <[email protected]>
When a file with active speculative post-EOF preallocations is closed, XFS synchronously attempts to free them via xfs_free_eofblocks(). This requires allocating a write transaction, which blocks indefinitely if the filesystem is frozen, causing close() to hang.
Add a regression test using a helper C program to verify that close() returns cleanly (with -EAGAIN if using XFS_TRANS_WRITECOUNT_TRYLOCK) without blocking the close system call.
This is a regression test for the corresponding kernel patch:
"xfs: prevent close() from hanging on frozen filesystems"
On a successfully patched kernel, the close system call returns cleanly and the test helper outputs 'close() completed immediately!', matching the golden output. On an unpatched kernel, the close system call blocks, the helper times out and outputs 'close() hung under freeze!', cleanly flagging the deadlock to fstests.
--- src/Makefile | 1 + src/xfs_freeze_close_repro.c | 127 +++++++++++++++++++++++++++++++++++ tests/xfs/842 | 32 +++++++++ tests/xfs/842.out | 2 + 4 files changed, 162 insertions(+) create mode 100644 src/xfs_freeze_close_repro.c create mode 100755 tests/xfs/842 create mode 100644 tests/xfs/842.out
src/Makefile +1 -0
@@ -68,6 +68,7 @@ LCFLAGS += -DHAVE_FILE_GETATTR endif ifeq ($(PKG_PLATFORM),linux) +LINUX_TARGETS += xfs_freeze_close_repro TARGETS += $(LINUX_TARGETS) endif
src/xfs_freeze_close_repro.c new file +127 -0
127 lines not on this page · raw message
tests/xfs/842 new file +32 -0
@@ -0,0 +1,32 @@ +#! /bin/bash +# SPDX-License-Identifier: GPL-2.0 +# Copyright (c) 2026 Aditya Prakash Srivastava. All Rights Reserved. +# +# FS QA Test No. 842 +# +# Verify that closing a file with active speculative post-EOF preallocations +# on a frozen XFS filesystem does not deadlock inside close(). +# +. ./common/preamble +_begin_fstest auto quick freeze + +# Import helper functions +. ./common/rc +. ./common/filter + +# Real-world configs +_supported_fs xfs +_require_scratch +_require_test_program "xfs_freeze_close_repro" + +_scratch_mkfs >> $seqres.full 2>&1 +_scratch_mount + +TEST_FILE=$SCRATCH_MNT/test_eofblocks_freeze + +# Execute the reproducer helper on scratch mount +$here/src/xfs_freeze_close_repro $TEST_FILE + +status=$? +_scratch_unmount +_exit
tests/xfs/842.out new file +2 -0
@@ -0,0 +1,2 @@ +QA output created by 842 +close() completed immediately!
Signature · 1 line
2.47.3
Quoted 38 lines · Aditya Srivastava
From: Aditya Prakash Srivastava <[email protected]>
When a file with active speculative post-EOF preallocations is closed, XFS synchronously attempts to free them via
xfs_free_eofblocks(). This requires allocating a write transaction, which blocks indefinitely if the filesystem is frozen, causingclose()to hang.Add a regression test using a helper C program to verify that
close()returns cleanly (with-EAGAINif usingXFS_TRANS_WRITECOUNT_TRYLOCK) without blocking the close system call.This is a regression test for the corresponding kernel patch:
"xfs: preventclose()from hanging on frozen filesystems"On a successfully patched kernel, the close system call returns cleanly and the test helper outputs '
close()completed immediately!', matching the golden output. On an unpatched kernel, the close system call blocks, the helper times out and outputs 'close()hung under freeze!', cleanly flagging the deadlock to fstests.Signed-off-by Aditya Prakash Srivastava <[email protected]>--- src/Makefile | 1 + src/xfs_freeze_close_repro.c | 127 +++++++++++++++++++++++++++++++++++ tests/xfs/842 | 32 +++++++++ tests/xfs/842.out | 2 + 4 files changed, 162 insertions(+) create mode 100644 src/xfs_freeze_close_repro.c create mode 100755 tests/xfs/842 create mode 100644 tests/xfs/842.outsrc/Makefile +0
-0
src/Makefile LCFLAGS += -DHAVE_FILE_GETATTR · line 71
Quoted 4 lines
src/Makefile +1
-0@@ -68,6 +68,7 @@ LCFLAGS += -DHAVE_FILE_GETATTR endif ifeq ($(PKG_PLATFORM),linux) +LINUX_TARGETS += xfs_freeze_close_repro
Please add xfs_freeze_close_repro into above/original "LINUX_TARGETS = ..." directly.
Quoted 9 lines
src/Makefile +0
-0TARGETS += $(LINUX_TARGETS) endifsrc/xfs_freeze_close_repro.c new file +0
-0
src/xfs_freeze_close_repro.c line 7
Quoted 7 lines
src/xfs_freeze_close_repro.c new file +7
-0@@ -0,0 +1,127 @@ +// SPDX-License-Identifier: GPL-2.0 +/* +* Copyright (c) 2026 Aditya Prakash Srivastava. All Rights Reserved. +* +* xfstests helper to reproduce close() hang on frozen XFS filesystems. +*/ +#define _GNU_SOURCE
#ifndef _GNU_SOURCE
#define _GNU_SOURCE
#endif
src/xfs_freeze_close_repro.c line 20
Quoted 13 lines
src/xfs_freeze_close_repro.c new file +13
-0+#include <stdio.h> +#include <stdlib.h> +#include <string.h> +#include <unistd.h> +#include <fcntl.h> +#include <pthread.h> +#include <sys/ioctl.h> +#include <sys/vfs.h> +#include <linux/fs.h> +#include <libgen.h> + +int close_started; +int close_completed;
volatile ?
Quoted 34 lines
src/xfs_freeze_close_repro.c new file +34
-0+ +void * +close_thread (void *arg) +{ +int fd = *(int *)arg; + + close_started =1 ; +close (fd); + close_completed =1 ; +return NULL ; +} + +int +main (int argc,char *argv[]) +{ +struct statfs sfs; +char *dir_buf; +char *parent_dir; +int freeze_fd; +int write_fd; +char buf[65536 ]; +pthread_t thread; +int hung =1 ; +int i; + +if (argc <2 ) { +fprintf (stderr,"Usage: %s <file_on_xfs>\n" , argv[0 ]); +return 1 ; + } + +if (statfs (argv[1 ], &sfs) <0 ) { + dir_buf =strdup (argv[1 ]); + parent_dir =dirname (dir_buf); +if (statfs (parent_dir, &sfs) <0 ) {
src/xfs_freeze_close_repro.c line 64
Quoted 10 lines
src/xfs_freeze_close_repro.c new file +10
-0+perror ("statfs" ); +free (dir_buf); +return 1 ; + } +free (dir_buf); + } +if (sfs.f_type !=0x58465342 ) { +fprintf (stderr,"Not on XFS\n" ); +return 1 ; + }
Why limit this program run on XFS? There're not XFS specific test steps.
Quoted 14 lines
src/xfs_freeze_close_repro.c new file +14
-0+ + dir_buf =strdup (argv[1 ]); + freeze_fd =open (dirname (dir_buf),O_RDONLY ); +if (freeze_fd <0 ) { +perror ("open dir" ); +free (dir_buf); +return 1 ; + } +free (dir_buf); + + write_fd =open (argv[1 ],O_WRONLY |O_CREAT |O_TRUNC ,0644 ); +if (write_fd <0 ) { +perror ("open file" ); +close (freeze_fd);
src/xfs_freeze_close_repro.c line 88
Quoted 10 lines
src/xfs_freeze_close_repro.c new file +10
-0+return 1 ; + } + +memset (buf,'A' ,sizeof (buf)); +for (i =0 ; i <320 ; i++) { +if (write (write_fd, buf,sizeof (buf)) <0 ) { +perror ("write" ); +close (write_fd); +close (freeze_fd); +return 1 ;
goto out_err;
src/xfs_freeze_close_repro.c line 96
Quoted 8 lines
src/xfs_freeze_close_repro.c new file +8
-0+ } + } + +if (ioctl (freeze_fd,FIFREEZE ,0 ) <0 ) { +perror ("ioctl FIFREEZE" ); +close (write_fd); +close (freeze_fd); +return 1 ;
goto out_err;
src/xfs_freeze_close_repro.c line 97
Quoted 1 line
src/xfs_freeze_close_repro.c new file +1
-0+ }
frozen = 1;
src/xfs_freeze_close_repro.c line 104
Quoted 7 lines
src/xfs_freeze_close_repro.c new file +7
-0+ +if (pthread_create (&thread,NULL , close_thread, &write_fd) !=0 ) { +perror ("pthread_create" ); +ioctl (freeze_fd,FITHAW ,0 ); +close (write_fd); +close (freeze_fd); +return 1 ;
goto out_err;
src/xfs_freeze_close_repro.c line 110
Quoted 6 lines
src/xfs_freeze_close_repro.c new file +6
-0+ } + +while (!close_started) +usleep (1000 ); + +for (i =0 ; i <30 ; i++) {
I'm wondering if "3 seconds" is enough to make sure "it's hang" absolutely :)
src/xfs_freeze_close_repro.c line 123
Quoted 13 lines
src/xfs_freeze_close_repro.c new file +13
-0+usleep (100000 ); +if (close_completed) { + hung =0 ; +break ; + } + } + +if (hung) +printf ("close() hung under freeze!\n" ); +else +printf ("close() completed immediately!\n" ); + +ioctl (freeze_fd,FITHAW ,0 );
frozen = 0;
src/xfs_freeze_close_repro.c line 126
Quoted 3 lines
src/xfs_freeze_close_repro.c new file +3
-0+pthread_join (thread,NULL ); +close (freeze_fd); +return hung ?0 :1 ;
out_err:
if (write_fd >= 0) close(write_fd); if (frozen) ioctl(freeze_fd, FITHAW, 0); if (freeze_fd >= 0) close(freeze_fd); return 1;
Quoted 12 lines
src/xfs_freeze_close_repro.c new file +1
-0+}tests/xfs/842 new file +5
-0@@ -0,0 +1,32 @@ +#! /bin/bash +# SPDX-License-Identifier: GPL-2.0 +# Copyright (c) 2026 Aditya Prakash Srivastava. All Rights Reserved. +# +# FS QA Test No. 842
tests/xfs/842 line 15
Quoted 10 lines
tests/xfs/842 new file +10
-0+# +# Verify that closing a file with active speculative post-EOF preallocations +# on a frozen XFS filesystem does not deadlock inside close(). +# +. ./common/preamble +_begin_fstest auto quick freeze + +# Import helper functions +. ./common/rc +. ./common/filter
^^^^^^
It's useless.
tests/xfs/842 line 18
Quoted 3 lines
tests/xfs/842 new file +3
-0+ +# Real-world configs +_supported_fs xfs
There's not "_supported_fs" helper anymore.
And I don't think this case is a xfs specific test case. I think it can be run on all filesystems which supports fsfreeze --
_require_freeze
tests/xfs/842 line 30
Quoted 12 lines
tests/xfs/842 new file +12
-0+_require_scratch +_require_test_program "xfs_freeze_close_repro" + +_scratch_mkfs >> $seqres.full 2>&1 +_scratch_mount + +TEST_FILE=$SCRATCH_MNT/test_eofblocks_freeze + +# Execute the reproducer helper on scratch mount +$here/src/xfs_freeze_close_repro $TEST_FILE + +status=$?
The output of xfs_freeze_close_repro will break the .out, don't need to set status=$? at here. If you want, you can call _fail ... after the xfs_freeze_close_repro returns non-zero.
tests/xfs/842 line 31
Quoted 1 line
tests/xfs/842 new file +1
-0+_scratch_unmount
"unmount" is not necessary at here. But I think you need a specific _cleanup() function for this case. Due to your C program does fs freeze. If it's killed by something suddently, we must make the fs is freezed before running next test case.
_cleanup()
{
# Make sure $SCRATCH_MNT is unfreezed
xfs_freeze -u $SCRATCH_MNT 2>/dev/null
....
....
}
tests/xfs/842 line 32
Quoted 1 line
tests/xfs/842 new file +1
-0+_exit
_exit 0
Since to your kernel patch is still under review, let's see how it goes at first
Thanks,
Zorro
Quoted 11 lines
tests/xfs/842.out new file +2
-0@@ -0,0 +1,2 @@ +QA output created by 842 +close() completed immediately!Signature · 1 line
2.47.3