Skip to contentSkip to conversation

xfs/842: test close() deadlocks on frozen filesystems

PATCH In review Aditya Srivastava 2 participants 2 messages Jun 12 – Jun 14

lore
Share & tools
lore
#0 lore raw

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
index 31ac43b2..9553e7c9 100644
@@ -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
new file mode 100755
index 00000000..8b225ea2
@@ -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
new file mode 100644
index 00000000..386fb9cc
@@ -0,0 +1,2 @@
+QA output created by 842
+close() completed immediately!
Signature · 1 line
2.47.3
#1 lore raw
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, 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 +0 -0
index 31ac43b2..9553e7c9 100644

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 -0
 TARGETS += $(LINUX_TARGETS)
 endif
 
src/xfs_freeze_close_repro.c new file +0 -0
new file mode 100644
index 00000000..075f2d18

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
new file mode 100755
index 00000000..8b225ea2
@@ -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
new file mode 100644
index 00000000..386fb9cc
@@ -0,0 +1,2 @@
+QA output created by 842
+close() completed immediately!
Signature · 1 line
2.47.3