Fix tests to work on non-4k block sized fs instances

PATCH Superseded Chandan Rajendra 2 participants 20 messages Aug 16, 2018 – Sep 4, 2018

Share & tools

Chandan Rajendra

author

2018-08-16 10:21 UTC #0 lore raw

cover Fix tests to work on non-4k block sized fs instances

This patchset fixes tests (mostly XFS specific ones) to work on variable block size. These patches now use the output of "od" utility to verify the contents of the test files instead of the md5sum utility.

The patchset modifies _filter_fiemap() filter function to optionally print the file offset range in block size units.

Chandan Rajendra (16):
Fix xfs/009 to work with 64k block size xfs/050: Fix "Push past soft inode limit" case Fix xfs/050 to work with 64k block size
Fix xfs/074 to work with 64k block size
Fix xfs/127 to work with 64k block size
Fix xfs/139 to work with 64k block size
Fix xfs/140 to work with 64k block size
Fix xfs/190 to work with 64k block size
Fix xfs/299 to work with 64k block size xfs/325: Inject free_extent error after CoW operation Fix generic/102 to work with 64k block size Fix generic/172 to work with 64k block size Filter fiemap output by FS block size
Fix generic/177 to work with 64k block size Fix generic/230 to work with 64k block size Fix generic/235 to work with 64k block size

 common/punch          | 19 ++++++++---
 tests/generic/102     |  4 +--
 tests/generic/102.out | 20 +++++------
 tests/generic/172     |  4 +--
 tests/generic/177     | 20 ++++++-----
 tests/generic/177.out | 23 ++++++++-----
 tests/generic/230     | 24 ++++++++------
 tests/generic/230.out | 16 ++++-----
 tests/generic/235     |  2 +-
 tests/generic/235.out |  4 +--
 tests/xfs/009         | 92 ++++++++++++++++++++++++++++++++++++++++++---------
 tests/xfs/009.out     | 66 ++++++++++++++++++------------------
 tests/xfs/050         | 23 ++++++++-----
 tests/xfs/050.out     | 60 ++++++++++++++++-----------------
 tests/xfs/074         | 23 ++++++++++---
 tests/xfs/127         |  2 +-
 tests/xfs/139         | 12 +++----
 tests/xfs/139.out     |  8 +++--
 tests/xfs/140         |  9 ++---
 tests/xfs/190         | 44 +++++++++++++++++++-----
 tests/xfs/299         | 23 ++++++++-----
 tests/xfs/299.out     | 60 ++++++++++++++++-----------------
 tests/xfs/325         |  5 +--
 tests/xfs/325.out     |  2 +-
 24 files changed, 355 insertions(+), 210 deletions(-)

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:21 UTC #1 lore raw

PATCH 1/16 Fix xfs/009 to work with 64k block size

xfs_alloc_file_space() rounds up allocation requests by the filesystem block size. Hence this commit changes the test to work with block size units rather than with a multiple of 4096 bytes.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/009     | 92 ++++++++++++++++++++++++++++++++++++++++++++++---------
 tests/xfs/009.out | 66 +++++++++++++++++++--------------------
 2 files changed, 110 insertions(+), 48 deletions(-)

tests/xfs/009 +77 ~~-15~~

index 68f6379..e8d1871 100755
@@ -14,9 +14,6 @@ here=`pwd`
 tmp=/tmp/$$
 status=1	# failure is the default!
 trap "_cleanup; exit \$status" 0 1 2 3 15
-# This isn't really related to fs block size, it's just what
-# alloc uses for the "block" unit in it's input parameters...
-bsize=4096
 
 _cleanup()
 {

@@ -24,13 +21,6 @@ _cleanup()
     _scratch_unmount
 }
 
-_block_filter()
-{
-   sed \
-	-e 's/[0-9][0-9]*\.\.[0-9][0-9]*/BLOCKRANGE/g' \
-	-e "s/blocksize $bsize/blocksize BSIZE/g"
-}
-
 _init()
 {
     echo "*** mkfs"

@@ -49,11 +39,6 @@ _init()
     fi
 }
 
-_filesize()
-{
-    ls -l $1 | $AWK_PROG '{print "filesize = " $5}'
-}
-
 # get standard environment, filters and checks
 . ./common/rc
 . ./common/filter

@@ -64,6 +49,83 @@ _supported_os Linux
 
 _require_scratch
 
+# This isn't really related to fs block size, it's just what
+# alloc uses for the "block" unit in it's input parameters...
+# However, xfs_alloc_file_space() ends up rounding up allocation
+# request by the filesystem block size.
+bsize=$(_get_block_size $TEST_DIR)
+
+_filesize()
+{
+    ls -l $1 | $AWK_PROG -v bsize="$bsize" '{print "filesize = " $5 / bsize}'
+}
+
+_block_filter()
+{
+	$AWK_PROG -v bsize="$bsize" '
+	/blocksize/ {
+		printf("    blocksize BSIZE\n")
+
+		next
+	}
+
+	/CMD/ {
+		split($3, off, "=")
+		offset = strtonum(off[2])
+		if (offset != -1)
+			offset = offset / bsize
+
+		split($4, len, "=")
+		nr_blocks = strtonum(len[2])
+		if (nr_blocks != -1)
+			nr_blocks = nr_blocks / bsize
+
+		printf("    %s %s off=%s, len=%d\n", $1, $2, offset, nr_blocks)
+
+		next
+	}
+
+	/MAP/ {
+		split($2, off, "=")
+		offset = strtonum(off[2])
+		if (offset != -1)
+			offset = offset / bsize
+
+		split($3, len, "=")
+
+		nr_blocks = strtonum(len[2])
+
+		if (nr_blocks != -1)
+			nr_blocks = nr_blocks / bsize
+
+		printf("    %s off=%s, len=%d %s\n", $1, offset, nr_blocks, $4)
+
+		next
+	}
+
+	/TRUNCATE/ {
+		split($2, off, "=")
+		offset = strtonum(off[2]) / bsize
+
+		printf("    %s off=%s\n", $1, offset)
+
+		next
+	}
+
+	/\[[0-9]+,[0-9]+\]:/ {
+		printf("        %s BLOCKRANGE\n", $1)
+
+		next
+	}
+
+	{
+		print
+
+		next
+	}
+	'
+}
+
 _init
 out=$SCRATCH_MNT/$$.tmp

tests/xfs/009.out +33 ~~-33~~

138 lines not on this page · raw message

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:21 UTC #2 lore raw

PATCH 2/16 xfs/050: Fix "Push past soft inode limit" case

In reply to Chandan Rajendra

The test sets an inode soft limit of four but only three files are created. This commit creates two more files in order to really push past the soft inode limit.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/050     |  2 ++
 tests/xfs/050.out | 36 ++++++++++++++++++------------------
 2 files changed, 20 insertions(+), 18 deletions(-)

tests/xfs/050 +2 -0

index dd77971..8569c2c 100755
@@ -143,6 +143,8 @@ _exercise()
 	echo "*** push past the soft inode limit" | tee -a $seqres.full
 	_file_as_id $SCRATCH_MNT/softie1 $id $type 1024 0
 	_file_as_id $SCRATCH_MNT/softie2 $id $type 1024 0
+	_file_as_id $SCRATCH_MNT/softie3 $id $type 1024 0
+	_file_as_id $SCRATCH_MNT/softie4 $id $type 1024 0
 	_qmount
 	xfs_quota -D $tmp.projects -P $tmp.projid -x \
 		-c "repquota -birnN -$type" $SCRATCH_DEV |

tests/xfs/050.out +18 ~~-18~~

index 5cb4a10..ff9eb1c 100644
@@ -16,11 +16,11 @@ realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX
 
 *** push past the soft inode limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 0 100 500 00 [--------] 3 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 0 100 500 00 [--------] 5 4 10 00 [7 days] 0 0 0 00 [--------]
 
 *** push past the soft block limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [7 days] 4 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [7 days] 6 4 10 00 [7 days] 0 0 0 00 [--------]
 
 *** push past the hard inode limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]

@@ -48,11 +48,11 @@ realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX
 
 *** push past the soft inode limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 0 100 500 00 [--------] 3 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 0 100 500 00 [--------] 5 4 10 00 [7 days] 0 0 0 00 [--------]
 
 *** push past the soft block limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [7 days] 4 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [7 days] 6 4 10 00 [7 days] 0 0 0 00 [--------]
 
 *** push past the hard inode limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]

@@ -80,19 +80,19 @@ realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX
 
 *** push past the soft inode limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 0 100 500 00 [--------] 3 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 0 100 500 00 [--------] 5 4 10 00 [--------] 0 0 0 00 [--------]
 
 *** push past the soft block limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [--------] 4 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [--------] 6 4 10 00 [--------] 0 0 0 00 [--------]
 
 *** push past the hard inode limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [--------] 16 4 10 00 [--none--] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [--------] 18 4 10 00 [--none--] 0 0 0 00 [--------]
 
 *** push past the hard block limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 540 100 500 00 [--none--] 16 4 10 00 [--none--] 0 0 0 00 [--------]
+[NAME] 540 100 500 00 [--none--] 18 4 10 00 [--none--] 0 0 0 00 [--------]
 
 *** unmount
 *** gqnoenforce

@@ -112,19 +112,19 @@ realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX
 
 *** push past the soft inode limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 0 100 500 00 [--------] 3 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 0 100 500 00 [--------] 5 4 10 00 [--------] 0 0 0 00 [--------]
 
 *** push past the soft block limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [--------] 4 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [--------] 6 4 10 00 [--------] 0 0 0 00 [--------]
 
 *** push past the hard inode limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [--------] 16 4 10 00 [--none--] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [--------] 18 4 10 00 [--none--] 0 0 0 00 [--------]
 
 *** push past the hard block limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 540 100 500 00 [--none--] 16 4 10 00 [--none--] 0 0 0 00 [--------]
+[NAME] 540 100 500 00 [--none--] 18 4 10 00 [--none--] 0 0 0 00 [--------]
 
 *** unmount
 *** pquota

@@ -144,11 +144,11 @@ realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX
 
 *** push past the soft inode limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 0 100 500 00 [--------] 3 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 0 100 500 00 [--------] 5 4 10 00 [7 days] 0 0 0 00 [--------]
 
 *** push past the soft block limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [7 days] 4 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [7 days] 6 4 10 00 [7 days] 0 0 0 00 [--------]
 
 *** push past the hard inode limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]

@@ -176,18 +176,18 @@ realtime =RDEV extsz=XXX blocks=XXX, rtextents=XXX
 
 *** push past the soft inode limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 0 100 500 00 [--------] 3 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 0 100 500 00 [--------] 5 4 10 00 [--------] 0 0 0 00 [--------]
 
 *** push past the soft block limit
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [--------] 4 4 10 00 [--------] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [--------] 6 4 10 00 [--------] 0 0 0 00 [--------]
 
 *** push past the hard inode limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 140 100 500 00 [--------] 16 4 10 00 [--none--] 0 0 0 00 [--------]
+[NAME] 140 100 500 00 [--------] 18 4 10 00 [--none--] 0 0 0 00 [--------]
 
 *** push past the hard block limit (expect EDQUOT)
 [ROOT] 0 0 0 00 [--------] 3 0 0 00 [--------] 0 0 0 00 [--------]
-[NAME] 540 100 500 00 [--none--] 16 4 10 00 [--none--] 0 0 0 00 [--------]
+[NAME] 540 100 500 00 [--none--] 18 4 10 00 [--none--] 0 0 0 00 [--------]
 
 *** unmount

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:21 UTC #3 lore raw

PATCH 3/16 Fix xfs/050 to work with 64k block size

In reply to Chandan Rajendra

This commit changes the test to calculate quota limits based on the block size of the underlying filesystem. Also, the sizes of the test files are now made to be a multiple of the filesystem block size.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/050     | 21 +++++++++++--------
 tests/xfs/050.out | 60 +++++++++++++++++++++++++++----------------------------
 2 files changed, 43 insertions(+), 38 deletions(-)

tests/xfs/050 +13 -8

index 8569c2c..41e1c2d 100755
@@ -38,8 +38,10 @@ chmod a+rwx $seqres.full	# arbitrary users will write here
 _require_scratch
 _require_xfs_quota
 
-bsoft=100
-bhard=500
+bsize=$(_get_block_size $TEST_DIR)
+
+bsoft=$(( 25 * $bsize ))
+bhard=$(( 125 * $bsize ))
 isoft=4
 ihard=10

@@ -55,7 +57,9 @@ _filter_report()
 		if ($ENV{'LARGE_SCRATCH_DEV'}) {
 			$val = $ENV{'NUM_SPACE_FILES'};
 		}
-		s/(^\[ROOT\] \S+ \S+ \S+ \S+ \[--------\] )(\S+)/$1@{[$2 - $val]}/g'
+		s/(^\[ROOT\] \S+ \S+ \S+ \S+ \[--------\] )(\S+)/$1@{[$2 - $val]}/g' |
+	perl -npe '
+		s|^(.*?) (\d+) (\d+) (\d+)|$1 @{[$2 * 1024 /'$bsize']} @{[$3 * 1024 /'$bsize']} @{[$4 * 1024 /'$bsize']}|'
 }
 
 # The actual point at which limit enforcement takes place for the

@@ -70,9 +74,10 @@ _filter_and_check_blks()
 		if (/^\#'$id'\s+(\d+)/ && '$enforce') {
 			$maximum = '$bhard';
 			$minimum = '$bhard' * 85/100;
-			if (($1 < $minimum || $1 > $maximum) && '$noextsz') {
+			$used = $1 * 1024;
+			if (($used < $minimum || $used > $maximum) && '$noextsz') {
 				printf(" URK %d: %d is out of range! [%d,%d]\n",
-					'$id', $1, $minimum, $maximum);
+					'$id', $used, $minimum, $maximum);
 			}
 			s/^(\#'$id'\s+)(\d+)/\1 =OK=/g;
 		}

@@ -132,7 +137,7 @@ _exercise()
 	echo "ls -l $SCRATCH_MNT" >>$seqres.full
 	ls -l $SCRATCH_MNT >>$seqres.full
 	xfs_quota -D $tmp.projects -P $temp.projid -x \
-		-c "limit -$type bsoft=${bsoft}k bhard=${bhard}k $id" \
+		-c "limit -$type bsoft=${bsoft} bhard=${bhard} $id" \
 		-c "limit -$type isoft=$isoft ihard=$ihard $id" \
 		$SCRATCH_DEV
 	xfs_quota -D $tmp.projects -P $tmp.projid -x \

@@ -152,7 +157,7 @@ _exercise()
 
 	echo
 	echo "*** push past the soft block limit" | tee -a $seqres.full
-	_file_as_id $SCRATCH_MNT/softie $id $type 1024 140
+	_file_as_id $SCRATCH_MNT/softie $id $type $bsize 35
 	_qmount
 	xfs_quota -D $tmp.projects -P $tmp.projid -x \
 		-c "repquota -birnN -$type" $SCRATCH_DEV |

@@ -173,7 +178,7 @@ _exercise()
 	echo
 	# Note: for quota accounting (not enforcement), EDQUOT is not expected
 	echo "*** push past the hard block limit (expect EDQUOT)" | tee -a $seqres.full
-	_file_as_id $SCRATCH_MNT/softie $id $type 1024 540
+	_file_as_id $SCRATCH_MNT/softie $id $type $bsize 135
 	echo "ls -l $SCRATCH_MNT" >>$seqres.full
 	ls -l $SCRATCH_MNT >>$seqres.full
 	_qmount

tests/xfs/050.out +30 ~~-30~~

167 lines not on this page · raw message

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #4 lore raw

PATCH 4/16 Fix xfs/074 to work with 64k block size

In reply to Chandan Rajendra

This commit makes file and extent size calculations to be a function of the filesystem's block size. It also adds a brief description of the bug that is being tested.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/074 | 23 +++++++++++++++++++----
 1 file changed, 19 insertions(+), 4 deletions(-)

tests/xfs/074 +19 -4

index e5888d5..39b04f4 100755
@@ -7,6 +7,18 @@
 # Check some extent size hint boundary conditions that can result in
 # MAXEXTLEN overflows.
 #
+# In xfs_bmap_extsize_align(), we had,
+# 	if ((temp = (align_alen % extsz))) {
+# 		align_alen += extsz - temp;
+# 	}
+# align_alen had the value of 2097151 (i.e. MAXEXTLEN) blocks. extsz had
+# the value of 4096 blocks.
+#
+# align_alen % extsz will be 4095. so align_alen will end up having
+# 2097151 + (4096 - 4095) = 2097152 i.e. (MAXEXTLEN + 1). Thus the length
+# of the new extent will be larger than MAXEXTLEN. This will later cause
+# the bmbt leaf to have an entry whose length is set to zero block count.
+#
 seq=`basename $0`
 seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"

@@ -40,25 +52,28 @@ _require_xfs_io_command "falloc"
 # without having to care about the underlying device size.
 _require_loop
 
+BLOCK_SIZE=$(_get_block_size $TEST_DIR)
+
 LOOP_FILE=$TEST_DIR/$seq.img
 LOOP_MNT=$TEST_DIR/$seq.mnt
 mkdir -p $LOOP_MNT
 $XFS_IO_PROG -ft -c "truncate 1t" $LOOP_FILE >> $seqres.full
 LOOP_DEV=`_create_loop_device $LOOP_FILE`
 
-_mkfs_dev -d size=156452m,agcount=4 -l size=32m $LOOP_DEV
+_mkfs_dev -d size=260g,agcount=2 $LOOP_DEV
 _mount $LOOP_DEV $LOOP_MNT
 
 # Corrupt the BMBT by creating extents larger than MAXEXTLEN
+# For 4k blocksize, MAXEXTLEN * 4k = 2097151 * 4k = 8589930496 = ~8GiB
 $XFS_IO_PROG -ft \
-	-c "extsize 16m" \
-	-c "falloc 0 30g" \
+	-c "extsize $(($BLOCK_SIZE * 4096))" \
+	-c "falloc 0 $(($BLOCK_SIZE * 2097152))" \
 	$LOOP_MNT/foo >> $seqres.full
 
 umount $LOOP_MNT
 _check_xfs_filesystem $LOOP_DEV none none
 
-_mkfs_dev -f -l size=32m $LOOP_DEV
+_mkfs_dev -f $LOOP_DEV
 _mount $LOOP_DEV $LOOP_MNT
 
 # check we trim both ends of the extent approproiately; this will fail

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:23 UTC #5 lore raw

PATCH 5/16 Fix xfs/127 to work with 64k block size

In reply to Chandan Rajendra

With reflink feature enabled, we require atleast 500MiB of disk space to create a filesystem with 64k block size. Hence this commit sets the size of the scratch filesystem to 512MiB.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/127 | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

tests/xfs/127 +1 -1

index 41dacd7..6a95026 100755
@@ -34,7 +34,7 @@ _require_no_large_scratch_dev
 _require_cp_reflink
 
 echo "Format and mount"
-_scratch_mkfs_sized $((2 * 4096 * 4096)) > $seqres.full 2>&1
+_scratch_mkfs_sized $((512 * 1024 * 1024)) > $seqres.full 2>&1
 _scratch_mount >> $seqres.full 2>&1
 
 testdir=$SCRATCH_MNT/test-$seq

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #6 lore raw

PATCH 6/16 Fix xfs/139 to work with 64k block size

In reply to Chandan Rajendra

For 64k block size, the agsize provided in the test causes mkfs.xfs to fail due to insufficient log space. Hence this commit computes agsize based on block size of the filesystem.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/139     | 12 ++++++------
 tests/xfs/139.out |  8 ++++++--
 2 files changed, 12 insertions(+), 8 deletions(-)

tests/xfs/139 +6 -6

index 2a26635..faeeada 100755
@@ -34,17 +34,17 @@ _require_cp_reflink
 
 rm -f $seqres.full
 
+blksz=$(_get_block_size $TEST_DIR)
+
 echo "Format and mount"
-_scratch_mkfs -d agsize=$((32 * 1048576)) > $seqres.full 2>&1
+_scratch_mkfs -d agsize=$((4400 * $blksz)) > $seqres.full 2>&1
 _scratch_mount >> $seqres.full 2>&1
 
 testdir=$SCRATCH_MNT/test-$seq
 mkdir $testdir
-blksz="$(_get_block_size $testdir)"
 
 echo "Create the original files"
-sz=$((48 * 1048576))
-nr=$((sz / blksz))
+sz=$((4800 * $blksz))
 _pwrite_byte 0x61 0 $sz $testdir/file1 >> $seqres.full
 _cp_reflink $testdir/file1 $testdir/file2 >> $seqres.full
 _scratch_cycle_mount

@@ -54,8 +54,8 @@ _pwrite_byte 0x62 0 $sz $testdir/file1 >> $seqres.full
 _scratch_cycle_mount
 
 echo "Compare files"
-md5sum $testdir/file1 | _filter_scratch
-md5sum $testdir/file2 | _filter_scratch
+od -t x1 $testdir/file1 | _filter_od
+od -t x1 $testdir/file2 | _filter_od
 #filefrag -v $testdir/file1 $testdir/file2
 
 # success, all done

tests/xfs/139.out +6 -2

index dc6a31e..55e03d6 100644
@@ -3,5 +3,9 @@ Format and mount
 Create the original files
 CoW every other block
 Compare files
-673c759fb131ccf3336c4f8c549a497e  SCRATCH_MNT/test-139/file1
-dc802351f6717547cbf4c951b294f952  SCRATCH_MNT/test-139/file2
+0 62 62 62 62 62 62 62 62 62 62 62 62 62 62 62 62
+*
+11300
+0 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61 61
+*
+11300

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #7 lore raw

PATCH 7/16 Fix xfs/140 to work with 64k block size

In reply to Chandan Rajendra

For 64k block size, the agsize provided in the test causes mkfs.xfs to fail due to insufficient log space. Hence this commit computes agsize based on block size of the filesystem.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/140 | 9 +++++----
 1 file changed, 5 insertions(+), 4 deletions(-)

tests/xfs/140 +5 -4

index 6e89fe3..a5d16ce 100755
@@ -34,17 +34,18 @@ _require_cp_reflink
 
 rm -f $seqres.full
 
+blksz=$(_get_block_size $TEST_DIR)
+
 echo "Format and mount"
-_scratch_mkfs -d agsize=$((32 * 1048576)) > $seqres.full 2>&1
+_scratch_mkfs -d agsize=$((4400 * $blksz)) > $seqres.full 2>&1
 _scratch_mount >> $seqres.full 2>&1
 
 testdir=$SCRATCH_MNT/test-$seq
 mkdir $testdir
-blksz=$(_get_block_size $testdir)
 
 echo "Create the original files"
-sz=$((48 * 1048576))
-nr=$((sz / blksz))
+nr=4800
+sz=$(($nr * $blksz))
 _pwrite_byte 0x61 0 $sz $testdir/file1 >> $seqres.full
 _cp_reflink $testdir/file1 $testdir/file2 >> $seqres.full
 _pwrite_byte 0x61 0 $sz $testdir/file2.chk >> $seqres.full

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #8 lore raw

PATCH 8/16 Fix xfs/190 to work with 64k block size

In reply to Chandan Rajendra

This commit describes "file hole" ranges in multiples of block sizes rather than using constants.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/190 | 44 +++++++++++++++++++++++++++++++++++---------
 1 file changed, 35 insertions(+), 9 deletions(-)

tests/xfs/190 +35 -9

index 3275e29..7ee7552 100755
@@ -10,13 +10,24 @@
 #
 # PV 985792
 #
-#This is the list of holes to punch in the file limited to $filesize
-#NOTE holes cannot overlap or this script will fail.
-holes="4096:4096 303104:4096 1048576:512 1051648:8192 1065984:8192 1085440:7168"
-#filesize in MB
-filesize=10
-#Name of file to perform the test on
-filename=test-190
+#-----------------------------------------------------------------------
+# Copyright (c) 2008 Silicon Graphics, Inc.  All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it would be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write the Free Software Foundation,
+# Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
+#
+#-----------------------------------------------------------------------
+#
 
 seq=`basename $0`
 seqres=$RESULT_DIR/$seq

@@ -38,9 +49,24 @@ _supported_os Linux
 _require_scratch
 _scratch_mkfs_xfs >/dev/null 2>&1
 _scratch_mount
-fsblocksize=`$XFS_INFO_PROG $SCRATCH_MNT|sed 's/=/ /g'|awk '/^data / { print $3 }'`
 
-dd if=/dev/zero of=$SCRATCH_MNT/$filename bs=1024k count=10 >> $seqres.full 2>&1
+fsblocksize=$(_get_block_size $TEST_DIR)
+
+#This is the list of holes to punch in the file limited to $filesize
+#NOTE holes cannot overlap or this script will fail.
+holes="$fsblocksize:$fsblocksize \
+$(($fsblocksize * 74)):$fsblocksize \
+$(($fsblocksize * 256)):$(($fsblocksize / 8)) \
+$(echo scale=0\;$fsblocksize \* 256 \+ $fsblocksize \* 3 \/ 4 | bc):$(($fsblocksize * 2)) \
+$(echo scale=0\;$fsblocksize \* 260 \+ $fsblocksize \* 1 \/ 4 | bc):$(($fsblocksize * 2)) \
+$(($fsblocksize * 265)):$(echo scale=0\;$fsblocksize \+ $fsblocksize \* 3 \/ 4 | bc)"
+
+#filesize
+filesize=$(($fsblocksize * 2560))
+#Name of file to perform the test on
+filename=test-190
+
+$XFS_IO_PROG -f -c "pwrite 0 $(($fsblocksize * 2560))" $SCRATCH_MNT/$filename >> $seqres.full 2>&1
 
 # run DMAPI test using verbose output
 echo Punching holes in file

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #9 lore raw

PATCH 9/16 Fix xfs/299 to work with 64k block size

In reply to Chandan Rajendra

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/299     | 23 +++++++++++++--------
 tests/xfs/299.out | 60 +++++++++++++++++++++++++++----------------------------
 2 files changed, 45 insertions(+), 38 deletions(-)

tests/xfs/299 +15 -8

index f0012ff..99e1567 100755
@@ -41,8 +41,10 @@ _require_xfs_quota
 _require_xfs_mkfs_crc
 _require_xfs_crc
 
-bsoft=100
-bhard=500
+bsize=$(_get_block_size $TEST_DIR)
+
+bsoft=$(( 25 * $bsize ))
+bhard=$(( 125 * $bsize ))
 isoft=4
 ihard=10

@@ -58,7 +60,9 @@ _filter_report()
 		if ($ENV{'LARGE_SCRATCH_DEV'}) {
 			$val = $ENV{'NUM_SPACE_FILES'};
 		}
-		s/(^\[ROOT\] \S+ \S+ \S+ \S+ \[--------\] )(\S+)/$1@{[$2 - $val]}/g'
+		s/(^\[ROOT\] \S+ \S+ \S+ \S+ \[--------\] )(\S+)/$1@{[$2 - $val]}/g' |
+	perl -npe '
+		s|^(.*?) (\d+) (\d+) (\d+)|$1 @{[$2 * 1024 /'$bsize']} @{[$3 * 1024 /'$bsize']} @{[$4 * 1024 /'$bsize']}|'
 }
 
 # The actual point at which limit enforcement takes place for the

@@ -73,9 +77,10 @@ _filter_and_check_blks()
 		if (/^\#'$id'\s+(\d+)/ && '$enforce') {
 			$maximum = '$bhard';
 			$minimum = '$bhard' * 85/100;
-			if (($1 < $minimum || $1 > $maximum) && '$noextsz') {
+			$used = $1 * 1024;
+			if (($used < $minimum || $used > $maximum) && '$noextsz') {
 				printf(" URK %d: %d is out of range! [%d,%d]\n",
-					'$id', $1, $minimum, $maximum);
+					'$id', $used, $minimum, $maximum);
 			}
 			s/^(\#'$id'\s+)(\d+)/\1 =OK=/g;
 		}

@@ -128,7 +133,7 @@ _exercise()
 	echo "ls -l $SCRATCH_MNT" >>$seqres.full
 	ls -l $SCRATCH_MNT >>$seqres.full
 	xfs_quota -D $tmp.projects -P $tmp.projid -x \
-		-c "limit -$type bsoft=${bsoft}k bhard=${bhard}k $id" \
+		-c "limit -$type bsoft=${bsoft} bhard=${bhard} $id" \
 		-c "limit -$type isoft=$isoft ihard=$ihard $id" \
 		$SCRATCH_DEV
 	xfs_quota -D $tmp.projects -P $tmp.projid -x \

@@ -139,6 +144,8 @@ _exercise()
 	echo "*** push past the soft inode limit" | tee -a $seqres.full
 	_file_as_id $SCRATCH_MNT/softie1 $id $type 1024 0
 	_file_as_id $SCRATCH_MNT/softie2 $id $type 1024 0
+	_file_as_id $SCRATCH_MNT/softie3 $id $type 1024 0
+	_file_as_id $SCRATCH_MNT/softie4 $id $type 1024 0
 	_qmount
 	xfs_quota -D $tmp.projects -P $tmp.projid -x \
 		-c "repquota -birnN -$type" $SCRATCH_DEV |

@@ -146,7 +153,7 @@ _exercise()
 
 	echo
 	echo "*** push past the soft block limit" | tee -a $seqres.full
-	_file_as_id $SCRATCH_MNT/softie $id $type 1024 140
+	_file_as_id $SCRATCH_MNT/softie $id $type $bsize 35
 	_qmount
 	xfs_quota -D $tmp.projects -P $tmp.projid -x \
 		-c "repquota -birnN -$type" $SCRATCH_DEV |

@@ -167,7 +174,7 @@ _exercise()
 	echo
 	# Note: for quota accounting (not enforcement), EDQUOT is not expected
 	echo "*** push past the hard block limit (expect EDQUOT)" | tee -a $seqres.full
-	_file_as_id $SCRATCH_MNT/softie $id $type 1024 540
+	_file_as_id $SCRATCH_MNT/softie $id $type $bsize 135
 	echo "ls -l $SCRATCH_MNT" >>$seqres.full
 	ls -l $SCRATCH_MNT >>$seqres.full
 	_qmount

tests/xfs/299.out +30 ~~-30~~

167 lines not on this page · raw message

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #10 lore raw

PATCH 10/16 xfs/325: Inject free_extent error after CoW operation

In reply to Chandan Rajendra

On a 64k blocksized filesystem, when the test CoWs the file2's offset range [10 * 64k, 19 * 64k], the call to xfs_bmapi_reserve_delalloc() allocates 32 64k blocks. This is because XFS_DEFAULT_COWEXTSZ_HINT has the value of 32 and xfs_get_cowextsz_hint() uses this to compute the extent alignment. This leads to xfs_bmapi_reserve_delalloc() to reserve space corresponding to the file range [0, 32 * 64k] in the inode's cow fork area. On completion of write I/O corresponding to file2's range [10 * 64k, 19 * 64k], xfs_end_io() moves 10 out of the originally allocated 32 64k blocks to the data fork area. The remaining 22 64k blocks linger on in cow fork area of the inode.

Later, when servicing the exit() syscall for the xfs_io process, xfs_free_eofblocks() ends up invoking xfs_reflink_cancel_cow_blocks() since i_delayed_blks has the value 22. xfs_reflink_cancel_cow_blocks() indirectly invokes __xfs_free_extent() which returns EIO since XFS_ERRTAG_FREE_EXTENT has been set. This leads to the filesystem to be shutdown. The "rm" command invoked later ends up returning an error and hence the test fails. The test actually requires that the filesystem gets shutdown when executing the "rm" command.

To fix the problem, this commit injects the free_extent error after we CoW file2's [10 * 64k, 19 * 64k] range.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/xfs/325     | 5 +++--
 tests/xfs/325.out | 2 +-
 2 files changed, 4 insertions(+), 3 deletions(-)

tests/xfs/325 +3 -2

index b156de9..6795901 100755
@@ -54,11 +54,12 @@ echo "Check files"
 md5sum $SCRATCH_MNT/file1 | _filter_scratch
 md5sum $SCRATCH_MNT/file2 | _filter_scratch
 
+echo "CoW a few blocks"
+$XFS_IO_PROG -c "pwrite -W -S 0x67 $((10 * blksz)) $((10 * blksz))" $SCRATCH_MNT/file2 >> $seqres.full
+
 echo "Inject error"
 _scratch_inject_error "free_extent"
 
-echo "CoW a few blocks"
-$XFS_IO_PROG -c "pwrite -W -S 0x67 $((10 * blksz)) $((10 * blksz))" $SCRATCH_MNT/file2 >> $seqres.full
 rm $SCRATCH_MNT/file1
 sync

tests/xfs/325.out +1 -1

index 4e25d2b..92027cd 100644
@@ -4,8 +4,8 @@ Create files
 Check files
 d5a0ed0305c8df4180cb2bf975ecffe8  SCRATCH_MNT/file1
 d5a0ed0305c8df4180cb2bf975ecffe8  SCRATCH_MNT/file2
-Inject error
 CoW a few blocks
+Inject error
 FS should be shut down, touch will fail
 touch: cannot touch 'SCRATCH_MNT/badfs': Input/output error
 Remount to replay log

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #11 lore raw

PATCH 11/16 Fix generic/102 to work with 64k block size

In reply to Chandan Rajendra

With 64k block size, mkfs.xfs fails with the following message when the filesystem size is 512MiB in size,

"log size 2037 blocks too small, minimum size is 2473 blocks"

Hence this commit increases the test filesystem size to 1GiB. Also, the size of the test file is increased to 800MiB which is ~80% of the test filesystem size. This is in proportion to the 400MiB test file used with the original 512MiB test filesystem.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/generic/102     |  4 ++--
 tests/generic/102.out | 20 ++++++++++----------
 2 files changed, 12 insertions(+), 12 deletions(-)

tests/generic/102 +2 -2

index faf940a..29abd89 100755
@@ -31,14 +31,14 @@ _require_scratch
 
 rm -f $seqres.full
 
-dev_size=$((512 * 1024 * 1024))     # 512MB filesystem
+dev_size=$((1024 * 1024 * 1024))     # 1GB filesystem
 _scratch_mkfs_sized $dev_size >>$seqres.full 2>&1
 _scratch_mount
 
 for ((i = 0; i < 10; i++)); do
 	echo "loop $i" >>$seqres.full
 
-	$XFS_IO_PROG -f -c "pwrite -b 1m 0 400m" "$SCRATCH_MNT"/file | \
+	$XFS_IO_PROG -f -c "pwrite -b 1m 0 800m" "$SCRATCH_MNT"/file | \
 _filter_xfs_io | _filter_scratch
 
 	rm -f "$SCRATCH_MNT"/file

tests/generic/102.out +10 ~~-10~~

index fc9275d..b58aa5c 100644
@@ -1,21 +1,21 @@
 QA output created by 102
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-wrote 419430400/419430400 bytes at offset 0
+wrote 838860800/838860800 bytes at offset 0
 XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #12 lore raw

PATCH 12/16 Fix generic/172 to work with 64k block size

In reply to Chandan Rajendra

For 64k block size, With 256MiB as the XFS filesystem size and 168 MiB as the size of the clone source file, we end up hitting ENOSPC when cloning the source file. This happens due to lack of space for housing the corresponding metadata. This scenario also occurs when using a 512MiB XFS filesystem and 300MiB clone source file.

Hence this commit increases the size of the test filesystem to 1 GiB and the size of the clone source file to 768MiB.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/generic/172 | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

tests/generic/172 +2 -2

index 5d6f295..08d2789 100755
@@ -47,8 +47,8 @@ echo "Reformat with appropriate size"
 blksz="$(_get_block_size $testdir)"
 umount $SCRATCH_MNT
 
-file_size=$((168 * 1024 * 1024))
-fs_size=$((256 * 1024 * 1024))
+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

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #13 lore raw

PATCH 13/16 Filter fiemap output by FS block size

In reply to Chandan Rajendra

When testing FS instances of block size other than 4k, the output of fiemap command will not match those in *.out files. This commit adds an optional "block size" argument to _filter_fiemap() which prints fiemap output in units of block size.

Signed-off-by Chandan Rajendra <[email protected]>

---
 common/punch | 19 ++++++++++++++-----
 1 file changed, 14 insertions(+), 5 deletions(-)

common/punch +14 -5

index 8088b01..0fc7729 100644
@@ -165,7 +165,11 @@ _test_punch() {
 
 _coalesce_extents()
 {
-	awk -F: '
+	block_size=$1
+
+	[[ -z $block_size ]] && block_size=512
+
+	awk -v block_size="$block_size" -F: '
 	{
 		range = $2;
 		type = $3;

@@ -176,19 +180,24 @@ _coalesce_extents()
 
 		if (type != prev_type) {
 			if (prev_type != "")
-				printf("%u]:%s\n", low - 1, prev_type);
-			printf("%u: [%u..", out_count++, low);
+				printf("%u]:%s\n", (low * 512 / block_size) - 1,
+					prev_type);
+			printf("%u: [%u..", out_count++,
+				(low * 512) / block_size);
 			prev_type = type;
 		}
 	}
 	END {
 		if (prev_type != "")
-			printf("%u]:%s\n", high, prev_type);
+			printf("%u]:%s\n", ((high + 1) * 512 / block_size) - 1,
+				prev_type);
 	}'
 }
 
 _filter_fiemap()
 {
+	block_size=$1
+
 	$AWK_PROG '
 		$3 ~ /hole/ {
 			print $1, $2, $3;

@@ -201,7 +210,7 @@ _filter_fiemap()
 		$5 ~ /0x[[:xdigit:]]+/ {
 			print $1, $2, "data";
 		}' |
-	_coalesce_extents
+	_coalesce_extents $block_size
 }
 
 _filter_fiemap_flags()

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #14 lore raw

PATCH 14/16 Fix generic/177 to work with 64k block size

In reply to Chandan Rajendra

This commit changes the test to work on file offsets that are aligned with the block size of the underlying filesystem.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/generic/177     | 20 +++++++++++---------
 tests/generic/177.out | 23 +++++++++++++++--------
 2 files changed, 26 insertions(+), 17 deletions(-)

tests/generic/177 +11 -9

index 36577b1..c0b79dd 100755
@@ -45,44 +45,46 @@ _require_metadata_journaling $SCRATCH_DEV
 _init_flakey
 _mount_flakey
 
+BLOCK_SIZE=$(_get_block_size $TEST_DIR)
+
 # Create out test file with some data and then fsync it.
 # We do the fsync only to make sure the last fsync we do in this test triggers
 # the fast code path of btrfs' fsync implementation, a condition necessary to
 # trigger the bug btrfs had.
-$XFS_IO_PROG -f -c "pwrite -S 0xaa 0K 128K" \
+$XFS_IO_PROG -f -c "pwrite -S 0xaa 0K $(($BLOCK_SIZE * 32))" \
 		-c "fsync"                  \
-		$SCRATCH_MNT/foobar | _filter_xfs_io
+		$SCRATCH_MNT/foobar | _filter_xfs_io_blocks_modified
 
 # Now punch a hole against the range [96K, 128K[.
-$XFS_IO_PROG -c "fpunch 96K 32K" $SCRATCH_MNT/foobar
+$XFS_IO_PROG -c "fpunch $(($BLOCK_SIZE * 24)) $(($BLOCK_SIZE * 8))" $SCRATCH_MNT/foobar
 
 # Punch another hole against a range that overlaps the previous range and ends
 # beyond eof.
-$XFS_IO_PROG -c "fpunch 64K 128K" $SCRATCH_MNT/foobar
+$XFS_IO_PROG -c "fpunch $(($BLOCK_SIZE * 16)) $(($BLOCK_SIZE * 32))" $SCRATCH_MNT/foobar
 
 # Punch another hole against a range that overlaps the first range ([96K, 128K[)
 # and ends at eof.
-$XFS_IO_PROG -c "fpunch 32K 96K" $SCRATCH_MNT/foobar
+$XFS_IO_PROG -c "fpunch $(($BLOCK_SIZE * 8)) $(($BLOCK_SIZE * 24))" $SCRATCH_MNT/foobar
 
 # Fsync our file. We want to verify that, after a power failure and mounting the
 # filesystem again, the file content reflects all the hole punch operations.
 $XFS_IO_PROG -c "fsync" $SCRATCH_MNT/foobar
 
 echo "File digest before power failure:"
-md5sum $SCRATCH_MNT/foobar | _filter_scratch
+od -t x1 $SCRATCH_MNT/foobar | _filter_od
 
 echo "Fiemap before power failure:"
-$XFS_IO_PROG -c "fiemap -v" $SCRATCH_MNT/foobar | _filter_fiemap
+$XFS_IO_PROG -c "fiemap -v" $SCRATCH_MNT/foobar | _filter_fiemap $BLOCK_SIZE
 
 _flakey_drop_and_remount
 
 echo "File digest after log replay:"
 # Must match the same digest we got before the power failure.
-md5sum $SCRATCH_MNT/foobar | _filter_scratch
+od -t x1 $SCRATCH_MNT/foobar | _filter_od
 
 echo "Fiemap after log replay:"
 # Must match the same extent listing we got before the power failure.
-$XFS_IO_PROG -c "fiemap -v" $SCRATCH_MNT/foobar | _filter_fiemap
+$XFS_IO_PROG -c "fiemap -v" $SCRATCH_MNT/foobar | _filter_fiemap $BLOCK_SIZE
 
 _unmount_flakey

tests/generic/177.out +15 -8

index cc10768..b47e136 100644
@@ -1,13 +1,20 @@
 QA output created by 177
-wrote 131072/131072 bytes at offset 0
-XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+Blocks modified: [0 - 31]
 File digest before power failure:
-d26bbb9a8396a9c0dd76423471b72b15  SCRATCH_MNT/foobar
+0 aa aa aa aa aa aa aa aa aa aa aa aa aa aa aa aa
+*
+10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+*
+40
 Fiemap before power failure:
-0: [0..63]: data
-1: [64..255]: hole
+0: [0..7]: data
+1: [8..31]: hole
 File digest after log replay:
-d26bbb9a8396a9c0dd76423471b72b15  SCRATCH_MNT/foobar
+0 aa aa aa aa aa aa aa aa aa aa aa aa aa aa aa aa
+*
+10 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00 00
+*
+40
 Fiemap after log replay:
-0: [0..63]: data
-1: [64..255]: hole
+0: [0..7]: data
+1: [8..31]: hole

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #15 lore raw

PATCH 15/16 Fix generic/230 to work with 64k block size

In reply to Chandan Rajendra

This commit changes the test to work on file offsets that are aligned with the block size of the underlying filesystem.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/generic/230     | 24 ++++++++++++++----------
 tests/generic/230.out | 16 ++++++++--------
 2 files changed, 22 insertions(+), 18 deletions(-)

tests/generic/230 +14 ~~-10~~

index bc8c1ad..0add028 100755
@@ -28,6 +28,8 @@ _require_scratch
 _require_quota
 _require_user
 
+BLOCK_SIZE=$(_get_block_size $TEST_DIR)
+
 test_files()
 {
 	echo; echo "### create files, setting up ownership (type=$type)"

@@ -42,27 +44,27 @@ test_enforcement()
 	echo "### some buffered IO (type=$type)"
 	echo "--- initiating IO..." >>$seqres.full
 	# Firstly fit below block soft limit
-	echo "Write 900k..."
-	su $qa_user -c "$XFS_IO_PROG -c 'pwrite 0 900k' -c fsync \
+	echo "Write 225 blocks..."
+	su $qa_user -c "$XFS_IO_PROG -c 'pwrite 0 $((225 * $BLOCK_SIZE))' -c fsync \
 		$SCRATCH_MNT/file1" 2>&1 >>$seqres.full | \
 		_filter_xfs_io_error | tee -a $seqres.full
 	repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
 	# Secondly overcome block soft limit
-	echo "Rewrite 1001k..."
-	su $qa_user -c "$XFS_IO_PROG -c 'pwrite 0 1001k' -c fsync \
+	echo "Rewrite 250 blocks plus 1 byte..."
+	su $qa_user -c "$XFS_IO_PROG -c 'pwrite 0 $((250 * $BLOCK_SIZE + 1))' -c fsync \
 		$SCRATCH_MNT/file1" 2>&1 >>$seqres.full | \
 		_filter_xfs_io_error | tee -a $seqres.full
 	repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
 	# Now try to overcome block hardlimit
-	echo "Write 1000k..."
-	su $qa_user -c "$XFS_IO_PROG -c 'pwrite 0 1000k' -c fsync \
+	echo "Write 250 blocks..."
+	su $qa_user -c "$XFS_IO_PROG -c 'pwrite 0 $((250 * $BLOCK_SIZE))' -c fsync \
 		$SCRATCH_MNT/file2" 2>&1 >>$seqres.full | \
 		_filter_xfs_io_error | tee -a $seqres.full
 	repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
 	# Now sleep for grace time and check that softlimit got enforced
 	sleep $((grace+1))
-	echo "Write 4096..."
-	su $qa_user -c "$XFS_IO_PROG -c 'truncate 0' -c 'pwrite 0 4096' \
+	echo "Write 1 block..."
+	su $qa_user -c "$XFS_IO_PROG -c 'truncate 0' -c 'pwrite 0 $BLOCK_SIZE' \
 		$SCRATCH_MNT/file2" 2>&1 >>$seqres.full | \
 		_filter_xfs_io_error | tee -a $seqres.full
 	repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1

@@ -103,9 +105,11 @@ _scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
 quotaon $SCRATCH_MNT 2>/dev/null
-setquota -u $qa_user 1000 2000 3 5 $SCRATCH_MNT
+setquota -u $qa_user $((250 * $BLOCK_SIZE / 1024)) \
+	 $((500 * $BLOCK_SIZE / 1024)) 3 5 $SCRATCH_MNT
 setquota -u -t $grace $grace $SCRATCH_MNT
-setquota -g $qa_user 1000 2000 3 5 $SCRATCH_MNT
+setquota -g $qa_user $((250 * $BLOCK_SIZE / 1024)) \
+	 $((500 * $BLOCK_SIZE / 1024)) 3 5 $SCRATCH_MNT
 setquota -g -t $grace $grace $SCRATCH_MNT
 _scratch_unmount

tests/generic/230.out +8 -8

index fcbacf2..9e89a47 100644
@@ -4,11 +4,11 @@ QA output created by 230
 
 ### create files, setting up ownership (type=u)
 ### some buffered IO (type=u)
-Write 900k...
-Rewrite 1001k...
-Write 1000k...
+Write 225 blocks...
+Rewrite 250 blocks plus 1 byte...
+Write 250 blocks...
 pwrite: Disk quota exceeded
-Write 4096...
+Write 1 block...
 pwrite: Disk quota exceeded
 Touch 3+4
 Touch 5+6

@@ -20,11 +20,11 @@ touch: cannot touch 'SCRATCH_MNT/file5': Disk quota exceeded
 
 ### create files, setting up ownership (type=g)
 ### some buffered IO (type=g)
-Write 900k...
-Rewrite 1001k...
-Write 1000k...
+Write 225 blocks...
+Rewrite 250 blocks plus 1 byte...
+Write 250 blocks...
 pwrite: Disk quota exceeded
-Write 4096...
+Write 1 block...
 pwrite: Disk quota exceeded
 Touch 3+4
 Touch 5+6

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 10:22 UTC #16 lore raw

PATCH 16/16 Fix generic/235 to work with 64k block size

In reply to Chandan Rajendra

With 64k blocksized filesystem, this test fails since a single 8k write will actually end up consuming 64k. Hence this commit writes 64k data into the test file.

Signed-off-by Chandan Rajendra <[email protected]>

---
 tests/generic/235     | 2 +-
 tests/generic/235.out | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

tests/generic/235 +1 -1

index 902e9ad..6adc803 100755
@@ -55,7 +55,7 @@ _try_scratch_mount "-o remount,ro" 2>&1 | tee -a $seqres.full | _filter_scratch
 touch $SCRATCH_MNT/failed 2>&1 | tee -a $seqres.full | _filter_scratch
 _try_scratch_mount "-o remount,rw" 2>&1 | tee -a $seqres.full | _filter_scratch
 
-$XFS_IO_PROG -c 'pwrite 0 8k' -c 'fsync' \
+$XFS_IO_PROG -c 'pwrite 0 64k' -c 'fsync' \
 			$SCRATCH_MNT/testfile >>$seqres.full 2>&1
 do_repquota

tests/generic/235.out +2 -2

index 601fa2f..abcb47a 100644
@@ -17,10 +17,10 @@ Block grace time: 7days; Inode grace time: 7days
                         Block limits                File limits
 User            used    soft    hard  grace    used  soft  hard  grace
 ----------------------------------------------------------------------
-fsgqa     --       8       0       0              1     0     0       
+fsgqa     --      64       0       0              1     0     0       
 *** Report for group quotas on device SCRATCH_DEV
 Block grace time: 7days; Inode grace time: 7days
                         Block limits                File limits
 Group           used    soft    hard  grace    used  soft  hard  grace
 ----------------------------------------------------------------------
-fsgqa     --       8       0       0              1     0     0       
+fsgqa     --      64       0       0              1     0     0

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-08-16 12:49 UTC #17 lore raw

PATCH RESEND 1/1 Fix xfs/190 to work with 64k block size

In reply to Chandan Rajendra

This commit describes "file hole" ranges in multiples of block sizes rather than using constants.

Signed-off-by Chandan Rajendra <[email protected]>

---
Changelog:
Removed the license header that was accidently added during Git rebase.

 tests/xfs/190 | 26 +++++++++++++++++---------
 1 file changed, 17 insertions(+), 9 deletions(-)

tests/xfs/190 +17 -9

index 3275e29..917b594 100755
@@ -10,13 +10,6 @@
 #
 # PV 985792
 #
-#This is the list of holes to punch in the file limited to $filesize
-#NOTE holes cannot overlap or this script will fail.
-holes="4096:4096 303104:4096 1048576:512 1051648:8192 1065984:8192 1085440:7168"
-#filesize in MB
-filesize=10
-#Name of file to perform the test on
-filename=test-190
 
 seq=`basename $0`
 seqres=$RESULT_DIR/$seq

@@ -38,9 +31,24 @@ _supported_os Linux
 _require_scratch
 _scratch_mkfs_xfs >/dev/null 2>&1
 _scratch_mount
-fsblocksize=`$XFS_INFO_PROG $SCRATCH_MNT|sed 's/=/ /g'|awk '/^data / { print $3 }'`
 
-dd if=/dev/zero of=$SCRATCH_MNT/$filename bs=1024k count=10 >> $seqres.full 2>&1
+fsblocksize=$(_get_block_size $TEST_DIR)
+
+#This is the list of holes to punch in the file limited to $filesize
+#NOTE holes cannot overlap or this script will fail.
+holes="$fsblocksize:$fsblocksize \
+$(($fsblocksize * 74)):$fsblocksize \
+$(($fsblocksize * 256)):$(($fsblocksize / 8)) \
+$(echo scale=0\;$fsblocksize \* 256 \+ $fsblocksize \* 3 \/ 4 | bc):$(($fsblocksize * 2)) \
+$(echo scale=0\;$fsblocksize \* 260 \+ $fsblocksize \* 1 \/ 4 | bc):$(($fsblocksize * 2)) \
+$(($fsblocksize * 265)):$(echo scale=0\;$fsblocksize \+ $fsblocksize \* 3 \/ 4 | bc)"
+
+#filesize
+filesize=$(($fsblocksize * 2560))
+#Name of file to perform the test on
+filename=test-190
+
+$XFS_IO_PROG -f -c "pwrite 0 $(($fsblocksize * 2560))" $SCRATCH_MNT/$filename >> $seqres.full 2>&1
 
 # run DMAPI test using verbose output
 echo Punching holes in file

Signature · 1 line

2.9.5

Eryu Guan

2018-09-01 21:34 UTC #18 lore raw

In reply to Chandan Rajendra

Quoted 8 lines · Chandan Rajendra

This patchset fixes tests (mostly XFS specific ones) to work on variable block size. These patches now use the output of "od" utility to verify the contents of the test files instead of the md5sum utility.
The patchset modifies _filter_fiemap() filter function to optionally print the file offset range in block size units.

Quoted 11 lines

Chandan Rajendra (16):
Fix xfs/009 to work with 64k block size xfs/050: Fix "Push past soft inode limit" case Fix xfs/050 to work with 64k block size
Fix xfs/074 to work with 64k block size
Fix xfs/127 to work with 64k block size
Fix xfs/139 to work with 64k block size
Fix xfs/140 to work with 64k block size
Fix xfs/190 to work with 64k block size
Fix xfs/299 to work with 64k block size xfs/325: Inject free_extent error after CoW operation

I may need helps from XFS folks to review these changes.

But I noticed that you are getting fs block size all from TEST_DIR, even if the test is testing against $SCRATCH_MNT, e.g. xfs/139 xfs/140 (and other tests too). But the fs block size could be different on TEST_DEV and SCRATCH_DEV.

Also, I'd be very helpful if someone could help test this patchset on real hardware that supports mounting 64k blocksize XFS.

Thanks a lot!

Eryu

Quoted 36 lines

Fix generic/102 to work with 64k block size
Fix generic/172 to work with 64k block size
Filter fiemap output by FS block size
Fix generic/177 to work with 64k block size
Fix generic/230 to work with 64k block size
Fix generic/235 to work with 64k block size

 common/punch          | 19 ++++++++---
 tests/generic/102     |  4 +--
 tests/generic/102.out | 20 +++++------
 tests/generic/172     |  4 +--
 tests/generic/177     | 20 ++++++-----
 tests/generic/177.out | 23 ++++++++-----
 tests/generic/230     | 24 ++++++++------
 tests/generic/230.out | 16 ++++-----
 tests/generic/235     |  2 +-
 tests/generic/235.out |  4 +--
 tests/xfs/009         | 92 ++++++++++++++++++++++++++++++++++++++++++---------
 tests/xfs/009.out     | 66 ++++++++++++++++++------------------
 tests/xfs/050         | 23 ++++++++-----
 tests/xfs/050.out     | 60 ++++++++++++++++-----------------
 tests/xfs/074         | 23 ++++++++++---
 tests/xfs/127         |  2 +-
 tests/xfs/139         | 12 +++----
 tests/xfs/139.out     |  8 +++--
 tests/xfs/140         |  9 ++---
 tests/xfs/190         | 44 +++++++++++++++++++-----
 tests/xfs/299         | 23 ++++++++-----
 tests/xfs/299.out     | 60 ++++++++++++++++-----------------
 tests/xfs/325         |  5 +--
 tests/xfs/325.out     |  2 +-
 24 files changed, 355 insertions(+), 210 deletions(-)

Signature · 1 line

2.9.5

Chandan Rajendra

author

2018-09-04 19:52 UTC #19 lore raw

Quoted 21 lines · IST Eryu Guan

Quoted 8 lines · Chandan Rajendra
This patchset fixes tests (mostly XFS specific ones) to work on variable block size. These patches now use the output of "od" utility to verify the contents of the test files instead of the md5sum utility.
The patchset modifies _filter_fiemap() filter function to optionally print the file offset range in block size units.
Quoted 11 lines
Chandan Rajendra (16):
Fix xfs/009 to work with 64k block size xfs/050: Fix "Push past soft inode limit" case Fix xfs/050 to work with 64k block size
Fix xfs/074 to work with 64k block size
Fix xfs/127 to work with 64k block size
Fix xfs/139 to work with 64k block size
Fix xfs/140 to work with 64k block size
Fix xfs/190 to work with 64k block size
Fix xfs/299 to work with 64k block size xfs/325: Inject free_extent error after CoW operation

Quoted 6 lines

I may need helps from XFS folks to review these changes.
But I noticed that you are getting fs block size all from TEST_DIR, even if the test is testing against $SCRATCH_MNT, e.g. xfs/139 xfs/140 (and other tests too). But the fs block size could be different on TEST_DEV and SCRATCH_DEV.

Sure, I will fix that up and send the next version of the patchset.

Quoted 43 lines

Also, I'd be very helpful if someone could help test this patchset on real hardware that supports mounting 64k blocksize XFS.

Thanks a lot!

Eryu

Quoted 33 lines

 common/punch          | 19 ++++++++---
 tests/generic/102     |  4 +--
 tests/generic/102.out | 20 +++++------
 tests/generic/172     |  4 +--
 tests/generic/177     | 20 ++++++-----
 tests/generic/177.out | 23 ++++++++-----
 tests/generic/230     | 24 ++++++++------
 tests/generic/230.out | 16 ++++-----
 tests/generic/235     |  2 +-
 tests/generic/235.out |  4 +--
 tests/xfs/009         | 92 ++++++++++++++++++++++++++++++++++++++++++---------
 tests/xfs/009.out     | 66 ++++++++++++++++++------------------
 tests/xfs/050         | 23 ++++++++-----
 tests/xfs/050.out     | 60 ++++++++++++++++-----------------
 tests/xfs/074         | 23 ++++++++++---
 tests/xfs/127         |  2 +-
 tests/xfs/139         | 12 +++----
 tests/xfs/139.out     |  8 +++--
 tests/xfs/140         |  9 ++---
 tests/xfs/190         | 44 +++++++++++++++++++-----
 tests/xfs/299         | 23 ++++++++-----
 tests/xfs/299.out     | 60 ++++++++++++++++-----------------
 tests/xfs/325         |  5 +--
 tests/xfs/325.out     |  2 +-
 24 files changed, 355 insertions(+), 210 deletions(-)

Signature · 1 line

chandan