Skip to contentSkip to conversation

Fixes for mkfs.xfs with high amount of CPUs and SSDs

PATCH Superseded Lukas Herbolt 2 participants 10 messages Apr 30 – May 14

v1 of 2 Superseded Latest is v2 →

lore
Share & tools
lore
#0 lore raw

cover Fixes for mkfs.xfs with high amount of CPUs and SSDs

Since xfsprogs v6.13.0 mkfs.xfs scales the log size on SSDs with the amount of CPUs. This leads to various failures from ENOSPC in generic/102 and generic172 (the xfs log can take up to 256MB on 1GB test FS) or depleting the dmthin metadata area in generic/347. Downsize of the percentage change is we cannot longer check the exact amount of data xfs_io wrote in the generic/102 test.

The xfs/21{6,7} are testing the old behavior before the concurrency option was introduced. Forcing the old behavior on newer mkfs.xfs.

Lukas Herbolt (4):
common/rc: Add helper to calculate percetage of free space available common/xfs: helper function to check if -l/-d/-r concurrecy flags. generic/{102,172,347}: Adapt test for XFS on systems with 128+CPUs +
SSDs
xfs/216 xfs/217 Use default -l conccurency=0 on mkfs.xfs that supports
it

 common/rc             |  8 ++++++++
 common/xfs            |  6 ++++++
 tests/generic/102     |  5 +++--
 tests/generic/102.out | 20 ++++++++++----------
 tests/generic/172     |  8 ++++----
 tests/generic/347     |  9 ++++++++-
 tests/xfs/216         |  9 +++++++--
 tests/xfs/217         | 17 +++++++++++++++--
 8 files changed, 61 insertions(+), 21 deletions(-)
Signature · 1 line
2.53.0
#1 lore raw

PATCH 1/4 common/rc: Add helper to calculate percetage of free space available

It calculates percentage of filesystem available space and returns it in MB. This helper will be used in the following test/generic fixes.

---
 common/rc | 8 ++++++++
 1 file changed, 8 insertions(+)
common/rc +8 -0
index 5fe44e2158ff..32c566cdb68a 100644
@@ -6189,6 +6189,14 @@ _require_fanotify_ioerrors()
 	_notrun "$FSTYP does not support fanotify ioerrors"
 }
 
+# Returns percentage of available space on given mount point.
+# usage example:
+# _mb_pct_of_available_space <mount point> <percents>
+#
+_mb_pct_of_available_space()
+{
+        _df_device $1 | $AWK_PROG -v pct=$2 '{printf "%.f", (($5*(pct/100))/1024)}'
+}
 ################################################################################
 # make sure this script returns success
 /bin/true
Signature · 1 line
2.53.0
#2 lore raw

Re: [PATCH 1/4] common/rc: Add helper to calculate percetage of free space available

"percentage" in the subject line

Quoted 13 lines · Lukas Herbolt

It calculates percentage of filesystem available space and returns it in MB. This helper will be used in the following test/generic fixes.

---
 common/rc | 8 ++++++++
 1 file changed, 8 insertions(+)
common/rc +0 -0
index 5fe44e2158ff..32c566cdb68a 100644

common/rc _require_fanotify_ioerrors() · line 6192

Quoted 4 lines
common/rc +1 -0
@@ -6189,6 +6189,14 @@ _require_fanotify_ioerrors()
 	_notrun "$FSTYP does not support fanotify ioerrors"
 }
 
+# Returns percentage of available space on given mount point.

“Computes a percentage of the available space in a filesystem and returns that quantity in MB. The percentage must not contain a percent sign ("%").”

common/rc _require_fanotify_ioerrors() · line 6194

Quoted 2 lines
common/rc +2 -0
+# usage example:
+# _mb_pct_of_available_space <mount point> <percents>

s/percents/percent/

--D

Quoted 12 lines
common/rc +5 -0
+#
+_mb_pct_of_available_space()
+{
+        _df_device $1 | $AWK_PROG -v pct=$2 '{printf "%.f", (($5*(pct/100))/1024)}'
+}
 ################################################################################
 # make sure this script returns success
 /bin/true
Signature · 1 line
2.53.0
#3 lore raw

PATCH 2/4 common/xfs: helper function to check if -l/-d/-r concurrecy flags.

In reply to Lukas Herbolt

Check if the requested flag is supported by the mkfs.xfs on scratch device.

---
 common/xfs | 6 ++++++
 1 file changed, 6 insertions(+)
common/xfs +6 -0
index f7a6d2f2f03a..12cf6c273c53 100644
@@ -2399,3 +2399,9 @@ _require_xfs_healer()
 	_xfs_healer --supported "$@" &>/dev/null || \
 		_notrun "health monitoring not supported on this kernel"
 }
+
+# Check if -l/-d/-r concurrency is supported.
+_scratch_mkfs_supports_concurrency()
+{
+        _scratch_mkfs_xfs_supported $1 concurrency=0
+}
Signature · 1 line
2.53.0
#4 lore raw

Re: [PATCH 2/4] common/xfs: helper function to check if -l/-d/-r concurrecy flags.

Quoted 13 lines · Lukas Herbolt

Check if the requested flag is supported by the mkfs.xfs on scratch device.

---
 common/xfs | 6 ++++++
 1 file changed, 6 insertions(+)
common/xfs +0 -0
index f7a6d2f2f03a..12cf6c273c53 100644

common/xfs _require_xfs_healer() · line 2404

Quoted 6 lines
common/xfs +3 -0
@@ -2399,3 +2399,9 @@ _require_xfs_healer()
 	_xfs_healer --supported "$@" &>/dev/null || \
 		_notrun "health monitoring not supported on this kernel"
 }
+
+# Check if -l/-d/-r concurrency is supported.
+_scratch_mkfs_supports_concurrency()

This is specific to xfs, so I think the name should reflect that.

_scratch_mkfs_xfs_supports_concurrency

common/xfs _require_xfs_healer() · line 2407

Quoted 3 lines
common/xfs +3 -0
+{
+        _scratch_mkfs_xfs_supported $1 concurrency=0
+}

As I noted downthread, -d and -l gained their concurrency= options in the same release so we probably ought to do future fstests authors a favor and note that in the comments or just do something dorky like:

_scratch_mkfs_xfs_supports_concurrency()

{
	local arg="${1:-d}"

	# -d and -l gained concurrency options at the same time
	test "$arg" = "-l" && arg="-d"

	_scratch_mkfs_xfs_supported "$arg" concurrency=0
}

--D

Quoted 4 lines
Signature · 1 line
2.53.0
#5 lore raw

PATCH 3/4 generic/{102,172,347}: Adapt test for XFS on systems with 128+CPUs + SSDs

In reply to Lukas Herbolt

XFS will now scale by default its log size according the amount of CPUs. This can significantly increase the log area and using hardcoded size of file size will make the test file. Using the the X percent of the free space to create the file will let the test proceed.

For generic/102 we also have to change the 102.out as we cannot know the amount written data and it has to be filterred out.

For generic/172 we just use the new function to calculate file big enough to consume most of the available space.

The generic/347 will use -l concurency=0 in case it is being run on the XFS filesystem and mkfs.xfs already supports this option.

---
 tests/generic/102     |  5 +++--
 tests/generic/102.out | 20 ++++++++++----------
 tests/generic/172     |  8 ++++----
 tests/generic/347     |  9 ++++++++-
 4 files changed, 25 insertions(+), 17 deletions(-)
tests/generic/102 +3 -2
index daa5061bd3fe..60e651fefb5b 100755
@@ -23,12 +23,13 @@ _require_scratch
 dev_size=$((1024 * 1024 * 1024))     # 1GB filesystem
 _scratch_mkfs_sized $dev_size >>$seqres.full 2>&1
 _scratch_mount
+file_size=`_mb_pct_of_available_space $SCRATCH_DEV 95`
 
 for ((i = 0; i < 10; i++)); do
 	echo "loop $i" >>$seqres.full
 
-	$XFS_IO_PROG -f -c "pwrite -b 1m 0 800m" "$SCRATCH_MNT"/file | \
-_filter_xfs_io | _filter_scratch
+	$XFS_IO_PROG -f -c "pwrite -b 1m 0 ${file_size}m" "$SCRATCH_MNT"/file | \
+_filter_xfs_io_numbers | _filter_scratch
 
 	rm -f "$SCRATCH_MNT"/file
 done
tests/generic/102.out +10 -10
index b58aa5ccc68b..647bb23abec1 100644
@@ -1,21 +1,21 @@
 QA output created by 102
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
tests/generic/172 +4 -4
index b67e817b667b..06f9370f065d 100755
@@ -37,15 +37,15 @@ echo "Reformat with appropriate size"
 blksz="$(_get_block_size $testdir)"
 _scratch_unmount
 
-file_size=$((768 * 1024 * 1024))
 fs_size=$((1024 * 1024 * 1024))
 _scratch_mkfs_sized $fs_size >> $seqres.full 2>&1
 _scratch_mount >> $seqres.full 2>&1
 rm -rf $testdir
 mkdir $testdir
+file_size=`_mb_pct_of_available_space $SCRATCH_DEV 70`
 
 echo "Create a big file and reflink it"
-_pwrite_byte 0x61 0 $file_size $testdir/bigfile >> $seqres.full 2>&1
+_pwrite_byte 0x61 0 ${file_size}m $testdir/bigfile >> $seqres.full 2>&1
 _cp_reflink $testdir/bigfile $testdir/clonefile
 _scratch_sync
 
@@ -54,7 +54,7 @@ _fill_fs $fs_size  $testdir/space $blksz 0 >> $seqres.full 2>&1
 _scratch_sync
 
 echo "CoW the big file"
-out="$(_pwrite_byte 0x62 0 $file_size $testdir/bigfile 2>&1 | \
+out="$(_pwrite_byte 0x62 0 ${file_size}m $testdir/bigfile 2>&1 | \
 	_filter_xfs_io_error)"
 echo ${out} | grep -q "No space left on device" || echo "CoW should have failed with ENOSPC"
 echo ${out} >> $seqres.full 2>&1
@@ -63,7 +63,7 @@ echo ${out}
 echo "Remount and try CoW again"
 _scratch_cycle_mount
 
-out="$(_pwrite_byte 0x62 0 $file_size $testdir/bigfile 2>&1 | \
+out="$(_pwrite_byte 0x62 0 ${file_size}m $testdir/bigfile 2>&1 | \
 	_filter_xfs_io_error)"
 echo ${out} | grep -q "No space left on device" || echo "CoW should have failed with ENOSPC"
 echo ${out} >> $seqres.full 2>&1
tests/generic/347 +8 -1
index 5c0e3f949585..cf3cfc94c8c4 100755
@@ -14,6 +14,13 @@ BACKING_SIZE=$((500 * 1024 * 1024 / 512))	# 500M
 VIRTUAL_SIZE=$((10 * $BACKING_SIZE))		# 5000M
 GROW_SIZE=$((100 * 1024 * 1024 / 512))		# 100M
 
+dmthin_mkfs_opts=""
+if [ $FSTYP == "xfs" ]; then
+	if _scratch_mkfs_xfs_supported -l concurrency=0  >> $seqres.full 2>&1; then
+		dmthin_mkfs_opts="-l concurrency=0"
+	fi
+fi
+
 # Override the default cleanup function.
 _cleanup()
 {
@@ -25,7 +32,7 @@ _setup_thin()
 {
 	_dmthin_init $BACKING_SIZE $VIRTUAL_SIZE
 	_dmthin_set_queue
-	_dmthin_mkfs
+	_dmthin_mkfs $dmthin_mkfs_opts
 	_dmthin_mount
 }
 
Signature · 1 line
2.53.0
#6 lore raw

Re: [PATCH 3/4] generic/{102,172,347}: Adapt test for XFS on systems with 128+CPUs + SSDs

Quoted 29 lines · Lukas Herbolt

XFS will now scale by default its log size according the amount of CPUs. This can significantly increase the log area and using hardcoded size of file size will make the test file. Using the the X percent of the free space to create the file will let the test proceed.

For generic/102 we also have to change the 102.out as we cannot know the amount written data and it has to be filterred out.

For generic/172 we just use the new function to calculate file big enough to consume most of the available space.

The generic/347 will use -l concurency=0 in case it is being run on the XFS filesystem and mkfs.xfs already supports this option.

---
 tests/generic/102     |  5 +++--
 tests/generic/102.out | 20 ++++++++++----------
 tests/generic/172     |  8 ++++----
 tests/generic/347     |  9 ++++++++-
 4 files changed, 25 insertions(+), 17 deletions(-)
tests/generic/102 +0 -0
index daa5061bd3fe..60e651fefb5b 100755
@@ -23,12 +23,13 @@ _require_scratch
 dev_size=$((1024 * 1024 * 1024))     # 1GB filesystem
 _scratch_mkfs_sized $dev_size >>$seqres.full 2>&1

tests/generic/102 _require_scratch · line 32

Quoted 10 lines
tests/generic/102 +3 -2
 _scratch_mount
+file_size=`_mb_pct_of_available_space $SCRATCH_DEV 95`
 
 for ((i = 0; i < 10; i++)); do
 	echo "loop $i" >>$seqres.full
 
-	$XFS_IO_PROG -f -c "pwrite -b 1m 0 800m" "$SCRATCH_MNT"/file | \
-_filter_xfs_io | _filter_scratch
+	$XFS_IO_PROG -f -c "pwrite -b 1m 0 ${file_size}m" "$SCRATCH_MNT"/file | \
+_filter_xfs_io_numbers | _filter_scratch

Ah, ok, so we're using 95% of the available space, not just a static 800M? That's a pretty big difference...

Quoted 43 lines
tests/generic/102 +0 -0
 	rm -f "$SCRATCH_MNT"/file
 done
tests/generic/102.out +10 -10
index b58aa5ccc68b..647bb23abec1 100644
@@ -1,21 +1,21 @@
 QA output created by 102
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 838860800/838860800 bytes at offset 0
+wrote XXXX/XXXX bytes at offset XXXX
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
tests/generic/172 +0 -0
index b67e817b667b..06f9370f065d 100755

tests/generic/172 echo "Reformat with appropriate size" · line 45

Quoted 10 lines
tests/generic/172 +1 -1
@@ -37,15 +37,15 @@ echo "Reformat with appropriate size"
 blksz="$(_get_block_size $testdir)"
 _scratch_unmount
 
-file_size=$((768 * 1024 * 1024))
 fs_size=$((1024 * 1024 * 1024))
 _scratch_mkfs_sized $fs_size >> $seqres.full 2>&1
 _scratch_mount >> $seqres.full 2>&1
 rm -rf $testdir
 mkdir $testdir
+file_size=`_mb_pct_of_available_space $SCRATCH_DEV 70`

...particularly since you replace 768/1024 with 70% here.

Quoted 29 lines
tests/generic/172 +3 -3
 echo "Create a big file and reflink it"
-_pwrite_byte 0x61 0 $file_size $testdir/bigfile >> $seqres.full 2>&1
+_pwrite_byte 0x61 0 ${file_size}m $testdir/bigfile >> $seqres.full 2>&1
 _cp_reflink $testdir/bigfile $testdir/clonefile
 _scratch_sync
 
@@ -54,7 +54,7 @@ _fill_fs $fs_size  $testdir/space $blksz 0 >> $seqres.full 2>&1
 _scratch_sync
 
 echo "CoW the big file"
-out="$(_pwrite_byte 0x62 0 $file_size $testdir/bigfile 2>&1 | \
+out="$(_pwrite_byte 0x62 0 ${file_size}m $testdir/bigfile 2>&1 | \
 	_filter_xfs_io_error)"
 echo ${out} | grep -q "No space left on device" || echo "CoW should have failed with ENOSPC"
 echo ${out} >> $seqres.full 2>&1
@@ -63,7 +63,7 @@ echo ${out}
 echo "Remount and try CoW again"
 _scratch_cycle_mount
 
-out="$(_pwrite_byte 0x62 0 $file_size $testdir/bigfile 2>&1 | \
+out="$(_pwrite_byte 0x62 0 ${file_size}m $testdir/bigfile 2>&1 | \
 	_filter_xfs_io_error)"
 echo ${out} | grep -q "No space left on device" || echo "CoW should have failed with ENOSPC"
 echo ${out} >> $seqres.full 2>&1
tests/generic/347 +0 -0
index 5c0e3f949585..cf3cfc94c8c4 100755

tests/generic/347 BACKING_SIZE=$((500 * 1024 * 1024 / 512)) # 500M · line 19

Quoted 6 lines
tests/generic/347 +3 -0
@@ -14,6 +14,13 @@ BACKING_SIZE=$((500 * 1024 * 1024 / 512))	# 500M
 VIRTUAL_SIZE=$((10 * $BACKING_SIZE))		# 5000M
 GROW_SIZE=$((100 * 1024 * 1024 / 512))		# 100M
 
+dmthin_mkfs_opts=""
+if [ $FSTYP == "xfs" ]; then
+	if _scratch_mkfs_xfs_supported -l concurrency=0  >> $seqres.full 2>&1; then

_scratch_mkfs_supports_concurrency ?

Quoted 20 lines
tests/generic/347 +5 -1
+		dmthin_mkfs_opts="-l concurrency=0"
+	fi
+fi
+
 # Override the default cleanup function.
 _cleanup()
 {
@@ -25,7 +32,7 @@ _setup_thin()
 {
 	_dmthin_init $BACKING_SIZE $VIRTUAL_SIZE
 	_dmthin_set_queue
-	_dmthin_mkfs
+	_dmthin_mkfs $dmthin_mkfs_opts
 	_dmthin_mount
 }
 
Signature · 1 line
2.53.0
#7 lore raw

PATCH 4/4 xfs/216 xfs/217 Use default -l conccurency=0 on mkfs.xfs that supports it

In reply to Lukas Herbolt

The XFS conccurency optimalization breaks the log sizing check on systems with non-rotational disks and high amount of CPUs. Default to the old behavior with -l conccurency=0 and with -d concurrency=0.

---
 tests/xfs/216 |  9 +++++++--
 tests/xfs/217 | 17 +++++++++++++++--
 2 files changed, 22 insertions(+), 4 deletions(-)
tests/xfs/216 +7 -2
index 091c11d08642..8b4610d5a0a6 100755
@@ -21,14 +21,19 @@ _cleanup()
 }
 
 _require_scratch
-_scratch_mkfs_xfs >/dev/null 2>&1
+if _scratch_mkfs_supports_concurrency -l >> $seqres.full 2>&1; then
+	_scratch_mkfs_xfs -l concurrency=0 >/dev/null 2>&1
+	loop_mkfs_opts="-l concurrency=0"
+else
+	_scratch_mkfs_xfs >/dev/null 2>&1
+	loop_mkfs_opts=
+fi
 _scratch_mount
 
 _require_loop
 LOOP_IMG=$SCRATCH_MNT/test_fs
 LOOP_MNT=$SCRATCH_MNT/test_fs_dir
 
-loop_mkfs_opts=
 $MKFS_XFS_PROG 2>&1 | grep -q rmapbt && \
 	loop_mkfs_opts="$loop_mkfs_opts -m rmapbt=0"
 $MKFS_XFS_PROG 2>&1 | grep -q reflink && \
tests/xfs/217 +15 -2
index dae6ce55f475..7c7b33b1ccf7 100755
@@ -20,7 +20,20 @@ _cleanup()
 }
 
 _require_scratch
-_scratch_mkfs_xfs >/dev/null 2>&1
+if _scratch_mkfs_supports_concurrency -l >> $seqres.full 2>&1; then
+	_scratch_mkfs_xfs -l concurrency=0 >/dev/null 2>&1
+	loop_mkfs_opts="-l concurrency=0"
+		if _scratch_mkfs_supports_concurrency -d >> $seqres.full 2>&1; then
+			# We could go just with -l concurency but then on 512CPUs
+			# it gives log size off by one block so better to set
+			# -d concurrency to 0.
+			loop_mkfs_opts="$loop_mkfs_opts -d concurrency=0"
+
+		fi
+else
+	_scratch_mkfs_xfs >/dev/null 2>&1
+	loop_mkfs_opts=
+fi
 _scratch_mount
 # 16T mkfs requires a bit over 2G free
 _require_fs_space $SCRATCH_MNT 2202000
@@ -34,7 +47,7 @@ _do_mkfs()
 	for i in $*; do
 		echo -n "fssize=${i}g "
 		$MKFS_XFS_PROG -f -b size=4096 -l version=2 \
-			-d size=${i}g $loop_dev |grep log
+			-d size=${i}g $loop_dev $loop_mkfs_opts |grep log
 		_mount $loop_dev $LOOP_MNT
 		echo "test write" > $LOOP_MNT/test
 		_unmount $LOOP_MNT > /dev/null 2>&1
Signature · 1 line
2.53.0
#8 lore raw

Re: [PATCH 4/4] xfs/216 xfs/217 Use default -l conccurency=0 on mkfs.xfs that supports it

Quoted 1 line · Lukas Herbolt

The XFS conccurency optimalization breaks the log sizing check on

"concurrency optimization"

Quoted 2 lines

systems with non-rotational disks and high amount of CPUs. Default to the old behavior with -l conccurency=0 and with -d concurrency=0.

"-l concurrency=0"

Quoted 37 lines
---
 tests/xfs/216 |  9 +++++++--
 tests/xfs/217 | 17 +++++++++++++++--
 2 files changed, 22 insertions(+), 4 deletions(-)
tests/xfs/216 +7 -2
index 091c11d08642..8b4610d5a0a6 100755
@@ -21,14 +21,19 @@ _cleanup()
 }
 
 _require_scratch
-_scratch_mkfs_xfs >/dev/null 2>&1
+if _scratch_mkfs_supports_concurrency -l >> $seqres.full 2>&1; then
+	_scratch_mkfs_xfs -l concurrency=0 >/dev/null 2>&1
+	loop_mkfs_opts="-l concurrency=0"
+else
+	_scratch_mkfs_xfs >/dev/null 2>&1
+	loop_mkfs_opts=
+fi
 _scratch_mount
 
 _require_loop
 LOOP_IMG=$SCRATCH_MNT/test_fs
 LOOP_MNT=$SCRATCH_MNT/test_fs_dir
 
-loop_mkfs_opts=
 $MKFS_XFS_PROG 2>&1 | grep -q rmapbt && \
 	loop_mkfs_opts="$loop_mkfs_opts -m rmapbt=0"
 $MKFS_XFS_PROG 2>&1 | grep -q reflink && \
tests/xfs/217 +0 -0
index dae6ce55f475..7c7b33b1ccf7 100755

tests/xfs/217 _cleanup() · line 24

Quoted 6 lines
tests/xfs/217 +2 -1
@@ -20,7 +20,20 @@ _cleanup()
 }
 
 _require_scratch
-_scratch_mkfs_xfs >/dev/null 2>&1
+if _scratch_mkfs_supports_concurrency -l >> $seqres.full 2>&1; then
+	_scratch_mkfs_xfs -l concurrency=0 >/dev/null 2>&1

Why does the scratch fs need a -lconcurrency option?

tests/xfs/217 _cleanup() · line 30

Quoted 6 lines
tests/xfs/217 +6 -0
+	loop_mkfs_opts="-l concurrency=0"
+		if _scratch_mkfs_supports_concurrency -d >> $seqres.full 2>&1; then
+			# We could go just with -l concurency but then on 512CPUs
+			# it gives log size off by one block so better to set
+			# -d concurrency to 0.
+			loop_mkfs_opts="$loop_mkfs_opts -d concurrency=0"

concurrency= was added for -d and -l in the same release (6.7) so you don't have to test them separately.

--D

Quoted 22 lines
tests/xfs/217 +7 -1
+
+		fi
+else
+	_scratch_mkfs_xfs >/dev/null 2>&1
+	loop_mkfs_opts=
+fi
 _scratch_mount
 # 16T mkfs requires a bit over 2G free
 _require_fs_space $SCRATCH_MNT 2202000
@@ -34,7 +47,7 @@ _do_mkfs()
 	for i in $*; do
 		echo -n "fssize=${i}g "
 		$MKFS_XFS_PROG -f -b size=4096 -l version=2 \
-			-d size=${i}g $loop_dev |grep log
+			-d size=${i}g $loop_dev $loop_mkfs_opts |grep log
 		_mount $loop_dev $LOOP_MNT
 		echo "test write" > $LOOP_MNT/test
 		_unmount $LOOP_MNT > /dev/null 2>&1
Signature · 1 line
2.53.0
#9 lore raw

Re: [PATCH 4/4] xfs/216 xfs/217 Use default -l conccurency=0 on mkfs.xfs that supports it

Quoted 49 lines · Darrick J. Wong
Quoted 1 line · Lukas Herbolt

The XFS conccurency optimalization breaks the log sizing check on

"concurrency optimization"

Quoted 2 lines

systems with non-rotational disks and high amount of CPUs. Default to the old behavior with -l conccurency=0 and with -d concurrency=0.

"-l concurrency=0"

Quoted 39 lines
---
 tests/xfs/216 |  9 +++++++--
 tests/xfs/217 | 17 +++++++++++++++--
 2 files changed, 22 insertions(+), 4 deletions(-)
tests/xfs/216 +7 -2
index 091c11d08642..8b4610d5a0a6 100755
@@ -21,14 +21,19 @@ _cleanup()
 }
 
 _require_scratch
-_scratch_mkfs_xfs >/dev/null 2>&1
+if _scratch_mkfs_supports_concurrency -l >> $seqres.full 2>&1; then
+	_scratch_mkfs_xfs -l concurrency=0 >/dev/null 2>&1
+	loop_mkfs_opts="-l concurrency=0"
+else
+	_scratch_mkfs_xfs >/dev/null 2>&1
+	loop_mkfs_opts=
+fi
 _scratch_mount
 
 _require_loop
 LOOP_IMG=$SCRATCH_MNT/test_fs
 LOOP_MNT=$SCRATCH_MNT/test_fs_dir
 
-loop_mkfs_opts=
 $MKFS_XFS_PROG 2>&1 | grep -q rmapbt && \
 	loop_mkfs_opts="$loop_mkfs_opts -m rmapbt=0"
 $MKFS_XFS_PROG 2>&1 | grep -q reflink && \
tests/xfs/217 +0 -0
index dae6ce55f475..7c7b33b1ccf7 100755
@@ -20,7 +20,20 @@ _cleanup()
 }
 
Quoted 6 lines

tests/xfs/217 _cleanup() · line 24

Quoted 4 lines
tests/xfs/217 +2 -1
 _require_scratch
-_scratch_mkfs_xfs >/dev/null 2>&1
+if _scratch_mkfs_supports_concurrency -l >> $seqres.full 2>&1; then
+	_scratch_mkfs_xfs -l concurrency=0 >/dev/null 2>&1

Why does the scratch fs need a -lconcurrency option?

Yeah right it does not need it. Wanted to be sure we do not run into -ENOSPC but on recommended 10G SCRATCH_DEV we should not.

Quoted 10 lines

tests/xfs/217 _cleanup() · line 30

Quoted 7 lines
tests/xfs/217 +6 -0
+	loop_mkfs_opts="-l concurrency=0"
+		if _scratch_mkfs_supports_concurrency -d >> $seqres.full 2>&1; then
+			# We could go just with -l concurency but then on 512CPUs
+			# it gives log size off by one block so better to set
+			# -d concurrency to 0.
+			loop_mkfs_opts="$loop_mkfs_opts -d concurrency=0"

concurrency= was added for -d and -l in the same release (6.7) so you don't have to test them separately.

Just wanted to be sure as those still came in different commits.

Quoted 25 lines

--D

Quoted 22 lines
tests/xfs/217 +7 -2
+
+		fi
+else
+	_scratch_mkfs_xfs >/dev/null 2>&1
+	loop_mkfs_opts=
+fi
 _scratch_mount
 # 16T mkfs requires a bit over 2G free
 _require_fs_space $SCRATCH_MNT 2202000
@@ -34,7 +47,7 @@ _do_mkfs()
 	for i in $*; do
 		echo -n "fssize=${i}g "
 		$MKFS_XFS_PROG -f -b size=4096 -l version=2 \
-			-d size=${i}g $loop_dev |grep log
+			-d size=${i}g $loop_dev $loop_mkfs_opts |grep log
 		_mount $loop_dev $LOOP_MNT
 		echo "test write" > $LOOP_MNT/test
 		_unmount $LOOP_MNT > /dev/null 2>&1
--

2.53.0

Signature · 1 line
-lhe