Add more tests for multi fs block atomic writes

From: "Ritesh Harjani (IBM)" <[email protected]>

Insert range and collapse range only works with bigalloc in case the range is cluster size aligned, which fsx doesnt take care. To work past this, disable insert range and collapse range on ext4, if bigalloc is enabled.

This is achieved by defining a new function _setup_fs_options which can serve as a mechanism to apply FS-wide options to the tests.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 common/preamble | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

common/preamble +16 -0

index ba029a34..2bccff74 100644
@@ -24,6 +24,20 @@ _register_cleanup()
 	trap "${cleanup}exit \$status" EXIT HUP INT QUIT TERM $*
 }
 
+# setup FS options only to be available for each test run
+_setup_fs_options() {
+	case "$FSTYP" in
+	"ext4")
+		if [[ "$MKFS_OPTIONS" =~ bigalloc ]]; then
+			export FSX_AVOID="-I -C"
+		fi
+		;;
+	# Add other filesystem types here as needed
+	*)
+		;;
+	esac
+}
+
 # Prepare to run a fstest by initializing the required global variables to
 # their defaults, sourcing common functions, registering a cleanup function,
 # and removing the $seqres.full file.

@@ -55,4 +69,6 @@ _begin_fstest()
 	# remove previous $seqres.full before test
 	rm -f $seqres.full $seqres.hints
 
+	# setup filesystem options for a given test execution
+	_setup_fs_options
 }

Signature · 1 line

2.49.0

Currently run_fsx is hardcoded to run on a file in $TEST_DIR. Add a helper _run_fsx_on_file so that we can run fsx on any given file including in $SCRATCH_MNT. Also, refactor _run_fsx to use this helper.

No functional change is intended in this patch.

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 common/rc | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

common/rc +4 -1

index cfbe2a5f..a5d811a1 100644
@@ -5115,13 +5115,22 @@ _require_hugepage_fsx()
 		_notrun "fsx binary does not support MADV_COLLAPSE"
 }
 
-_run_fsx()
+_run_fsx_on_file()
 {
+	local testfile=$1
+	shift
+

common/rc +7 -1

 	echo "$@" >>$seqres.full
-	rm -f $TEST_DIR/junk
+	rm -f $testfile
 	"$@" 2>&1 | tee -a $seqres.full >$tmp.fsx
 	local res=${PIPESTATUS[0]}
 	if [ $res -ne 0 ]; then

@@ -5133,6 +5142,12 @@ _run_fsx()
 	return 0
 }
 
+_run_fsx()
+{
+	_run_fsx_on_file $TEST_DIR/junk $@
+	return $?
+}
+
 # Run fsx with -h(ugepage buffers).  If we can't set up a hugepage then skip
 # the test, but if any other error occurs then exit the test.
 _run_hugepage_fsx() {

Signature · 1 line

2.49.0

Implement atomic write support to help fuzz atomic writes with fsx.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 ltp/fsx.c | 105 +++++++++++++++++++++++++++++++++++++++++++++++++++---
 1 file changed, 100 insertions(+), 5 deletions(-)

ltp/fsx.c +84 -3

index 163b9453..9353fe6f 100644
@@ -40,6 +40,7 @@
 #include <liburing.h>
 #endif
 #include <sys/syscall.h>
+#include "statx.h"
 
 #ifndef MAP_FILE
 # define MAP_FILE 0

@@ -49,6 +50,10 @@
 #define RWF_DONTCACHE	0x80
 #endif
 
+#ifndef RWF_ATOMIC
+#define RWF_ATOMIC	0x40
+#endif
+
 #define NUMPRINTCOLUMNS 32	/* # columns of data to print on each line */
 
 /* Operation flags (bitmask) */

@@ -110,6 +115,7 @@ enum {
 	OP_READ_DONTCACHE,
 	OP_WRITE,
 	OP_WRITE_DONTCACHE,
+	OP_WRITE_ATOMIC,
 	OP_MAPREAD,
 	OP_MAPWRITE,
 	OP_MAX_LITE,

@@ -200,6 +206,11 @@ int	uring = 0;
 int	mark_nr = 0;
 int	dontcache_io = 1;
 int	hugepages = 0;                  /* -h flag */
+int	do_atomic_writes = 0;		/* -a flag */
+
+/* User for atomic writes */
+int awu_min = 0;
+int awu_max = 0;
 
 /* Stores info needed to periodically collapse hugepages */
 struct hugepages_collapse_info {

@@ -288,6 +299,7 @@ static const char *op_names[] = {
 	[OP_READ_DONTCACHE] = "read_dontcache",
 	[OP_WRITE] = "write",
 	[OP_WRITE_DONTCACHE] = "write_dontcache",
+	[OP_WRITE_ATOMIC] = "write_atomic",
 	[OP_MAPREAD] = "mapread",
 	[OP_MAPWRITE] = "mapwrite",
 	[OP_TRUNCATE] = "truncate",

@@ -422,6 +434,7 @@ logdump(void)
 				prt("\t***RRRR***");
 			break;
 		case OP_WRITE_DONTCACHE:
+		case OP_WRITE_ATOMIC:
 		case OP_WRITE:
 			prt("WRITE    0x%x thru 0x%x\t(0x%x bytes)",
 			    lp->args[0], lp->args[0] + lp->args[1] - 1,

@@ -1073,6 +1086,25 @@ update_file_size(unsigned offset, unsigned size)
 	file_size = offset + size;
 }
 
+static int is_power_of_2(unsigned n) {
+	return ((n & (n - 1)) == 0);
+}
+
+/*
+ * Round down n to nearest power of 2.
+ * If n is already a power of 2, return n;
+ */
+static int rounddown_pow_of_2(int n) {
+	int i = 0;
+
+	if (is_power_of_2(n))
+		return n;
+
+	for (; (1 << i) < n; i++);
+
+	return 1 << (i - 1);
+}
+
 void
 dowrite(unsigned offset, unsigned size, int flags)
 {

@@ -1081,6 +1113,27 @@ dowrite(unsigned offset, unsigned size, int flags)
 	offset -= offset % writebdy;
 	if (o_direct)
 		size -= size % writebdy;
+	if (flags & RWF_ATOMIC) {
+		/* atomic write len must be inbetween awu_min and awu_max */
+		if (size < awu_min)
+			size = awu_min;
+		if (size > awu_max)
+			size = awu_max;
+
+		/* atomic writes need power-of-2 sizes */
+		size = rounddown_pow_of_2(size);
+
+		/* atomic writes need naturally aligned offsets */
+		offset -= offset % size;
+
+		/* Skip the write if we are crossing max filesize */
+		if ((offset + size) > maxfilelen) {
+			if (!quiet && testcalls > simulatedopcount)
+				prt("skipping atomic write past maxfilelen\n");
+			log4(OP_WRITE_ATOMIC, offset, size, FL_SKIPPED);
+			return;
+		}
+	}
 	if (size == 0) {
 		if (!quiet && testcalls > simulatedopcount && !o_direct)
 			prt("skipping zero size write\n");

@@ -1088,7 +1141,10 @@ dowrite(unsigned offset, unsigned size, int flags)
 		return;
 	}
 
-	log4(OP_WRITE, offset, size, FL_NONE);
+	if (flags & RWF_ATOMIC)
+		log4(OP_WRITE_ATOMIC, offset, size, FL_NONE);
+	else
+		log4(OP_WRITE, offset, size, FL_NONE);
 
 	gendata(original_buf, good_buf, offset, size);
 	if (offset + size > file_size) {

@@ -1108,8 +1164,9 @@ dowrite(unsigned offset, unsigned size, int flags)
 		       (monitorstart == -1 ||
 			(offset + size > monitorstart &&
 			(monitorend == -1 || offset <= monitorend))))))
-		prt("%lld write\t0x%x thru\t0x%x\t(0x%x bytes)\tdontcache=%d\n", testcalls,
-		    offset, offset + size - 1, size, (flags & RWF_DONTCACHE) != 0);
+		prt("%lld write\t0x%x thru\t0x%x\t(0x%x bytes)\tdontcache=%d atomic_wr=%d\n", testcalls,
+		    offset, offset + size - 1, size, (flags & RWF_DONTCACHE) != 0,
+		    (flags & RWF_ATOMIC) != 0);
 	iret = fsxwrite(fd, good_buf + offset, size, offset, flags);
 	if (iret != size) {
 		if (iret == -1)

@@ -1785,6 +1842,30 @@ do_dedupe_range(unsigned offset, unsigned length, unsigned dest)
 }
 #endif
 
+int test_atomic_writes(void) {
+	int ret;
+	struct statx stx;
+
+	ret = xfstests_statx(AT_FDCWD, fname, 0, STATX_WRITE_ATOMIC, &stx);
+	if (ret < 0) {
+		fprintf(stderr, "main: Statx failed with %d."
+			" Failed to determine atomic write limits, "
+			" disabling!\n", ret);
+		return 0;
+	}
+
+	if (stx.stx_attributes & STATX_ATTR_WRITE_ATOMIC &&
+	    stx.stx_atomic_write_unit_min > 0) {
+		awu_min = stx.stx_atomic_write_unit_min;
+		awu_max = stx.stx_atomic_write_unit_max;
+		return 1;
+	}
+
+	fprintf(stderr, "main: IO Stack does not support"
+			"atomic writes, disabling!\n");
+	return 0;
+}
+
 #ifdef HAVE_COPY_FILE_RANGE
 int
 test_copy_range(void)

ltp/fsx.c +10 -2

+		break;
+
 	case OP_MAPREAD:
 		TRIM_OFF_LEN(offset, size, file_size);
 		domapread(offset, size);

@@ -2511,13 +2600,14 @@ void
 usage(void)
 {
 	fprintf(stdout, "usage: %s",
-		"fsx [-dfhknqxyzBEFHIJKLORWXZ0]\n\
+		"fsx [-adfhknqxyzBEFHIJKLORWXZ0]\n\
 	   [-b opnum] [-c Prob] [-g filldata] [-i logdev] [-j logid]\n\
 	   [-l flen] [-m start:end] [-o oplen] [-p progressinterval]\n\
 	   [-r readbdy] [-s style] [-t truncbdy] [-w writebdy]\n\
 	   [-A|-U] [-D startingop] [-N numops] [-P dirpath] [-S seed]\n\
 	   [--replay-ops=opsfile] [--record-ops[=opsfile]] [--duration=seconds]\n\
 	   ... fname\n\
+	-a: enable atomic writes if IO stack supports it\n\
 	-b opnum: beginning operation number (default 1)\n\
 	-c P: 1 in P chance of file close+open at each op (default infinity)\n\
 	-d: debug output for all operations\n\

@@ -3059,9 +3149,12 @@ main(int argc, char **argv)
 	setvbuf(stdout, (char *)0, _IOLBF, 0); /* line buffered stdout */
 
 	while ((ch = getopt_long(argc, argv,
-				 "0b:c:de:fg:hi:j:kl:m:no:p:qr:s:t:uw:xyABD:EFJKHzCILN:OP:RS:UWXZ",
+				 "0ab:c:de:fg:hi:j:kl:m:no:p:qr:s:t:uw:xyABD:EFJKHzCILN:OP:RS:UWXZ",
 				 longopts, NULL)) != EOF)
 		switch (ch) {
+		case 'a':
+			do_atomic_writes = 1;
+			break;
 		case 'b':
 			simulatedopcount = getnum(optarg, &endp);
 			if (!quiet)

@@ -3475,6 +3568,8 @@ main(int argc, char **argv)
 		exchange_range_calls = test_exchange_range();
 	if (dontcache_io)
 		dontcache_io = test_dontcache_io();
+	if (do_atomic_writes)
+		do_atomic_writes = test_atomic_writes();
 
 	while (keep_running())
 		if (!test())

Signature · 1 line

2.49.0

From: "Ritesh Harjani (IBM)" <[email protected]>

This adds atomic write test using fio based on it's crc check verifier. fio adds a crc for each data block. If the underlying device supports atomic write then it is guaranteed that we will never have a mix data from two threads writing on the same physical block.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/767     | 84 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/767.out |  2 ++
 2 files changed, 86 insertions(+)
 create mode 100755 tests/generic/767
 create mode 100644 tests/generic/767.out

tests/generic/767 new file +24 -0

new file mode 100755
index 00000000..4f80e7b6
@@ -0,0 +1,84 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 767
+#
+# Validate FS atomic write using fio crc check verifier.
+#
+. ./common/preamble
+. ./common/atomicwrites
+
+_begin_fstest auto aio rw atomicwrites
+
+_require_scratch_write_atomic
+_require_odirect
+_require_aio
+
+function max()
+{
+	if (( $1 > $2 )); then
+		echo "$1"
+	else
+		echo "$2"
+	fi

tests/generic/767 new file +5 -0

+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount
+
+touch "$SCRATCH_MNT/f1"
+awu_min_write=$(_get_atomic_write_unit_min "$SCRATCH_MNT/f1")

tests/generic/767 new file +34 -0

+SIZE=$((100 * 1024 * 1024))
+
+cat >$fio_config <<EOF
+[aio-dio-aw-verify]
+direct=1
+ioengine=libaio
+rw=randwrite
+bs=$blocksize
+fallocate=native
+filename=$SCRATCH_MNT/test-file
+size=$SIZE
+iodepth=$FIO_LOAD
+numjobs=$FIO_LOAD
+group_reporting=1
+verify_state_save=0
+verify=crc32c
+verify_fatal=1
+verify_dump=0
+verify_backlog=1024
+verify_async=4
+verify_write_sequence=0
+atomic=1
+EOF
+
+_require_fio $fio_config
+
+cat $fio_config >> $seqres.full
+$FIO_PROG $fio_config --output=$fio_out
+cat $fio_out >> $seqres.full
+
+# success, all done
+echo Silence is golden
+status=0
+exit

tests/generic/767.out new file +2 -0

new file mode 100644
index 00000000..2bf7f989
@@ -0,0 +1,2 @@
+QA output created by 767
+Silence is golden

Signature · 1 line

2.49.0

Stress file with atomic writes to ensure we excercise codepaths where we are mixing different FS operations with atomic writes

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/771     | 49 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/771.out |  2 ++
 2 files changed, 51 insertions(+)
 create mode 100755 tests/generic/771
 create mode 100644 tests/generic/771.out

tests/generic/771 new file +29 -0

new file mode 100755
index 00000000..690dfa0a
@@ -0,0 +1,49 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 771
+#
+# fuzz fsx with atomic writes
+#
+. ./common/preamble
+. ./common/atomicwrites
+_begin_fstest rw auto quick atomicwrites
+
+# Import common functions.
+. ./common/filter
+
+_require_test
+_require_odirect
+_require_scratch_write_atomic
+
+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount  >> $seqres.full 2>&1
+
+testfile=$SCRATCH_MNT/testfile
+touch $testfile
+
+awu_max=$(_get_atomic_write_unit_max $testfile)
+blksz=$(_get_block_size $SCRATCH_MNT)
+bsize=`$here/src/min_dio_alignment $SCRATCH_MNT $SCRATCH_DEV`
+

tests/generic/771 new file +10 -0

+status=$?
+
+if [[ "$status" != "0" ]]
+then
+	echo "Somthing went wrong, check $seqres.full"
+fi
+
+echo "Silence is golden"
+status=0
+exit

tests/generic/771.out new file +2 -0

new file mode 100644
index 00000000..c2345c7b
@@ -0,0 +1,2 @@
+QA output created by 771
+Silence is golden

Signature · 1 line

2.49.0

From: "Ritesh Harjani (IBM)" <[email protected]>

This tests uses fio to first create a file with mixed mappings. Then it does atomic writes using aio dio with parallel jobs to the same file with mixed mappings. This forces the filesystem allocator to allocate extents over mixed mapping regions to stress FS block allocators.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/769     | 101 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/769.out |   2 +
 2 files changed, 103 insertions(+)
 create mode 100755 tests/generic/769
 create mode 100644 tests/generic/769.out

tests/generic/769 new file +16 -0

new file mode 100755
index 00000000..469d6344
@@ -0,0 +1,101 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 769
+#
+# Validate FS atomic write using fio crc check verifier on mixed mappings
+# of a file.
+#
+. ./common/preamble
+. ./common/atomicwrites
+
+_begin_fstest auto aio rw atomicwrites
+
+_require_scratch_write_atomic_multi_fsblock
+_require_odirect

tests/generic/769 new file +75 -0

+
+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount
+
+touch "$SCRATCH_MNT/f1"
+awu_min_write=$(_get_atomic_write_unit_min "$SCRATCH_MNT/f1")
+awu_max_write=$(_get_atomic_write_unit_max "$SCRATCH_MNT/f1")
+aw_bsize=$(max "$awu_min_write" "$((awu_max_write/4))")
+
+fsbsize=$(_get_block_size $SCRATCH_MNT)
+
+fio_config=$tmp.fio
+fio_out=$tmp.fio.out
+
+FIO_LOAD=$(($(nproc) * 2 * LOAD_FACTOR))
+SIZE=$((128 * 1024 * 1024))
+
+cat >$fio_config <<EOF
+[global]
+ioengine=libaio
+fallocate=none
+filename=$SCRATCH_MNT/test-file
+filesize=$SIZE
+bs=$fsbsize
+direct=1
+verify=0
+group_reporting=1
+
+# Create written extents
+[written_blocks]
+stonewall
+ioengine=libaio
+rw=randwrite
+io_size=$((SIZE/3))
+random_generator=lfsr
+
+# Create unwritten extents
+[unwritten_blocks]
+stonewall
+ioengine=falloc
+rw=randwrite
+io_size=$((SIZE/3))
+random_generator=lfsr
+
+# atomic write to mixed mappings of written/unwritten/holes
+[atomic_write_aio_dio_job]
+stonewall
+direct=1
+ioengine=libaio
+rw=randwrite
+bs=$aw_bsize
+iodepth=$FIO_LOAD
+numjobs=$FIO_LOAD
+size=$SIZE
+random_generator=lfsr
+verify_state_save=0
+verify=crc32c
+verify_fatal=1
+verify_dump=0
+verify_backlog=1024
+verify_async=4
+verify_write_sequence=0
+atomic=1
+EOF
+
+_require_fio $fio_config
+
+cat $fio_config >> $seqres.full
+$FIO_PROG $fio_config --output=$fio_out
+cat $fio_out >> $seqres.full
+
+# success, all done
+echo Silence is golden
+status=0
+exit

tests/generic/769.out new file +2 -0

new file mode 100644
index 00000000..1512b439
@@ -0,0 +1,2 @@
+QA output created by 769
+Silence is golden

Signature · 1 line

2.49.0

This adds various atomic write multi-fsblock stresst tests with mixed mappings and O_SYNC, to ensure the data and metadata is atomically persisted even if there is a shutdown.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/770     | 161 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/770.out |   2 +
 2 files changed, 163 insertions(+)
 create mode 100755 tests/generic/770
 create mode 100644 tests/generic/770.out

tests/generic/770 new file +5 -0

new file mode 100755
index 00000000..2b98b3b3
@@ -0,0 +1,161 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 770

tests/generic/770 new file +146 -0

+
+_scratch_mkfs >> $seqres.full
+_scratch_mount >> $seqres.full
+
+check_data_integrity() {
+	actual=$(_hexdump $testfile)
+	if [[ "$expected" != "$actual" ]]
+	then
+		echo "Integrity check failed"
+		echo "Integrity check failed" >> $seqres.full
+		echo "# Expected file contents:" >> $seqres.full
+		echo "$expected" >> $seqres.full
+		echo "# Actual file contents:" >> $seqres.full
+		echo "$actual" >> $seqres.full
+	fi
+}
+
+testfile=$SCRATCH_MNT/testfile
+touch $testfile
+
+awu_max=$(_get_atomic_write_unit_max $testfile)
+blksz=$(_get_block_size $SCRATCH_MNT)
+
+# Create an expected pattern to compare with
+$XFS_IO_PROG -tc "pwrite -b $awu_max 0 $awu_max" $testfile >> $seqres.full
+expected=$(_hexdump $testfile)
+echo "# Expected file contents:" >> $seqres.full
+echo "$expected" >> $seqres.full
+
+echo "# Test 1: Do O_DSYNC atomic write on random mixed mapping (10 iterations):" >> $seqres.full
+# Calculate how many blocks (e.g. 4K) fit in awu_max (e.g. 64K)
+num_blocks=$((awu_max / blksz))
+echo "Testing $num_blocks blocks of $blksz size within $awu_max region" >> $seqres.full
+
+operations=("W" "H" "U")
+
+# Run 10 iterations of the test
+for ((iteration=1; iteration<=10; iteration++)); do
+	echo "=== Mixed Mapping Test Iteration $iteration ===" >> $seqres.full
+
+	$XFS_IO_PROG -c "truncate 0" $testfile >> $seqres.full
+	off=0
+	mapping=""
+
+	for ((i=0; i<num_blocks; i++)); do
+		index=$((RANDOM % ${#operations[@]}))
+		map="${operations[$index]}"
+		mapping="${mapping}${map}"
+
+		case "$map" in
+			"W")
+				$XFS_IO_PROG -dc "pwrite -S 0x61 -b $blksz $off $blksz" $testfile > /dev/null
+				;;
+			"H")
+				# No operation needed for hole
+				;;
+			"U")
+				$XFS_IO_PROG -c "falloc $off $blksz" $testfile >> /dev/null
+				;;
+		esac
+		off=$((off + blksz))
+	done
+
+	echo "Mixed mapping preparation complete. Full mapping pattern: $mapping" >> $seqres.full
+
+	sync $testfile
+
+	echo "Performing O_DSYNC atomic write over the entire $awu_max region" >> $seqres.full
+	bytes_written=$($XFS_IO_PROG -dc "pwrite -DA -V1 -b $awu_max 0 $awu_max" $testfile | \
+				  grep wrote | awk -F'[/ ]' '{print $2}')
+
+	test $bytes_written -eq $awu_max || echo "atomic write len=$awu_max failed"
+	check_data_integrity
+	echo "Iteration $iteration completed: OK" >> $seqres.full
+	echo >> $seqres.full
+done
+echo "# Test 1: Do O_SYNC atomic write on random mixed mapping (10 iterations): OK" >> $seqres.full
+
+echo >> $seqres.full
+echo "# Test 2: Do extending O_SYNC atomic writes: " >> $seqres.full
+bytes_written=$($XFS_IO_PROG -dstc "pwrite -A -V1 -b $awu_max 0 $awu_max" $testfile | \
+                grep wrote | awk -F'[/ ]' '{print $2}')
+test $bytes_written -eq $awu_max || echo "atomic write len=$awu_max failed"
+_scratch_shutdown -v >> $seqres.full
+_scratch_cycle_mount >>$seqres.full 2>&1 || _fail "remount failed for Test-2"
+check_data_integrity
+echo "# Test 2: Do extending O_SYNC atomic writes: OK" >> $seqres.full
+
+echo >> $seqres.full
+echo "# Test 3: Do O_DSYNC atomic write on random mixed mapping with sudden fs shutdown (10 iterations):" >> $seqres.full
+num_blocks=$((awu_max / blksz))
+echo "Testing $num_blocks blocks of $blksz size within $awu_max region" >> $seqres.full
+
+operations=("W" "H" "U")
+
+for ((iteration=1; iteration<=10; iteration++)); do
+	echo "=== Mixed Mapping Shutdown Test Iteration $iteration ===" >> $seqres.full
+
+	$XFS_IO_PROG -c "truncate 0" $testfile >> $seqres.full
+
+	off=0
+	mapping=""
+
+	for ((i=0; i<num_blocks; i++)); do
+		index=$((RANDOM % ${#operations[@]}))
+		map="${operations[$index]}"
+		mapping="${mapping}${map}"
+
+		case "$map" in
+			"W")
+				$XFS_IO_PROG -dc "pwrite -S 0x61 -b $blksz $off $blksz" $testfile > /dev/null
+				;;
+			"H")
+				# No operation needed for hole
+				;;
+			"U")
+				$XFS_IO_PROG -c "falloc $off $blksz" $testfile > /dev/null
+				;;
+		esac
+		off=$((off + blksz))
+	done
+
+	echo "Mixed mapping preparation complete. Full mapping pattern: $mapping" >> $seqres.full
+
+	sync $testfile
+
+	echo "Performing O_DSYNC atomic write over the entire $awu_max region" >> $seqres.full
+	bytes_written=$($XFS_IO_PROG -dc "pwrite -DA -V1 -b $awu_max 0 $awu_max" $testfile | \
+				  grep wrote | awk -F'[/ ]' '{print $2}')
+
+	test $bytes_written -eq $awu_max || echo "atomic write len=$awu_max failed"
+
+	echo "Shutting down filesystem" >> $seqres.full
+	_scratch_shutdown -v >> $seqres.full
+	_scratch_cycle_mount >>$seqres.full 2>&1 || _fail "remount failed for Test-3"
+	check_data_integrity
+	echo "Iteration $iteration completed: OK" >> $seqres.full
+	echo >> $seqres.full
+done
+echo "# Test 3: Do O_SYNC atomic write on random mixed mapping with sudden fs shutdown (10 iterations): OK" >> $seqres.full
+
+# success, all done
+echo "Silence is golden"
+status=0
+exit
+

tests/generic/770.out new file +2 -0

new file mode 100644
index 00000000..17994ed5
@@ -0,0 +1,2 @@
+QA output created by 770
+Silence is golden

Signature · 1 line

2.49.0

This test is intended to ensure that multi blocks atomic writes maintain atomic guarantees across sudden FS shutdowns.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/772     | 360 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/772.out |   2 +
 2 files changed, 362 insertions(+)
 create mode 100755 tests/generic/772
 create mode 100644 tests/generic/772.out

tests/generic/772 new file +4 -0

new file mode 100755
index 00000000..6af7e74c
@@ -0,0 +1,360 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#

tests/generic/772 new file +346 -0

+
+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount >> $seqres.full
+
+testfile=$SCRATCH_MNT/testfile
+touch $testfile
+
+awu_max=$(_get_atomic_write_unit_max $testfile)
+blksz=$(_get_block_size $SCRATCH_MNT)
+echo "Awu max: $awu_max" >> $seqres.full
+
+num_blocks=$((awu_max / blksz))
+filesize=$(($blksz * 12 * 1024 ))
+
+atomic_write_loop() {
+	local off=0
+	local size=$awu_max
+	for ((i=0; i<$((filesize / $size )); i++)); do
+		# Due to sudden shutdown this can produce errors so just redirect them
+		# to seqres.full
+		$XFS_IO_PROG -c "open -fsd $testfile" -c "pwrite -S 0x61 -DA -V1 -b $size $off $size" >> /dev/null 2>>$seqres.full
+		echo "Written to offset: $off" >> $tmp.aw
+		off=$((off + $size))
+	done
+}
+
+create_mixed_mappings() {
+	local file=$1
+	local size_bytes=$2
+
+	echo "# Filling file $file with alternate mappings till size $size_bytes" >> $seqres.full
+	#Fill the file with alternate written and unwritten blocks
+	local off=0
+	local operations=("W" "U")
+
+	for ((i=0; i<$((size_bytes / blksz )); i++)); do
+		index=$(($i % ${#operations[@]}))
+		map="${operations[$index]}"
+
+		case "$map" in
+		    "W")
+			$XFS_IO_PROG -fc "pwrite -b $blksz $off $blksz" $file  >> /dev/null
+			;;
+		    "U")
+			$XFS_IO_PROG -fc "falloc $off $blksz" $file >> /dev/null
+			;;
+		esac
+		off=$((off + blksz))
+	done
+
+	sync $file
+}
+
+populate_expected_data() {
+	# create a dummy file with expected old data for different cases
+	create_mixed_mappings $testfile.exp_old_mixed $awu_max
+	expected_data_old_mixed=$(xxd -s 0 -l $awu_max -p $testfile.exp_old_mixed)
+
+	$XFS_IO_PROG -fc "falloc 0 $awu_max" $testfile.exp_old_zeroes >> $seqres.full
+	expected_data_old_zeroes=$(xxd -s 0 -l $awu_max -p $testfile.exp_old_zeroes)
+
+	$XFS_IO_PROG -fc "pwrite -b $awu_max 0 $awu_max" $testfile.exp_old_mapped >> $seqres.full
+	expected_data_old_mapped=$(xxd -s 0 -l $awu_max -p $testfile.exp_old_mapped)
+
+	# create a dummy file with expected new data
+	$XFS_IO_PROG -fc "pwrite -S 0x61 -b $awu_max 0 $awu_max" $testfile.exp_new >> $seqres.full
+	expected_data_new=$(xxd -s 0 -l $awu_max -p $testfile.exp_new)
+}
+
+verify_data_blocks() {
+	local verify_start=$1
+	local verify_end=$2
+	local expected_data_old="$3"
+	local expected_data_new="$4"
+
+	echo >> $seqres.full
+	echo "# Checking data integrity from $verify_start to $verify_end" >> $seqres.full
+
+	# After an atomic write, for every chunk we ensure that the underlying
+	# data is either the old data or new data as writes shouldn't get torn.
+	local off=$verify_start
+	while [[ "$off" -lt "$verify_end" ]]
+	do
+		actual_data=$(xxd -s $off -l $awu_max -p $testfile)
+		if [[ "$actual_data" != "$expected_data_new" ]] && [[ "$actual_data" != "$expected_data_old" ]]
+		then
+			echo "Checksum match failed at off: $off size: $awu_max"
+			echo "Expected contents: (Either of the 2 below):"
+			echo
+			echo "Expected old: "
+			echo "$expected_data_old"
+			echo
+			echo "Expected new: "
+			echo "$expected_data_new"
+			echo
+			echo "Actual contents: "
+			echo "$actual_data"
+
+			return 1
+		fi
+		echo -n "Check at offset $off suceeded! " >> $seqres.full
+		if [[ "$actual_data" == "$expected_data_new" ]]
+		then
+			echo "matched new" >> $seqres.full
+		elif [[ "$actual_data" == "$expected_data_old" ]]
+		then
+			echo "matched old" >> $seqres.full
+		fi
+		off=$(( off + awu_max ))
+	done
+
+	return 0
+}
+
+# test data integrity for file by shutting down in between atomic writes
+test_data_integrity() {
+	echo >> $seqres.full
+	echo "# Writing atomically to file in background" >> $seqres.full
+	atomic_write_loop &
+	awloop_pid=$!
+
+	# Wait for atleast first write to be recorded
+	while [ ! -f "$tmp.aw" ]; do sleep 0.2; done
+
+	echo >> $seqres.full
+	echo "# Shutting down filesystem while write is running" >> $seqres.full
+	_scratch_shutdown
+
+	kill $awloop_pid
+	wait $awloop_pid
+
+	last_offset=$(tail -n 1 $tmp.aw | cut -d" " -f4)
+	cat $tmp.aw >> $seqres.full
+	echo >> $seqres.full
+	echo "# Last offset of atomic write: $last_offset" >> $seqres.full
+
+	rm $tmp.aw
+	sleep 0.5
+
+	_scratch_cycle_mount
+
+	# we want to verify all blocks around which the shutdown happended
+	verify_start=$(( last_offset - (awu_max * 5)))
+	if [[ $verify_start < 0 ]]
+	then
+		verify_start=0
+	fi
+
+	verify_end=$(( last_offset + (awu_max * 5)))
+	if [[ "$verify_end" -gt "$filesize" ]]
+	then
+		verify_end=$filesize
+	fi
+}
+
+# test data integrity for file wiht written and unwritten mappings
+test_data_integrity_mixed() {
+	$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Creating testfile with mixed mappings" >> $seqres.full
+	create_mixed_mappings $testfile $filesize
+
+	test_data_integrity
+
+	verify_data_blocks $verify_start $verify_end "$expected_data_old_mixed" "$expected_data_new"
+
+	if [[ "$?" == "1" ]]
+	then
+		return 1
+	fi
+}
+
+# test data integrity for file with completely written mappings
+test_data_integrity_writ() {
+	$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Creating testfile with fully written mapping" >> $seqres.full
+	$XFS_IO_PROG -c "pwrite -b $filesize 0 $filesize" $testfile >> $seqres.full
+	sync $testfile
+
+	test_data_integrity
+
+	verify_data_blocks $verify_start $verify_end "$expected_data_old_mapped" "$expected_data_new"
+
+	if [[ "$?" == "1" ]]
+	then
+		return 1
+	fi
+}
+
+# test data integrity for file with completely unwritten mappings
+test_data_integrity_unwrit() {
+	$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Creating testfile with fully unwritten mappings" >> $seqres.full
+	$XFS_IO_PROG -c "falloc 0 $filesize" $testfile >> $seqres.full
+	sync $testfile
+
+	test_data_integrity
+
+	verify_data_blocks $verify_start $verify_end "$expected_data_old_zeroes" "$expected_data_new"
+
+	if [[ "$?" == "1" ]]
+	then
+		return 1
+	fi
+}
+
+# test data integrity for file with no mappings
+test_data_integrity_hole() {
+	$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Creating testfile with no mappings" >> $seqres.full
+	$XFS_IO_PROG -c "truncate $filesize" $testfile >> $seqres.full
+	sync $testfile
+
+	test_data_integrity
+
+	verify_data_blocks $verify_start $verify_end "$expected_data_old_zeroes" "$expected_data_new"
+
+	if [[ "$?" == "1" ]]
+	then
+		return 1
+	fi
+}
+
+test_filesize_integrity() {
+	$XFS_IO_PROG -c "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Performing extending atomic writes over file in background" >> $seqres.full
+	atomic_write_loop &
+	awloop_pid=$!
+
+	# Wait for atleast first write to be recorded
+	while [ ! -f "$tmp.aw" ]; do sleep 0.2; done
+
+	echo >> $seqres.full
+	echo "# Shutting down filesystem while write is running" >> $seqres.full
+	_scratch_shutdown
+
+	kill $awloop_pid
+	wait $awloop_pid
+
+	local last_offset=$(tail -n 1 $tmp.aw | cut -d" " -f4)
+	cat $tmp.aw >> $seqres.full
+	echo >> $seqres.full
+	echo "# Last offset of atomic write: $last_offset" >> $seqres.full
+	rm $tmp.aw
+	sleep 0.5
+
+	_scratch_cycle_mount
+	local filesize=$(_get_filesize $testfile)
+	echo >> $seqres.full
+	echo "# Filesize after shutdown: $filesize" >> $seqres.full
+
+	# To confirm that the write went atomically, we check:
+	# 1. The last block should be a multiple of awu_max
+	# 2. The last block should be the completely new data
+
+	if (( $filesize % $awu_max ))
+	then
+		echo "Filesize after shutdown ($filesize) not a multiple of atomic write unit ($awu_max)"
+	fi
+
+	verify_start=$(( filesize - (awu_max * 5)))
+	if [[ $verify_start < 0 ]]
+	then
+		verify_start=0
+	fi
+
+	local verify_end=$filesize
+
+	# Here the blocks should always match new data hence, for simplicity of
+	# code, just corrupt the $expected_data_old buffer so it never matches
+	local expected_data_old="POISON"
+	verify_data_blocks $verify_start $verify_end "$expected_data_old" "$expected_data_new"
+
+	return $?
+}
+
+$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+echo >> $seqres.full
+echo "# Populating expected data buffers" >> $seqres.full
+populate_expected_data
+
+# Loop 20 times to shake out any races due to shutdown
+for ((iter=0; iter<20; iter++))
+do
+	echo >> $seqres.full
+	echo "------ Iteration $iter ------" >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over mixed mapping" >> $seqres.full
+	test_data_integrity_mixed
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over fully written mapping" >> $seqres.full
+	test_data_integrity_writ
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over fully unwritten mapping" >> $seqres.full
+	test_data_integrity_unwrit
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over holes" >> $seqres.full
+	test_data_integrity_hole
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+
+	echo >> $seqres.full
+	echo "# Starting filesize integrity test for atomic writes" >> $seqres.full
+	test_filesize_integrity
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+done
+
+echo "Silence is golden"
+status=0
+exit

tests/generic/772.out new file +2 -0

new file mode 100644
index 00000000..98c13968
@@ -0,0 +1,2 @@
+QA output created by 772
+Silence is golden

Signature · 1 line

2.49.0

Quoted 6 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)" <[email protected]>

Insert range and collapse range only works with bigalloc in case the range is cluster size aligned, which fsx doesnt take care. To work past this, disable insert range and collapse range on ext4, if bigalloc is enabled.

Hmmm, insert/collapse-range have the same behavior on xfs realtime, maybe we should amend test() in fsx to round to the allocation unit size?

Querying that programmatically might be ... interesting though. Is there a good way to do that for ext4 bigalloc?

(See detect_xfs_alloc_unit in punch-alternating.c)

--D

Quoted 46 lines

This is achieved by defining a new function _setup_fs_options which can serve as a mechanism to apply FS-wide options to the tests.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 common/preamble | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

common/preamble +16 -0

index ba029a34..2bccff74 100644
@@ -24,6 +24,20 @@ _register_cleanup()
 	trap "${cleanup}exit \$status" EXIT HUP INT QUIT TERM $*
 }
 
+# setup FS options only to be available for each test run
+_setup_fs_options() {
+	case "$FSTYP" in
+	"ext4")
+		if [[ "$MKFS_OPTIONS" =~ bigalloc ]]; then
+			export FSX_AVOID="-I -C"
+		fi
+		;;
+	# Add other filesystem types here as needed
+	*)
+		;;
+	esac
+}
+
 # Prepare to run a fstest by initializing the required global variables to
 # their defaults, sourcing common functions, registering a cleanup function,
 # and removing the $seqres.full file.

@@ -55,4 +69,6 @@ _begin_fstest()
 	# remove previous $seqres.full before test
 	rm -f $seqres.full $seqres.hints
 
+	# setup filesystem options for a given test execution
+	_setup_fs_options
 }

Signature · 1 line

2.49.0

Quoted 26 lines · Ojaswin Mujoo

Currently run_fsx is hardcoded to run on a file in $TEST_DIR. Add a helper _run_fsx_on_file so that we can run fsx on any given file including in $SCRATCH_MNT. Also, refactor _run_fsx to use this helper.

No functional change is intended in this patch.

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 common/rc | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

common/rc +4 -1

index cfbe2a5f..a5d811a1 100644
@@ -5115,13 +5115,22 @@ _require_hugepage_fsx()
 		_notrun "fsx binary does not support MADV_COLLAPSE"
 }
 
-_run_fsx()
+_run_fsx_on_file()
 {
+	local testfile=$1
+	shift
+

common/rc _require_hugepage_fsx() · line 5131

Quoted 10 lines

common/rc +7 -1

+	if ! [ -f $testfile ]
+	then
+		echo "_run_fsx_on_file: $testfile doesn't exist. Creating" >> $seqres.full
+		touch $testfile
+	fi
+
 	echo "fsx $*"
 	local args=`echo $@ | sed -e "s/ BSIZE / $bsize /g" -e "s/ PSIZE / $psize /g"`
-	set -- $FSX_PROG $args $FSX_AVOID $TEST_DIR/junk
+	set -- $FSX_PROG $args $FSX_AVOID $testfile

	local testfile="${1:-$TEST_DIR/junk}"
	...
	set -- $FSX_PROG $args $FSX_AVOID $testfile

Then you don't need the extra helper.

--D

Quoted 23 lines

common/rc +7 -1

 	echo "$@" >>$seqres.full
-	rm -f $TEST_DIR/junk
+	rm -f $testfile
 	"$@" 2>&1 | tee -a $seqres.full >$tmp.fsx
 	local res=${PIPESTATUS[0]}
 	if [ $res -ne 0 ]; then

@@ -5133,6 +5142,12 @@ _run_fsx()
 	return 0
 }
 
+_run_fsx()
+{
+	_run_fsx_on_file $TEST_DIR/junk $@
+	return $?
+}
+
 # Run fsx with -h(ugepage buffers).  If we can't set up a hugepage then skip
 # the test, but if any other error occurs then exit the test.
 _run_hugepage_fsx() {

Signature · 1 line

2.49.0

Quoted 6 lines · Ojaswin Mujoo

Implement atomic write support to help fuzz atomic writes with fsx.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---

Quoted 5 lines

ltp/fsx.c +1 -0

+
 #ifdef HAVE_COPY_FILE_RANGE
 int
 test_copy_range(void)

ltp/fsx.c have_op: · line 2474

Quoted 9 lines

ltp/fsx.c +6 -0

@@ -2385,6 +2466,14 @@ have_op:
 			dowrite(offset, size, 0);
 		break;
 
+	case OP_WRITE_ATOMIC:
+		TRIM_OFF_LEN(offset, size, maxfilelen);
+		if (do_atomic_writes)
+			dowrite(offset, size, RWF_ATOMIC);
+		else
+			dowrite(offset, size, 0);

Er.... shouldn't we skip OP_ATOMIC_WRITE if !do_atomic_writes? There's a whole switch statement further up in test() that does things like:

	case OP_COPY_RANGE:
		if (!copy_range_calls) {
			log5(op, offset, size, offset2, FL_SKIPPED);
			goto out;
		}
		break;

to break out early.

--D

Quoted 46 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)" <[email protected]>

This adds atomic write test using fio based on it's crc check verifier. fio adds a crc for each data block. If the underlying device supports atomic write then it is guaranteed that we will never have a mix data from two threads writing on the same physical block.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/767     | 84 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/767.out |  2 ++
 2 files changed, 86 insertions(+)
 create mode 100755 tests/generic/767
 create mode 100644 tests/generic/767.out

tests/generic/767 new file +24 -0

new file mode 100755
index 00000000..4f80e7b6
@@ -0,0 +1,84 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 767
+#
+# Validate FS atomic write using fio crc check verifier.
+#
+. ./common/preamble
+. ./common/atomicwrites
+
+_begin_fstest auto aio rw atomicwrites
+
+_require_scratch_write_atomic
+_require_odirect
+_require_aio
+
+function max()
+{
+	if (( $1 > $2 )); then
+		echo "$1"
+	else
+		echo "$2"
+	fi

tests/generic/767 line 34

Quoted 10 lines

tests/generic/767 new file +10 -0

+}
+
+function min()
+{
+	if (( $1 > $2 )); then
+		echo "$2"
+	else
+		echo "$1"
+	fi
+}

Should these be common/rc helpers?

Or, since bash is ... uh fun with arguments...

_min() {
	local ret

	for arg in "$@"; do
		if [ -z "$ret" ] || (( $arg < $ret )); then
			ret="$arg"
		fi
	done
	echo $ret
}

and then you can pass as many arguments as you like. The only downside is that you can pass stringly typed crap "_min cow frog" and it still returns "cow". As if.

Quoted 10 lines

tests/generic/767 new file +9 -0

+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount
+
+touch "$SCRATCH_MNT/f1"
+awu_min_write=$(_get_atomic_write_unit_min "$SCRATCH_MNT/f1")
+awu_max_write=$(_get_atomic_write_unit_max "$SCRATCH_MNT/f1")
+blocksize=$(max "$awu_min_write" "$((awu_max_write/2))")
+
+# XFS can have high awu_max_write due to software fallback. Cap it at 64k

tests/generic/767 line 50

Quoted 6 lines

tests/generic/767 new file +6 -0

+blocksize=$(min "$blocksize" "65536")
+
+fio_config=$tmp.fio
+fio_out=$tmp.fio.out
+
+FIO_LOAD=$(($(nproc) * 2 * LOAD_FACTOR))

What program is nproc?

--D

Quoted 46 lines

tests/generic/767 new file +34 -0

+SIZE=$((100 * 1024 * 1024))
+
+cat >$fio_config <<EOF
+[aio-dio-aw-verify]
+direct=1
+ioengine=libaio
+rw=randwrite
+bs=$blocksize
+fallocate=native
+filename=$SCRATCH_MNT/test-file
+size=$SIZE
+iodepth=$FIO_LOAD
+numjobs=$FIO_LOAD
+group_reporting=1
+verify_state_save=0
+verify=crc32c
+verify_fatal=1
+verify_dump=0
+verify_backlog=1024
+verify_async=4
+verify_write_sequence=0
+atomic=1
+EOF
+
+_require_fio $fio_config
+
+cat $fio_config >> $seqres.full
+$FIO_PROG $fio_config --output=$fio_out
+cat $fio_out >> $seqres.full
+
+# success, all done
+echo Silence is golden
+status=0
+exit

tests/generic/767.out new file +2 -0

new file mode 100644
index 00000000..2bf7f989
@@ -0,0 +1,2 @@
+QA output created by 767
+Silence is golden

Signature · 1 line

2.49.0

Quoted 24 lines · Ojaswin Mujoo

This adds various atomic write multi-fsblock stresst tests with mixed mappings and O_SYNC, to ensure the data and metadata is atomically persisted even if there is a shutdown.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/770     | 161 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/770.out |   2 +
 2 files changed, 163 insertions(+)
 create mode 100755 tests/generic/770
 create mode 100644 tests/generic/770.out

tests/generic/770 new file +5 -0

new file mode 100755
index 00000000..2b98b3b3
@@ -0,0 +1,161 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 770

tests/generic/770 line 15

Quoted 10 lines

tests/generic/770 new file +10 -0

+#
+# Atomic write multi-fsblock data integrity tests with mixed mappings
+# and O_SYNC
+#
+. ./common/preamble
+. ./common/atomicwrites
+_begin_fstest auto quick rw atomicwrites
+
+_require_scratch_write_atomic_multi_fsblock
+_require_atomic_write_test_commands

_require_shutdown?

--D

Quoted 52 lines · Ojaswin Mujoo

Stress file with atomic writes to ensure we excercise codepaths where we are mixing different FS operations with atomic writes

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/771     | 49 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/771.out |  2 ++
 2 files changed, 51 insertions(+)
 create mode 100755 tests/generic/771
 create mode 100644 tests/generic/771.out

tests/generic/771 new file +34 -0

new file mode 100755
index 00000000..690dfa0a
@@ -0,0 +1,49 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 771
+#
+# fuzz fsx with atomic writes
+#
+. ./common/preamble
+. ./common/atomicwrites
+_begin_fstest rw auto quick atomicwrites
+
+# Import common functions.
+. ./common/filter
+
+_require_test
+_require_odirect
+_require_scratch_write_atomic
+
+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount  >> $seqres.full 2>&1
+
+testfile=$SCRATCH_MNT/testfile
+touch $testfile
+
+awu_max=$(_get_atomic_write_unit_max $testfile)
+blksz=$(_get_block_size $SCRATCH_MNT)
+bsize=`$here/src/min_dio_alignment $SCRATCH_MNT $SCRATCH_DEV`
+
+# fsx usage:
+#
+# -N numops: total # operations to do
+# -l flen: the upper bound on file size
+# -o oplen: the upper bound on operation size (64k default)

tests/generic/771 line 39

Quoted 5 lines

tests/generic/771 new file +5 -0

+# -w writebdy: $psize would make writes page aligned (on i386)
+# -Z: O_DIRECT (use -R, -W, -r and -w too)
+# -W: mapped write operations DISabled
+
+_run_fsx_on_file $testfile -N 10000 -a -o $awu_max  -l 500000 -r $bsize -w $bsize -Z -W $FSX_AVOID >> $seqres.full

Don't we already get fsx stress testing RWF_ATOMIC through generic/521 and generic/522?

Also why is mmap write disabled?

--D

Quoted 22 lines

tests/generic/771 new file +10 -0

+status=$?
+
+if [[ "$status" != "0" ]]
+then
+	echo "Somthing went wrong, check $seqres.full"
+fi
+
+echo "Silence is golden"
+status=0
+exit

tests/generic/771.out new file +2 -0

new file mode 100644
index 00000000..c2345c7b
@@ -0,0 +1,2 @@
+QA output created by 771
+Silence is golden

Signature · 1 line

2.49.0

Quoted 22 lines · Ojaswin Mujoo

This test is intended to ensure that multi blocks atomic writes maintain atomic guarantees across sudden FS shutdowns.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/772     | 360 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/772.out |   2 +
 2 files changed, 362 insertions(+)
 create mode 100755 tests/generic/772
 create mode 100644 tests/generic/772.out

tests/generic/772 new file +4 -0

new file mode 100755
index 00000000..6af7e74c
@@ -0,0 +1,360 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#

tests/generic/772 line 14

Quoted 10 lines

tests/generic/772 new file +10 -0

+# FS QA Test 0772
+#
+# Test multi block atomic writes with sudden FS shutdowns to ensure
+# the FS is not tearing the write operation
+. ./common/preamble
+. ./common/atomicwrites
+_begin_fstest auto atomicwrites
+
+_require_scratch_write_atomic_multi_fsblock
+_require_atomic_write_test_commands

_require_shutdown?

Otherwise seems fine to me...

--D

From: "Ritesh Harjani (IBM)"<[email protected]>

Brute force all possible blocksize clustersize combination on a bigalloc filesystem for stressing atomic write using fio data crc verifier. We run multiple threads in parallel with each job writing to its own file. The parallel jobs running on a constrained filesystem size ensure that we stress the ext4 allocator to allocate contiguous extents.

Signed-off-by Ritesh Harjani (IBM)<[email protected]>

Signed-off-by Ojaswin Mujoo<[email protected]>

Quoted 42 lines · Darrick J. Wong

Quoted 26 lines · Ojaswin Mujoo

Currently run_fsx is hardcoded to run on a file in $TEST_DIR. Add a helper _run_fsx_on_file so that we can run fsx on any given file including in $SCRATCH_MNT. Also, refactor _run_fsx to use this helper.

No functional change is intended in this patch.

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 common/rc | 21 ++++++++++++++++++---
 1 file changed, 18 insertions(+), 3 deletions(-)

common/rc +4 -1

index cfbe2a5f..a5d811a1 100644
@@ -5115,13 +5115,22 @@ _require_hugepage_fsx()
 		_notrun "fsx binary does not support MADV_COLLAPSE"
 }
 
-_run_fsx()
+_run_fsx_on_file()
 {
+	local testfile=$1
+	shift
+

common/rc _require_hugepage_fsx() · line 5131

Quoted 10 lines

common/rc +7 -1

+	if ! [ -f $testfile ]
+	then
+		echo "_run_fsx_on_file: $testfile doesn't exist. Creating" >> $seqres.full
+		touch $testfile
+	fi
+
 	echo "fsx $*"
 	local args=`echo $@ | sed -e "s/ BSIZE / $bsize /g" -e "s/ PSIZE / $psize /g"`
-	set -- $FSX_PROG $args $FSX_AVOID $TEST_DIR/junk
+	set -- $FSX_PROG $args $FSX_AVOID $testfile

	local testfile="${1:-$TEST_DIR/junk}"
	...
	set -- $FSX_PROG $args $FSX_AVOID $testfile

Quoted 1 line

Then you don't need the extra helper.

Hi Darrick,

I originally added the extra helper so that we won't need to change the existing run_fsx calls. For example, with the change you suggested, generic/263 would need to be changed from:

run_fsx -N 10000 -o 8192 -l 500000 -r PSIZE -t BSIZE -w BSIZE -Z

to

run_fsx $TEST_DIR/junk -N 10000 -o 8192 -l 500000 -r PSIZE -t BSIZE -w BSIZE -Z

because otherwise, the $1 would actually be "-N" and run_fsx would get confused.

However, if you would prefer to drop the helper and rather modify run_fsx and the call sites to pass a filename, that should be doable as well. Please let me know your preference on this.

Regards,
ojaswin

Quoted 26 lines

--D

Quoted 23 lines

common/rc +7 -1

 	echo "$@" >>$seqres.full
-	rm -f $TEST_DIR/junk
+	rm -f $testfile
 	"$@" 2>&1 | tee -a $seqres.full >$tmp.fsx
 	local res=${PIPESTATUS[0]}
 	if [ $res -ne 0 ]; then

@@ -5133,6 +5142,12 @@ _run_fsx()
 	return 0
 }
 
+_run_fsx()
+{
+	_run_fsx_on_file $TEST_DIR/junk $@
+	return $?
+}
+
 # Run fsx with -h(ugepage buffers).  If we can't set up a hugepage then skip
 # the test, but if any other error occurs then exit the test.
 _run_hugepage_fsx() {

Signature · 1 line

2.49.0

Quoted 8 lines · Darrick J. Wong

Quoted 6 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)" <[email protected]>

Insert range and collapse range only works with bigalloc in case the range is cluster size aligned, which fsx doesnt take care. To work past this, disable insert range and collapse range on ext4, if bigalloc is enabled.

Quoted 3 lines

Hmmm, insert/collapse-range have the same behavior on xfs realtime, maybe we should amend test() in fsx to round to the allocation unit size?

Hey Darrick,

Yes makes sense but as you mentioned, I'm not sure if there is a way to programatically detect the bigalloc cluster size (or allocation unit in general) like we do for xfs.

(Adding Ted to CC in case he has some idea)

Quoted 54 lines

Querying that programmatically might be ... interesting though. Is there a good way to do that for ext4 bigalloc?

(See detect_xfs_alloc_unit in punch-alternating.c)

--D

Quoted 46 lines

This is achieved by defining a new function _setup_fs_options which can serve as a mechanism to apply FS-wide options to the tests.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 common/preamble | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

common/preamble +16 -0

index ba029a34..2bccff74 100644
@@ -24,6 +24,20 @@ _register_cleanup()
 	trap "${cleanup}exit \$status" EXIT HUP INT QUIT TERM $*
 }
 
+# setup FS options only to be available for each test run
+_setup_fs_options() {
+	case "$FSTYP" in
+	"ext4")
+		if [[ "$MKFS_OPTIONS" =~ bigalloc ]]; then
+			export FSX_AVOID="-I -C"
+		fi
+		;;
+	# Add other filesystem types here as needed
+	*)
+		;;
+	esac
+}
+
 # Prepare to run a fstest by initializing the required global variables to
 # their defaults, sourcing common functions, registering a cleanup function,
 # and removing the $seqres.full file.

@@ -55,4 +69,6 @@ _begin_fstest()
 	# remove previous $seqres.full before test
 	rm -f $seqres.full $seqres.hints
 
+	# setup filesystem options for a given test execution
+	_setup_fs_options
 }

Signature · 1 line

2.49.0

Quoted 73 lines · Darrick J. Wong

Quoted 46 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)" <[email protected]>

This adds atomic write test using fio based on it's crc check verifier. fio adds a crc for each data block. If the underlying device supports atomic write then it is guaranteed that we will never have a mix data from two threads writing on the same physical block.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/767     | 84 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/767.out |  2 ++
 2 files changed, 86 insertions(+)
 create mode 100755 tests/generic/767
 create mode 100644 tests/generic/767.out

tests/generic/767 new file +24 -0

new file mode 100755
index 00000000..4f80e7b6
@@ -0,0 +1,84 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 767
+#
+# Validate FS atomic write using fio crc check verifier.
+#
+. ./common/preamble
+. ./common/atomicwrites
+
+_begin_fstest auto aio rw atomicwrites
+
+_require_scratch_write_atomic
+_require_odirect
+_require_aio
+
+function max()
+{
+	if (( $1 > $2 )); then
+		echo "$1"
+	else
+		echo "$2"
+	fi

tests/generic/767 line 34

Quoted 10 lines

tests/generic/767 new file +10 -0

+}
+
+function min()
+{
+	if (( $1 > $2 )); then
+		echo "$2"
+	else
+		echo "$1"
+	fi
+}

Should these be common/rc helpers?

Or, since bash is ... uh fun with arguments...

_min() {
	local ret

	for arg in "$@"; do
		if [ -z "$ret" ] || (( $arg < $ret )); then
			ret="$arg"
		fi
	done
	echo $ret
}

Quoted 3 lines

and then you can pass as many arguments as you like. The only downside is that you can pass stringly typed crap "_min cow frog" and it still returns "cow". As if.

Yes this makes sense (sans the cow vs frog part :p) . I'll make the change in v2.

Quoted 10 lines

Quoted 10 lines

tests/generic/767 new file +9 -0

+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount
+
+touch "$SCRATCH_MNT/f1"
+awu_min_write=$(_get_atomic_write_unit_min "$SCRATCH_MNT/f1")
+awu_max_write=$(_get_atomic_write_unit_max "$SCRATCH_MNT/f1")
+blocksize=$(max "$awu_min_write" "$((awu_max_write/2))")
+
+# XFS can have high awu_max_write due to software fallback. Cap it at 64k

Quoted 8 lines

tests/generic/767 line 50

Quoted 6 lines

tests/generic/767 new file +6 -0

+blocksize=$(min "$blocksize" "65536")
+
+fio_config=$tmp.fio
+fio_out=$tmp.fio.out
+
+FIO_LOAD=$(($(nproc) * 2 * LOAD_FACTOR))

What program is nproc?

It returns the number of CPUs so we can scale the load based on CPUs we have. It comes from coreutils so I think the distros should have it.

Thanks,
ojaswin

Quoted 49 lines

--D

Quoted 46 lines

tests/generic/767 new file +34 -0

+SIZE=$((100 * 1024 * 1024))
+
+cat >$fio_config <<EOF
+[aio-dio-aw-verify]
+direct=1
+ioengine=libaio
+rw=randwrite
+bs=$blocksize
+fallocate=native
+filename=$SCRATCH_MNT/test-file
+size=$SIZE
+iodepth=$FIO_LOAD
+numjobs=$FIO_LOAD
+group_reporting=1
+verify_state_save=0
+verify=crc32c
+verify_fatal=1
+verify_dump=0
+verify_backlog=1024
+verify_async=4
+verify_write_sequence=0
+atomic=1
+EOF
+
+_require_fio $fio_config
+
+cat $fio_config >> $seqres.full
+$FIO_PROG $fio_config --output=$fio_out
+cat $fio_out >> $seqres.full
+
+# success, all done
+echo Silence is golden
+status=0
+exit

tests/generic/767.out new file +2 -0

new file mode 100644
index 00000000..2bf7f989
@@ -0,0 +1,2 @@
+QA output created by 767
+Silence is golden

Signature · 1 line

2.49.0

Quoted 53 lines · Darrick J. Wong

Quoted 52 lines · Ojaswin Mujoo

Stress file with atomic writes to ensure we excercise codepaths where we are mixing different FS operations with atomic writes

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/771     | 49 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/771.out |  2 ++
 2 files changed, 51 insertions(+)
 create mode 100755 tests/generic/771
 create mode 100644 tests/generic/771.out

tests/generic/771 new file +34 -0

new file mode 100755
index 00000000..690dfa0a
@@ -0,0 +1,49 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 771
+#
+# fuzz fsx with atomic writes
+#
+. ./common/preamble
+. ./common/atomicwrites
+_begin_fstest rw auto quick atomicwrites
+
+# Import common functions.
+. ./common/filter
+
+_require_test
+_require_odirect
+_require_scratch_write_atomic
+
+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount  >> $seqres.full 2>&1
+
+testfile=$SCRATCH_MNT/testfile
+touch $testfile
+
+awu_max=$(_get_atomic_write_unit_max $testfile)
+blksz=$(_get_block_size $SCRATCH_MNT)
+bsize=`$here/src/min_dio_alignment $SCRATCH_MNT $SCRATCH_DEV`
+
+# fsx usage:
+#
+# -N numops: total # operations to do
+# -l flen: the upper bound on file size
+# -o oplen: the upper bound on operation size (64k default)

Quoted 8 lines

tests/generic/771 line 39

Quoted 5 lines

tests/generic/771 new file +5 -0

+# -w writebdy: $psize would make writes page aligned (on i386)
+# -Z: O_DIRECT (use -R, -W, -r and -w too)
+# -W: mapped write operations DISabled
+
+_run_fsx_on_file $testfile -N 10000 -a -o $awu_max  -l 500000 -r $bsize -w $bsize -Z -W $FSX_AVOID >> $seqres.full

Don't we already get fsx stress testing RWF_ATOMIC through generic/521 and generic/522?

So for RWF_ATOMIC we need to pass the -a flag to fsx which the other tests don't do. This test specifically passes -a to make sure we stress the RWF_ATOMIC code path intermixed with other operations. Further, other tests run FSX on test device whereas for our atomic write tests we generally assume the scratch dev is the one with atomic capabilities.

Quoted 1 line

Also why is mmap write disabled?

I thought it'd be better to not mix mmap writes with direct writes but I can add it back if that's preferred.

Regards,
ojaswin

Quoted 25 lines

--D

Quoted 22 lines

tests/generic/771 new file +10 -0

+status=$?
+
+if [[ "$status" != "0" ]]
+then
+	echo "Somthing went wrong, check $seqres.full"
+fi
+
+echo "Silence is golden"
+status=0
+exit

tests/generic/771.out new file +2 -0

new file mode 100644
index 00000000..c2345c7b
@@ -0,0 +1,2 @@
+QA output created by 771
+Silence is golden

Signature · 1 line

2.49.0

Quoted 2 lines · Ojaswin Mujoo

Quoted 1 line · Darrick J. Wong

On Wed, Jun 11, 2025 at 03:04:50PM +0530, Ojaswin Mujoo wrote:

Quoted 12 lines

Quoted 11 lines

tests/generic/771 line 39

Quoted 8 lines

tests/generic/771 new file +8 -0

+# -N numops: total # operations to do
+# -l flen: the upper bound on file size
+# -o oplen: the upper bound on operation size (64k default)
+# -w writebdy: $psize would make writes page aligned (on i386)
+# -Z: O_DIRECT (use -R, -W, -r and -w too)
+# -W: mapped write operations DISabled
+
+_run_fsx_on_file $testfile -N 10000 -a -o $awu_max  -l 500000 -r $bsize -w $bsize -Z -W $FSX_AVOID >> $seqres.full

Don't we already get fsx stress testing RWF_ATOMIC through generic/521 and generic/522?

Quoted 5 lines

So for RWF_ATOMIC we need to pass the -a flag to fsx which the other tests don't do. This test specifically passes -a to make sure we stress the RWF_ATOMIC code path intermixed with other operations. Further, other tests run FSX on test device whereas for our atomic write tests we generally assume the scratch dev is the one with atomic capabilities.

Oh, I overlooked the part where it's not enabled by default if its presence can be detected by fsx. Can we flip the polarity of -a, that way RWF_ATOMIC will get tested with all the other fsx soak tests?

Quoted 5 lines

Quoted 2 lines

Also why is mmap write disabled?

I thought it'd be better to not mix mmap writes with direct writes but I can add it back if that's preferred.

It's not unreasonable that some dumb program is going to try that some day, even though we all scream for ice crea^W^W^Wnot to mix the two IO paths.

--D

Quoted 28 lines

Regards,
ojaswin

Quoted 25 lines

--D

Quoted 22 lines

tests/generic/771 new file +10 -0

+status=$?
+
+if [[ "$status" != "0" ]]
+then
+	echo "Somthing went wrong, check $seqres.full"
+fi
+
+echo "Silence is golden"
+status=0
+exit

tests/generic/771.out new file +2 -0

new file mode 100644
index 00000000..c2345c7b
@@ -0,0 +1,2 @@
+QA output created by 771
+Silence is golden

Signature · 1 line

2.49.0

Quoted 14 lines · Ojaswin Mujoo

Quoted 11 lines · Darrick J. Wong

Quoted 6 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)" <[email protected]>

Insert range and collapse range only works with bigalloc in case the range is cluster size aligned, which fsx doesnt take care. To work past this, disable insert range and collapse range on ext4, if bigalloc is enabled.

Hmmm, insert/collapse-range have the same behavior on xfs realtime, maybe we should amend test() in fsx to round to the allocation unit size?

Hey Darrick,

Quoted 3 lines

Yes makes sense but as you mentioned, I'm not sure if there is a way to programatically detect the bigalloc cluster size (or allocation unit in general) like we do for xfs.

I don't either, but maybe we should have a way reveal the allocation unit size for a given file? Yet another statx field? :P

(It /would/ be useful for programs that use collapse/insert range)

--D

Quoted 8 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)"<[email protected]>

Brute force all possible blocksize clustersize combination on a bigalloc filesystem for stressing atomic write using fio data crc verifier. We run multiple threads in parallel with each job writing to its own file. The parallel jobs running on a constrained filesystem size ensure that we stress the ext4 allocator to allocate contiguous extents.

Quoted 2 lines

Signed-off-by Ritesh Harjani (IBM)<[email protected]>

Signed-off-by Ojaswin Mujoo<[email protected]>

RWF_ATOMIC does not guarantee that racing atomic writes and reads are serialised. That is what you are testing here, right?

NVMe and SCSI do guarantee this (serialisation). However, reads in the block layer may be split into multiple requests, even though unlikely.

Quoted 15 lines · Darrick J. Wong

Quoted 14 lines · Ojaswin Mujoo

Quoted 11 lines · Darrick J. Wong

Quoted 6 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)" <[email protected]>

Insert range and collapse range only works with bigalloc in case the range is cluster size aligned, which fsx doesnt take care. To work past this, disable insert range and collapse range on ext4, if bigalloc is enabled.

Hmmm, insert/collapse-range have the same behavior on xfs realtime, maybe we should amend test() in fsx to round to the allocation unit size?

Hey Darrick,

Quoted 8 lines

Quoted 3 lines

Yes makes sense but as you mentioned, I'm not sure if there is a way to programatically detect the bigalloc cluster size (or allocation unit in general) like we do for xfs.

I don't either, but maybe we should have a way reveal the allocation unit size for a given file? Yet another statx field? :P

(It /would/ be useful for programs that use collapse/insert range)

Yes it would, at the very least, help with defining clear semantics for collapse/insert range with bigalloc/rtvol because right now those operations just EINVAL if the range is not aligned correctly, which is confusing since it is not documented how to do it properly.

xfs does have an ioctl to get the geometry for rtvol. I think you are suggesting a more generic statx field which can be used by other FSes as well, right?

Regards,
ojaswin

Quoted 3 lines

--D

Quoted 25 lines · Ojaswin Mujoo

Quoted 15 lines · Darrick J. Wong

Quoted 14 lines · Ojaswin Mujoo

Quoted 11 lines · Darrick J. Wong

Quoted 6 lines · Ojaswin Mujoo

From: "Ritesh Harjani (IBM)" <[email protected]>

Insert range and collapse range only works with bigalloc in case the range is cluster size aligned, which fsx doesnt take care. To work past this, disable insert range and collapse range on ext4, if bigalloc is enabled.

Hmmm, insert/collapse-range have the same behavior on xfs realtime, maybe we should amend test() in fsx to round to the allocation unit size?

Hey Darrick,

Quoted 8 lines

Quoted 3 lines

Yes makes sense but as you mentioned, I'm not sure if there is a way to programatically detect the bigalloc cluster size (or allocation unit in general) like we do for xfs.

I don't either, but maybe we should have a way reveal the allocation unit size for a given file? Yet another statx field? :P

(It /would/ be useful for programs that use collapse/insert range)

Quoted 8 lines

Yes it would, at the very least, help with defining clear semantics for collapse/insert range with bigalloc/rtvol because right now those operations just EINVAL if the range is not aligned correctly, which is confusing since it is not documented how to do it properly.

xfs does have an ioctl to get the geometry for rtvol. I think you are suggesting a more generic statx field which can be used by other FSes as well, right?

Right, since other filesystems (fat, ntfs, etc) also have allocation units larger than the fsblock size. Most of the time the allocunit amplification simply doesn't matter to applications, but once in a while it does (collapse/insert range, cow) affect performance.

--D

From: "Ritesh Harjani (IBM)" <[email protected]>

Insert range and collapse range only works with bigalloc in case the range is cluster size aligned, which fsx doesnt take care. To work past this, disable insert range and collapse range on ext4, if bigalloc is enabled.

This is achieved by defining a new function _setup_fs_options which can serve as a mechanism to apply FS-wide options to the tests.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 common/preamble | 16 ++++++++++++++++
 1 file changed, 16 insertions(+)

common/preamble +0 -0

index ba029a34..2bccff74 100644

common/preamble +10 -0

+		fi
+		;;
+	# Add other filesystem types here as needed
+	*)
+		;;
+	esac
+}
+
 # Prepare to run a fstest by initializing the required global variables to
 # their defaults, sourcing common functions, registering a cleanup function,
 # and removing the $seqres.full file.

@@ -55,4 +69,6 @@ _begin_fstest()
 	# remove previous $seqres.full before test
 	rm -f $seqres.full $seqres.hints
 
+	# setup filesystem options for a given test execution
+	_setup_fs_options
 }

Signature · 1 line

2.49.0

From: "Ritesh Harjani (IBM)" <[email protected]>

This adds atomic write test using fio based on it's crc check verifier. fio adds a crc for each data block. If the underlying device supports atomic write then it is guaranteed that we will never have a mix data from two threads writing on the same physical block.

Signed-off-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/767     | 84 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/767.out |  2 ++

 2 files changed, 86 insertions(+)
 create mode 100755 tests/generic/767
 create mode 100644 tests/generic/767.out

tests/generic/767 new file +40 -0

new file mode 100755
index 00000000..4f80e7b6
@@ -0,0 +1,84 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 767
+#
+# Validate FS atomic write using fio crc check verifier.
+#
+. ./common/preamble
+. ./common/atomicwrites
+
+_begin_fstest auto aio rw atomicwrites
+
+_require_scratch_write_atomic
+_require_odirect
+_require_aio
+
+function max()
+{
+	if (( $1 > $2 )); then
+		echo "$1"
+	else
+		echo "$2"
+	fi
+}
+
+function min()
+{
+	if (( $1 > $2 )); then
+		echo "$2"
+	else
+		echo "$1"
+	fi
+}
+
+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount
+
+touch "$SCRATCH_MNT/f1"
+awu_min_write=$(_get_atomic_write_unit_min "$SCRATCH_MNT/f1")

tests/generic/767 new file +34 -0

+SIZE=$((100 * 1024 * 1024))
+
+cat >$fio_config <<EOF
+[aio-dio-aw-verify]
+direct=1
+ioengine=libaio
+rw=randwrite
+bs=$blocksize
+fallocate=native
+filename=$SCRATCH_MNT/test-file
+size=$SIZE
+iodepth=$FIO_LOAD
+numjobs=$FIO_LOAD
+group_reporting=1
+verify_state_save=0
+verify=crc32c
+verify_fatal=1
+verify_dump=0
+verify_backlog=1024
+verify_async=4
+verify_write_sequence=0
+atomic=1
+EOF
+
+_require_fio $fio_config
+
+cat $fio_config >> $seqres.full
+$FIO_PROG $fio_config --output=$fio_out
+cat $fio_out >> $seqres.full
+
+# success, all done
+echo Silence is golden
+status=0
+exit

tests/generic/767.out new file +2 -0

new file mode 100644
index 00000000..2bf7f989
@@ -0,0 +1,2 @@
+QA output created by 767
+Silence is golden

Signature · 1 line

2.49.0

This adds various atomic write multi-fsblock stresst tests with mixed mappings and O_SYNC, to ensure the data and metadata is atomically persisted even if there is a shutdown.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/770     | 161 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/770.out |   2 +
 2 files changed, 163 insertions(+)
 create mode 100755 tests/generic/770
 create mode 100644 tests/generic/770.out

tests/generic/770 new file +63 -0

new file mode 100755
index 00000000..2b98b3b3
@@ -0,0 +1,161 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 770
+#
+# Atomic write multi-fsblock data integrity tests with mixed mappings
+# and O_SYNC
+#
+. ./common/preamble
+. ./common/atomicwrites
+_begin_fstest auto quick rw atomicwrites
+
+_require_scratch_write_atomic_multi_fsblock
+_require_atomic_write_test_commands
+
+_scratch_mkfs >> $seqres.full
+_scratch_mount >> $seqres.full
+
+check_data_integrity() {
+	actual=$(_hexdump $testfile)
+	if [[ "$expected" != "$actual" ]]
+	then
+		echo "Integrity check failed"
+		echo "Integrity check failed" >> $seqres.full
+		echo "# Expected file contents:" >> $seqres.full
+		echo "$expected" >> $seqres.full
+		echo "# Actual file contents:" >> $seqres.full
+		echo "$actual" >> $seqres.full
+	fi
+}
+
+testfile=$SCRATCH_MNT/testfile
+touch $testfile
+
+awu_max=$(_get_atomic_write_unit_max $testfile)
+blksz=$(_get_block_size $SCRATCH_MNT)
+
+# Create an expected pattern to compare with
+$XFS_IO_PROG -tc "pwrite -b $awu_max 0 $awu_max" $testfile >> $seqres.full
+expected=$(_hexdump $testfile)
+echo "# Expected file contents:" >> $seqres.full
+echo "$expected" >> $seqres.full
+
+echo "# Test 1: Do O_DSYNC atomic write on random mixed mapping (10 iterations):" >> $seqres.full
+# Calculate how many blocks (e.g. 4K) fit in awu_max (e.g. 64K)
+num_blocks=$((awu_max / blksz))
+echo "Testing $num_blocks blocks of $blksz size within $awu_max region" >> $seqres.full
+
+operations=("W" "H" "U")
+
+# Run 10 iterations of the test
+for ((iteration=1; iteration<=10; iteration++)); do
+	echo "=== Mixed Mapping Test Iteration $iteration ===" >> $seqres.full
+
+	$XFS_IO_PROG -c "truncate 0" $testfile >> $seqres.full
+	off=0
+	mapping=""
+
+	for ((i=0; i<num_blocks; i++)); do
+		index=$((RANDOM % ${#operations[@]}))
+		map="${operations[$index]}"
+		mapping="${mapping}${map}"

tests/generic/770 new file +5 -0

+				  grep wrote | awk -F'[/ ]' '{print $2}')
+
+	test $bytes_written -eq $awu_max || echo "atomic write len=$awu_max failed"
+	check_data_integrity
+	echo "Iteration $iteration completed: OK" >> $seqres.full

tests/generic/770 new file +45 -0

+_scratch_cycle_mount >>$seqres.full 2>&1 || _fail "remount failed for Test-2"
+check_data_integrity
+echo "# Test 2: Do extending O_SYNC atomic writes: OK" >> $seqres.full
+
+echo >> $seqres.full
+echo "# Test 3: Do O_DSYNC atomic write on random mixed mapping with sudden fs shutdown (10 iterations):" >> $seqres.full
+num_blocks=$((awu_max / blksz))
+echo "Testing $num_blocks blocks of $blksz size within $awu_max region" >> $seqres.full
+
+operations=("W" "H" "U")
+
+for ((iteration=1; iteration<=10; iteration++)); do
+	echo "=== Mixed Mapping Shutdown Test Iteration $iteration ===" >> $seqres.full
+
+	$XFS_IO_PROG -c "truncate 0" $testfile >> $seqres.full
+
+	off=0
+	mapping=""
+
+	for ((i=0; i<num_blocks; i++)); do
+		index=$((RANDOM % ${#operations[@]}))
+		map="${operations[$index]}"
+		mapping="${mapping}${map}"
+
+		case "$map" in
+			"W")
+				$XFS_IO_PROG -dc "pwrite -S 0x61 -b $blksz $off $blksz" $testfile > /dev/null
+				;;
+			"H")
+				# No operation needed for hole
+				;;
+			"U")
+				$XFS_IO_PROG -c "falloc $off $blksz" $testfile > /dev/null
+				;;
+		esac
+		off=$((off + blksz))
+	done
+
+	echo "Mixed mapping preparation complete. Full mapping pattern: $mapping" >> $seqres.full
+
+	sync $testfile
+
+	echo "Performing O_DSYNC atomic write over the entire $awu_max region" >> $seqres.full
+	bytes_written=$($XFS_IO_PROG -dc "pwrite -DA -V1 -b $awu_max 0 $awu_max" $testfile | \
+				  grep wrote | awk -F'[/ ]' '{print $2}')

tests/generic/770 new file +7 -0

+echo "# Test 3: Do O_SYNC atomic write on random mixed mapping with sudden fs shutdown (10 iterations): OK" >> $seqres.full
+
+# success, all done
+echo "Silence is golden"
+status=0
+exit
+

tests/generic/770.out new file +2 -0

new file mode 100644
index 00000000..17994ed5
@@ -0,0 +1,2 @@
+QA output created by 770
+Silence is golden

Signature · 1 line

2.49.0

Stress file with atomic writes to ensure we excercise codepaths where we are mixing different FS operations with atomic writes

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/771     | 49 +++++++++++++++++++++++++++++++++++++++++++
 tests/generic/771.out |  2 ++
 2 files changed, 51 insertions(+)
 create mode 100755 tests/generic/771
 create mode 100644 tests/generic/771.out

tests/generic/771 new file +4 -0

new file mode 100755
index 00000000..690dfa0a
@@ -0,0 +1,49 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#

tests/generic/771 new file +1 -0

+exit

tests/generic/771.out new file +2 -0

new file mode 100644
index 00000000..c2345c7b
@@ -0,0 +1,2 @@
+QA output created by 771
+Silence is golden

Signature · 1 line

2.49.0

This test is intended to ensure that multi blocks atomic writes maintain atomic guarantees across sudden FS shutdowns.

Suggested-by Ritesh Harjani (IBM) <[email protected]>

Signed-off-by Ojaswin Mujoo <[email protected]>

---
 tests/generic/772     | 360 ++++++++++++++++++++++++++++++++++++++++++
 tests/generic/772.out |   2 +
 2 files changed, 362 insertions(+)
 create mode 100755 tests/generic/772
 create mode 100644 tests/generic/772.out

tests/generic/772 new file +25 -0

new file mode 100755
index 00000000..6af7e74c
@@ -0,0 +1,360 @@
+#! /bin/bash
+# SPDX-License-Identifier: GPL-2.0
+# Copyright (c) 2025 IBM Corporation. All Rights Reserved.
+#
+# FS QA Test 0772
+#
+# Test multi block atomic writes with sudden FS shutdowns to ensure
+# the FS is not tearing the write operation
+. ./common/preamble
+. ./common/atomicwrites
+_begin_fstest auto atomicwrites
+
+_require_scratch_write_atomic_multi_fsblock
+_require_atomic_write_test_commands
+
+_scratch_mkfs >> $seqres.full 2>&1
+_scratch_mount >> $seqres.full
+
+testfile=$SCRATCH_MNT/testfile
+touch $testfile
+
+awu_max=$(_get_atomic_write_unit_max $testfile)
+blksz=$(_get_block_size $SCRATCH_MNT)
+echo "Awu max: $awu_max" >> $seqres.full
+

tests/generic/772 new file +14 -0

+		echo "Written to offset: $off" >> $tmp.aw
+		off=$((off + $size))
+	done
+}
+
+create_mixed_mappings() {
+	local file=$1
+	local size_bytes=$2
+
+	echo "# Filling file $file with alternate mappings till size $size_bytes" >> $seqres.full
+	#Fill the file with alternate written and unwritten blocks
+	local off=0
+	local operations=("W" "U")
+

tests/generic/772 new file +53 -0

+
+	$XFS_IO_PROG -fc "falloc 0 $awu_max" $testfile.exp_old_zeroes >> $seqres.full
+	expected_data_old_zeroes=$(xxd -s 0 -l $awu_max -p $testfile.exp_old_zeroes)
+
+	$XFS_IO_PROG -fc "pwrite -b $awu_max 0 $awu_max" $testfile.exp_old_mapped >> $seqres.full
+	expected_data_old_mapped=$(xxd -s 0 -l $awu_max -p $testfile.exp_old_mapped)
+
+	# create a dummy file with expected new data
+	$XFS_IO_PROG -fc "pwrite -S 0x61 -b $awu_max 0 $awu_max" $testfile.exp_new >> $seqres.full
+	expected_data_new=$(xxd -s 0 -l $awu_max -p $testfile.exp_new)
+}
+
+verify_data_blocks() {
+	local verify_start=$1
+	local verify_end=$2
+	local expected_data_old="$3"
+	local expected_data_new="$4"
+
+	echo >> $seqres.full
+	echo "# Checking data integrity from $verify_start to $verify_end" >> $seqres.full
+
+	# After an atomic write, for every chunk we ensure that the underlying
+	# data is either the old data or new data as writes shouldn't get torn.
+	local off=$verify_start
+	while [[ "$off" -lt "$verify_end" ]]
+	do
+		actual_data=$(xxd -s $off -l $awu_max -p $testfile)
+		if [[ "$actual_data" != "$expected_data_new" ]] && [[ "$actual_data" != "$expected_data_old" ]]
+		then
+			echo "Checksum match failed at off: $off size: $awu_max"
+			echo "Expected contents: (Either of the 2 below):"
+			echo
+			echo "Expected old: "
+			echo "$expected_data_old"
+			echo
+			echo "Expected new: "
+			echo "$expected_data_new"
+			echo
+			echo "Actual contents: "
+			echo "$actual_data"
+
+			return 1
+		fi
+		echo -n "Check at offset $off suceeded! " >> $seqres.full
+		if [[ "$actual_data" == "$expected_data_new" ]]
+		then
+			echo "matched new" >> $seqres.full
+		elif [[ "$actual_data" == "$expected_data_old" ]]
+		then
+			echo "matched old" >> $seqres.full
+		fi
+		off=$(( off + awu_max ))
+	done

tests/generic/772 new file +18 -0

+
+	last_offset=$(tail -n 1 $tmp.aw | cut -d" " -f4)
+	cat $tmp.aw >> $seqres.full
+	echo >> $seqres.full
+	echo "# Last offset of atomic write: $last_offset" >> $seqres.full
+
+	rm $tmp.aw
+	sleep 0.5
+
+	_scratch_cycle_mount
+
+	# we want to verify all blocks around which the shutdown happended
+	verify_start=$(( last_offset - (awu_max * 5)))
+	if [[ $verify_start < 0 ]]
+	then
+		verify_start=0
+	fi
+

tests/generic/772 new file +9 -0

+}
+
+# test data integrity for file with completely written mappings
+test_data_integrity_writ() {
+	$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Creating testfile with fully written mapping" >> $seqres.full
+	$XFS_IO_PROG -c "pwrite -b $filesize 0 $filesize" $testfile >> $seqres.full

tests/generic/772 new file +9 -0

+}
+
+# test data integrity for file with completely unwritten mappings
+test_data_integrity_unwrit() {
+	$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Creating testfile with fully unwritten mappings" >> $seqres.full
+	$XFS_IO_PROG -c "falloc 0 $filesize" $testfile >> $seqres.full

tests/generic/772 new file +9 -0

+}
+
+# test data integrity for file with no mappings
+test_data_integrity_hole() {
+	$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Creating testfile with no mappings" >> $seqres.full
+	$XFS_IO_PROG -c "truncate $filesize" $testfile >> $seqres.full

tests/generic/772 new file +93 -0

+
+	# Wait for atleast first write to be recorded
+	while [ ! -f "$tmp.aw" ]; do sleep 0.2; done
+
+	echo >> $seqres.full
+	echo "# Shutting down filesystem while write is running" >> $seqres.full
+	_scratch_shutdown
+
+	kill $awloop_pid
+	wait $awloop_pid
+
+	local last_offset=$(tail -n 1 $tmp.aw | cut -d" " -f4)
+	cat $tmp.aw >> $seqres.full
+	echo >> $seqres.full
+	echo "# Last offset of atomic write: $last_offset" >> $seqres.full
+	rm $tmp.aw
+	sleep 0.5
+
+	_scratch_cycle_mount
+	local filesize=$(_get_filesize $testfile)
+	echo >> $seqres.full
+	echo "# Filesize after shutdown: $filesize" >> $seqres.full
+
+	# To confirm that the write went atomically, we check:
+	# 1. The last block should be a multiple of awu_max
+	# 2. The last block should be the completely new data
+
+	if (( $filesize % $awu_max ))
+	then
+		echo "Filesize after shutdown ($filesize) not a multiple of atomic write unit ($awu_max)"
+	fi
+
+	verify_start=$(( filesize - (awu_max * 5)))
+	if [[ $verify_start < 0 ]]
+	then
+		verify_start=0
+	fi
+
+	local verify_end=$filesize
+
+	# Here the blocks should always match new data hence, for simplicity of
+	# code, just corrupt the $expected_data_old buffer so it never matches
+	local expected_data_old="POISON"
+	verify_data_blocks $verify_start $verify_end "$expected_data_old" "$expected_data_new"
+
+	return $?
+}
+
+$XFS_IO_PROG -fc "truncate 0" $testfile >> $seqres.full
+
+echo >> $seqres.full
+echo "# Populating expected data buffers" >> $seqres.full
+populate_expected_data
+
+# Loop 20 times to shake out any races due to shutdown
+for ((iter=0; iter<20; iter++))
+do
+	echo >> $seqres.full
+	echo "------ Iteration $iter ------" >> $seqres.full
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over mixed mapping" >> $seqres.full
+	test_data_integrity_mixed
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over fully written mapping" >> $seqres.full
+	test_data_integrity_writ
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over fully unwritten mapping" >> $seqres.full
+	test_data_integrity_unwrit
+	if [[ "$?" == "1" ]]
+	then
+		status=1
+		break
+	fi
+
+	echo >> $seqres.full
+	echo "# Starting data integrity test for atomic writes over holes" >> $seqres.full
+	test_data_integrity_hole
+	if [[ "$?" == "1" ]]
+	then
+		status=1