* [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode.
@ 2010-08-27 20:33 Akshay Lal
2010-08-27 21:49 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly Eric Sandeen
2010-08-27 23:32 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode Dave Chinner
0 siblings, 2 replies; 14+ messages in thread
From: Akshay Lal @ 2010-08-27 20:33 UTC (permalink / raw)
To: xfs; +Cc: Akshay Lal
Bug reference:
http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
---
243 | 145 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
243.out | 25 +++++++++++
group | 1 +
3 files changed, 171 insertions(+), 0 deletions(-)
create mode 100644 243
create mode 100644 243.out
diff --git a/243 b/243
new file mode 100644
index 0000000..8102f24
--- /dev/null
+++ b/243
@@ -0,0 +1,145 @@
+#! /bin/bash
+# FS QA Test No. 243
+#
+# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
+#
+# As found by Theodore Ts'o:
+# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
+# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
+# This forces e2fsck to complain about that inode.
+#
+# creator
+owner=alal@google.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+tmp=/tmp/$$
+status=1 # failure is the default!
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# Test specific macros.
+BIT_NOT_SET=0 # inode flag - 0x40000 bit is set.
+BIT_SET=1 # inode flag - 0x400000 bit is not set.
+
+# Generic test cleanup function.
+_cleanup()
+{
+ cd /
+ rm -f $tmp.*
+}
+
+# Checks the state of the sample file in the filesystem and returns whether
+# the inode flag 0x400000 is set or not.
+_check_file_state()
+{
+ bit_set=1
+
+ # Check whether EOFBLOCK_FL is set.
+ if [ "${FSTYP}" == "ext4" ]; then
+ # Unmount the ${TEST_DEV}
+ umount ${TEST_DEV}
+
+ # Run debugfs to gather file_parameters - specifically iflags.
+ file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
+ iflags=${file_params#*Flags: }
+
+ # Ensure that the iflags value was parsed correctly.
+ if [ -z ${iflags} ]; then
+ echo "iFlags value was not parsed successfully."
+ status=1
+ exit ${status}
+ fi
+
+ if ((${iflags} & 0x400000)); then
+ echo "EOFBLOCK_FL bit is set."
+ bit_set=1
+ else
+ echo "EOFBLOCK_FL bit is not set."
+ bit_set=0
+ fi
+
+ # Check current bit state to expected value.
+ if [ ${bit_set} -ne ${2} ]; then
+ echo "Error: Current bit state incorrect."
+ exit ${status}
+ fi
+
+ # Mount the ${TEST_DEV}
+ mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
+ else
+ # Run fsck on the fs. fsck -t ${FSTYP} -fn ${TEST_DEV}.
+ _check_test_fs
+ fi
+
+ # Remove test file
+ rm -f ${TEST_DIR}/${1}
+}
+
+# Get standard environment, filters and checks.
+. ./common.rc
+. ./common.filter
+
+# Prerequisites for the test run.
+_supported_fs generic
+_supported_os Linux
+_require_xfs_io_falloc
+
+# Real QA test starts here.
+rm -f $seq.full
+
+# Begin test cases.
+
+# Using FALLOC_FL_KEEP_SIZE
+# Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
+echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)."
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_1 | _filter_xfs_io_unique
+_check_file_state test_1 ${BIT_SET}
+
+# Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
+echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)."
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_2 | _filter_xfs_io_unique
+_check_file_state test_2 ${BIT_SET}
+
+# Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
+echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)."
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_3 | _filter_xfs_io_unique
+_check_file_state test_3 ${BIT_NOT_SET}
+
+# Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
+echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)."
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_4 | _filter_xfs_io_unique
+_check_file_state test_4 ${BIT_NOT_SET}
+
+# Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io).
+echo "Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io)."
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_5 | _filter_xfs_io_unique
+_check_file_state test_5 ${BIT_NOT_SET}
+
+# Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
+echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)."
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_6 | _filter_xfs_io_unique
+_check_file_state test_6 ${BIT_NOT_SET}
+
+
+status=0
+exit ${status}
diff --git a/243.out b/243.out
new file mode 100644
index 0000000..35583e8
--- /dev/null
+++ b/243.out
@@ -0,0 +1,25 @@
+QA output created by 243
+Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+EOFBLOCK_FL bit is set.
+Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+EOFBLOCK_FL bit is set.
+Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+EOFBLOCK_FL bit is set.
+Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+EOFBLOCK_FL bit is set.
+Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io).
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+EOFBLOCK_FL bit is not set.
+Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+EOFBLOCK_FL bit is not set.
diff --git a/group b/group
index ff16bb3..e6dab13 100644
--- a/group
+++ b/group
@@ -356,3 +356,4 @@ deprecated
240 auto aio quick rw
241 auto
242 auto quick prealloc
+243 auto quick prealloc
--
1.7.1
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-27 20:33 [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode Akshay Lal
@ 2010-08-27 21:49 ` Eric Sandeen
2010-08-27 23:10 ` Akshay Lal
2010-08-27 23:32 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode Dave Chinner
1 sibling, 1 reply; 14+ messages in thread
From: Eric Sandeen @ 2010-08-27 21:49 UTC (permalink / raw)
To: Akshay Lal; +Cc: xfs
Akshay Lal wrote:
> As found by Theodore Ts'o: If a 128K file is falloc'ed using the
> KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't
> get cleared correctly. This forces e2fsck to complain about that
> inode.
Thanks, a few comments below...
> ---
> 243 | 145 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 243.out | 25 +++++++++++
> group | 1 +
> 3 files changed, 171 insertions(+), 0 deletions(-)
> create mode 100644 243
> create mode 100644 243.out
>
> diff --git a/243 b/243
> new file mode 100644
> index 0000000..8102f24
> --- /dev/null
> +++ b/243
> @@ -0,0 +1,145 @@
> +#! /bin/bash
> +# FS QA Test No. 243
> +#
> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
> +#
> +# As found by Theodore Ts'o:
> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> +# This forces e2fsck to complain about that inode.
> +#
> +# creator
> +owner=alal@google.com
> +
> +seq=`basename $0`
> +echo "QA output created by $seq"
> +
> +here=`pwd`
> +tmp=/tmp/$$
> +status=1 # failure is the default!
> +trap "_cleanup; exit \$status" 0 1 2 3 15
> +
> +# Test specific macros.
> +BIT_NOT_SET=0 # inode flag - 0x40000 bit is set.
> +BIT_SET=1 # inode flag - 0x400000 bit is not set.
I'm thinking one of the values in the comment is not right :)
> +
> +# Generic test cleanup function.
> +_cleanup()
> +{
> + cd /
> + rm -f $tmp.*
> +}
> +
> +# Checks the state of the sample file in the filesystem and returns whether
> +# the inode flag 0x400000 is set or not.
I guess a little more comment here about why we do this only for ext4 might
be good.
Just to make it more obvious in the main test could you maybe call
it something like _check_ext4_eof_flag() ? If we ever need to do
testing on other filesystems we can adjust it.
> +_check_file_state()
> +{
> + bit_set=1
> +
> + # Check whether EOFBLOCK_FL is set.
> + if [ "${FSTYP}" == "ext4" ]; then
> + # Unmount the ${TEST_DEV}
> + umount ${TEST_DEV}
> +
> + # Run debugfs to gather file_parameters - specifically iflags.
> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
> + iflags=${file_params#*Flags: }
> +
> + # Ensure that the iflags value was parsed correctly.
> + if [ -z ${iflags} ]; then
> + echo "iFlags value was not parsed successfully."
> + status=1
> + exit ${status}
> + fi
> +
> + if ((${iflags} & 0x400000)); then
> + echo "EOFBLOCK_FL bit is set."
This will cause the test to fail on anything but ext4 because
it's expected in the output but only happens for ext4...
You could redirect it into $seq.full, just to have it for analysis
if the test ever fails.
> + bit_set=1
> + else
> + echo "EOFBLOCK_FL bit is not set."
> + bit_set=0
> + fi
> +
> + # Check current bit state to expected value.
> + if [ ${bit_set} -ne ${2} ]; then
> + echo "Error: Current bit state incorrect."
> + exit ${status}
> + fi
> +
> + # Mount the ${TEST_DEV}
> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
> + else
> + # Run fsck on the fs. fsck -t ${FSTYP} -fn ${TEST_DEV}.
> + _check_test_fs
Ah now I see why you didn't call it _check_ext4_eof_flag() ;)
This may not be necessary, the harness runs fsck after each
test anyway. On a large filesystem this could take a pretty
long time if you run fsck 6 times. I'd just drop
this and let the post-test-fsck catch any problems.
> + fi
> +
> + # Remove test file
> + rm -f ${TEST_DIR}/${1}
... but I suppose you'd need to leave the files around for that to work,
which is fine; the test_dir is supposed to age anyway.
Thanks,
-Eric
> +}
> +
> +# Get standard environment, filters and checks.
> +. ./common.rc
> +. ./common.filter
> +
> +# Prerequisites for the test run.
> +_supported_fs generic
> +_supported_os Linux
> +_require_xfs_io_falloc
> +
> +# Real QA test starts here.
> +rm -f $seq.full
> +
> +# Begin test cases.
> +
> +# Using FALLOC_FL_KEEP_SIZE
> +# Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)."
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
> +_check_file_state test_1 ${BIT_SET}
> +
> +# Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)."
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
> +_check_file_state test_2 ${BIT_SET}
> +
> +# Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)."
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
> +_check_file_state test_3 ${BIT_NOT_SET}
> +
> +# Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)."
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
> +_check_file_state test_4 ${BIT_NOT_SET}
> +
> +# Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io).
> +echo "Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io)."
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
> +_check_file_state test_5 ${BIT_NOT_SET}
> +
> +# Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)."
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
> +_check_file_state test_6 ${BIT_NOT_SET}
> +
> +
> +status=0
> +exit ${status}
> diff --git a/243.out b/243.out
> new file mode 100644
> index 0000000..35583e8
> --- /dev/null
> +++ b/243.out
> @@ -0,0 +1,25 @@
> +QA output created by 243
> +Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io).
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is not set.
> +Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is not set.
> diff --git a/group b/group
> index ff16bb3..e6dab13 100644
> --- a/group
> +++ b/group
> @@ -356,3 +356,4 @@ deprecated
> 240 auto aio quick rw
> 241 auto
> 242 auto quick prealloc
> +243 auto quick prealloc
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-27 21:49 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly Eric Sandeen
@ 2010-08-27 23:10 ` Akshay Lal
2010-08-27 23:23 ` Eric Sandeen
0 siblings, 1 reply; 14+ messages in thread
From: Akshay Lal @ 2010-08-27 23:10 UTC (permalink / raw)
To: Eric Sandeen; +Cc: xfs
>> +# Test specific macros.
>> +BIT_NOT_SET=0 # inode flag - 0x40000 bit is set.
>> +BIT_SET=1 # inode flag - 0x400000 bit is not set.
>
> I'm thinking one of the values in the comment is not right :)
Duh. Thats silly of me.
Done.
>> +# Checks the state of the sample file in the filesystem and returns whether
>> +# the inode flag 0x400000 is set or not.
>
> I guess a little more comment here about why we do this only for ext4 might
> be good.
>
> Just to make it more obvious in the main test could you maybe call
> it something like _check_ext4_eof_flag() ? If we ever need to do
> testing on other filesystems we can adjust it.
Done.
>> + if ((${iflags} & 0x400000)); then
>> + echo "EOFBLOCK_FL bit is set."
>
> This will cause the test to fail on anything but ext4 because
> it's expected in the output but only happens for ext4...
>
> You could redirect it into $seq.full, just to have it for analysis
> if the test ever fails.
I've added an else condition to exit the test with the error message
that the test is only
supported on ext4 filesystems.
I've also redirected all echo messages to $seq.full
>> + # Run fsck on the fs. fsck -t ${FSTYP} -fn ${TEST_DEV}.
>> + _check_test_fs
>
> Ah now I see why you didn't call it _check_ext4_eof_flag() ;)
>
> This may not be necessary, the harness runs fsck after each
> test anyway. On a large filesystem this could take a pretty
> long time if you run fsck 6 times. I'd just drop
> this and let the post-test-fsck catch any problems.
Removed.
---------------------------------------------------------------------------------------
Updated patch:
---------------------------------------------------------------------------------------
>From f1e8df788e4b93ae33e01c48a859f2b21c425357 Mon Sep 17 00:00:00 2001
From: Akshay Lal <alal@google.com>
Date: Fri, 27 Aug 2010 13:14:18 -0700
Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
As found by Theodore Ts'o:
If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
This forces e2fsck to complain about that inode.
Bug reference:
http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
---
243 | 157 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
243.out | 13 +++++
group | 1 +
3 files changed, 171 insertions(+), 0 deletions(-)
create mode 100644 243
create mode 100644 243.out
diff --git a/243 b/243
new file mode 100644
index 0000000..804513f
--- /dev/null
+++ b/243
@@ -0,0 +1,157 @@
+#! /bin/bash
+# FS QA Test No. 243
+#
+# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
+#
+# As found by Theodore Ts'o:
+# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
+# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
+# This forces e2fsck to complain about that inode.
+#
+# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
+#
+# creator
+owner=alal@google.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+tmp=/tmp/$$
+status=1 # failure is the default!
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# Test specific macros.
+BIT_NOT_SET=0 # inode flag - 0x40000 bit is not set.
+BIT_SET=1 # inode flag - 0x400000 bit is set.
+
+# Generic test cleanup function.
+_cleanup()
+{
+ cd /
+ rm -f $tmp.*
+}
+
+# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
+# enabled. The only time this bit should be set is when extending the allocated
+# blocks further than what the i_size represents. In the situations wherein the
+# i_size covers all allocated blocks, this bit should be cleared.
+
+# Checks the state of the sample file in the filesystem and returns whether
+# the inode flag 0x400000 is set or not.
+_check_ext4_eof_flag()
+{
+ bit_set=1
+
+ # Check whether EOFBLOCK_FL is set.
+ if [ "${FSTYP}" == "ext4" ]; then
+ # Unmount the ${TEST_DEV}
+ umount ${TEST_DEV}
+
+ # Run debugfs to gather file_parameters - specifically iflags.
+ file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
+ iflags=${file_params#*Flags: }
+
+ # Ensure that the iflags value was parsed correctly.
+ if [ -z ${iflags} ]; then
+ echo "iFlags value was not parsed successfully." >> $seq.full
+ status=1
+ exit ${status}
+ fi
+
+ # Check if EOFBLOCKS_FL is set.
+ if ((${iflags} & 0x400000)); then
+ echo "EOFBLOCK_FL bit is set." >> $seq.full
+ bit_set=1
+ else
+ echo "EOFBLOCK_FL bit is not set." >> $seq.full
+ bit_set=0
+ fi
+
+ # Check current bit state to expected value.
+ if [ ${bit_set} -ne ${2} ]; then
+ echo "Error: Current bit state incorrect." >> $seq.full
+ exit ${status}
+ fi
+
+ # Mount the ${TEST_DEV}
+ mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
+ else
+ echo "Only EXT4 filesystems supported." >> $seq.full
+ status=1
+ exit ${status}
+ fi
+}
+
+# Get standard environment, filters and checks.
+. ./common.rc
+. ./common.filter
+
+# Prerequisites for the test run.
+_supported_fs generic
+_supported_os Linux
+_require_xfs_io_falloc
+
+# Real QA test starts here.
+rm -f $seq.full
+
+# Begin test cases.
+
+# Using FALLOC_FL_KEEP_SIZE
+# Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
+echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_1 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_1 ${BIT_SET}
+
+# Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
+echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_2 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_2 ${BIT_SET}
+
+# Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
+echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_3 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
+
+# Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
+echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_4 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
+
+# Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io).
+echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_5 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
+
+# Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
+echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_6 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
+
+
+status=0
+exit ${status}
diff --git a/243.out b/243.out
new file mode 100644
index 0000000..290a005
--- /dev/null
+++ b/243.out
@@ -0,0 +1,13 @@
+QA output created by 243
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
diff --git a/group b/group
index ff16bb3..e6dab13 100644
--- a/group
+++ b/group
@@ -356,3 +356,4 @@ deprecated
240 auto aio quick rw
241 auto
242 auto quick prealloc
+243 auto quick prealloc
--
1.7.1
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-27 23:10 ` Akshay Lal
@ 2010-08-27 23:23 ` Eric Sandeen
0 siblings, 0 replies; 14+ messages in thread
From: Eric Sandeen @ 2010-08-27 23:23 UTC (permalink / raw)
To: alal; +Cc: xfs
Akshay Lal wrote:
>>> +# Test specific macros.
>>> +BIT_NOT_SET=0 # inode flag - 0x40000 bit is set.
>>> +BIT_SET=1 # inode flag - 0x400000 bit is not set.
>> I'm thinking one of the values in the comment is not right :)
> Duh. Thats silly of me.
> Done.
>
>>> +# Checks the state of the sample file in the filesystem and returns whether
>>> +# the inode flag 0x400000 is set or not.
>> I guess a little more comment here about why we do this only for ext4 might
>> be good.
>>
>> Just to make it more obvious in the main test could you maybe call
>> it something like _check_ext4_eof_flag() ? If we ever need to do
>> testing on other filesystems we can adjust it.
> Done.
>
>
>>> + if ((${iflags} & 0x400000)); then
>>> + echo "EOFBLOCK_FL bit is set."
>> This will cause the test to fail on anything but ext4 because
>> it's expected in the output but only happens for ext4...
>>
>> You could redirect it into $seq.full, just to have it for analysis
>> if the test ever fails.
> I've added an else condition to exit the test with the error message
> that the test is only
> supported on ext4 filesystems.
If you only want to run on ext4, just set _supported_fs ext4
but I think the test is fine to run on other filesystems, it
exercises some boundary conditions, it just doesn't do the low-level
testing for other filesystems. But that's ok, it's a regression
test specifically for ext4 which can be sanity-checked on other
filesystems.
I'd prefer to keep it a generic test, and only do the low-level
debugfs checks for ext4....
More below.
> I've also redirected all echo messages to $seq.full
>
>
>>> + # Run fsck on the fs. fsck -t ${FSTYP} -fn ${TEST_DEV}.
>>> + _check_test_fs
>> Ah now I see why you didn't call it _check_ext4_eof_flag() ;)
>>
>> This may not be necessary, the harness runs fsck after each
>> test anyway. On a large filesystem this could take a pretty
>> long time if you run fsck 6 times. I'd just drop
>> this and let the post-test-fsck catch any problems.
> Removed.
>
> ---------------------------------------------------------------------------------------
> Updated patch:
> ---------------------------------------------------------------------------------------
>
> From f1e8df788e4b93ae33e01c48a859f2b21c425357 Mon Sep 17 00:00:00 2001
> From: Akshay Lal <alal@google.com>
> Date: Fri, 27 Aug 2010 13:14:18 -0700
> Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
> As found by Theodore Ts'o:
> If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> This forces e2fsck to complain about that inode.
>
> Bug reference:
> http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
> ---
> 243 | 157 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 243.out | 13 +++++
> group | 1 +
> 3 files changed, 171 insertions(+), 0 deletions(-)
> create mode 100644 243
> create mode 100644 243.out
>
> diff --git a/243 b/243
> new file mode 100644
> index 0000000..804513f
> --- /dev/null
> +++ b/243
> @@ -0,0 +1,157 @@
> +#! /bin/bash
> +# FS QA Test No. 243
> +#
> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
> +#
> +# As found by Theodore Ts'o:
> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> +# This forces e2fsck to complain about that inode.
> +#
> +# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
> +#
> +# creator
> +owner=alal@google.com
> +
> +seq=`basename $0`
> +echo "QA output created by $seq"
> +
> +here=`pwd`
> +tmp=/tmp/$$
> +status=1 # failure is the default!
> +trap "_cleanup; exit \$status" 0 1 2 3 15
> +
> +# Test specific macros.
> +BIT_NOT_SET=0 # inode flag - 0x40000 bit is not set.
> +BIT_SET=1 # inode flag - 0x400000 bit is set.
still different ;)
> +
> +# Generic test cleanup function.
> +_cleanup()
> +{
> + cd /
> + rm -f $tmp.*
> +}
> +
> +# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
> +# enabled. The only time this bit should be set is when extending the allocated
> +# blocks further than what the i_size represents. In the situations wherein the
> +# i_size covers all allocated blocks, this bit should be cleared.
> +
> +# Checks the state of the sample file in the filesystem and returns whether
> +# the inode flag 0x400000 is set or not.
> +_check_ext4_eof_flag()
> +{
> + bit_set=1
> +
> + # Check whether EOFBLOCK_FL is set.
> + if [ "${FSTYP}" == "ext4" ]; then
> + # Unmount the ${TEST_DEV}
> + umount ${TEST_DEV}
> +
> + # Run debugfs to gather file_parameters - specifically iflags.
> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
> + iflags=${file_params#*Flags: }
> +
> + # Ensure that the iflags value was parsed correctly.
> + if [ -z ${iflags} ]; then
> + echo "iFlags value was not parsed successfully." >> $seq.full
> + status=1
> + exit ${status}
> + fi
> +
> + # Check if EOFBLOCKS_FL is set.
> + if ((${iflags} & 0x400000)); then
> + echo "EOFBLOCK_FL bit is set." >> $seq.full
> + bit_set=1
> + else
> + echo "EOFBLOCK_FL bit is not set." >> $seq.full
> + bit_set=0
> + fi
> +
> + # Check current bit state to expected value.
> + if [ ${bit_set} -ne ${2} ]; then
> + echo "Error: Current bit state incorrect." >> $seq.full
> + exit ${status}
> + fi
> +
> + # Mount the ${TEST_DEV}
> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
> + else
> + echo "Only EXT4 filesystems supported." >> $seq.full
> + status=1
> + exit ${status}
this will make it -fail- on other filesystems, at worst we want to
not run, but in reality we can just skip the debugfs steps for non-ext4
and do the quick checks on other filesystems, with the built-in fsck
backing us up.
So I'd just say "if not ext4 return" and then let the rest
of the function do the ext4 checking.
(FYI if/when you ever do want to bail like above, you can either:
_notrun "Sorry, Dave, I'm afraid I can't do that"
or
_fail "Something terrible has gone wrong!"
and the user will see the results during the test run and
get the right test status)
> + fi
> +}
> +
> +# Get standard environment, filters and checks.
> +. ./common.rc
> +. ./common.filter
> +
> +# Prerequisites for the test run.
> +_supported_fs generic
so you have "generic" supported but it fails on non-ext4 now ;)
Really you probably want to have:
_supported_fs ext4 xfs btrfs gfs2
since those are the ones which support preallocation.
(sorry, I didn't catch that the first time)
-Eric
> +_supported_os Linux
> +_require_xfs_io_falloc
> +
> +# Real QA test starts here.
> +rm -f $seq.full
> +
> +# Begin test cases.
> +
> +# Using FALLOC_FL_KEEP_SIZE
> +# Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_1 ${BIT_SET}
> +
> +# Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_2 ${BIT_SET}
> +
> +# Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
> +
> +# Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
> +
> +# Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io).
> +echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
> +
> +# Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
> +
> +
> +status=0
> +exit ${status}
> diff --git a/243.out b/243.out
> new file mode 100644
> index 0000000..290a005
> --- /dev/null
> +++ b/243.out
> @@ -0,0 +1,13 @@
> +QA output created by 243
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> diff --git a/group b/group
> index ff16bb3..e6dab13 100644
> --- a/group
> +++ b/group
> @@ -356,3 +356,4 @@ deprecated
> 240 auto aio quick rw
> 241 auto
> 242 auto quick prealloc
> +243 auto quick prealloc
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode.
2010-08-27 20:33 [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode Akshay Lal
2010-08-27 21:49 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly Eric Sandeen
@ 2010-08-27 23:32 ` Dave Chinner
2010-08-28 0:03 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly Eric Sandeen
1 sibling, 1 reply; 14+ messages in thread
From: Dave Chinner @ 2010-08-27 23:32 UTC (permalink / raw)
To: Akshay Lal; +Cc: xfs
On Fri, Aug 27, 2010 at 01:33:44PM -0700, Akshay Lal wrote:
> Bug reference:
> http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
The test looks good - a few minor things, though. Firstly Can you
add a brief description rather than just a URL as this forms the
commit message?
> ---
> 243 | 145 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 243.out | 25 +++++++++++
> group | 1 +
> 3 files changed, 171 insertions(+), 0 deletions(-)
> create mode 100644 243
> create mode 100644 243.out
>
> diff --git a/243 b/243
> new file mode 100644
> index 0000000..8102f24
> --- /dev/null
> +++ b/243
> @@ -0,0 +1,145 @@
> +#! /bin/bash
> +# FS QA Test No. 243
> +#
> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
> +#
> +# As found by Theodore Ts'o:
> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> +# This forces e2fsck to complain about that inode.
> +#
> +# creator
Please retain the GPL license text here as per the new test template
and all other tests.
> +owner=alal@google.com
> +
> +seq=`basename $0`
> +echo "QA output created by $seq"
> +
> +here=`pwd`
> +tmp=/tmp/$$
> +status=1 # failure is the default!
> +trap "_cleanup; exit \$status" 0 1 2 3 15
> +
> +# Test specific macros.
> +BIT_NOT_SET=0 # inode flag - 0x40000 bit is set.
> +BIT_SET=1 # inode flag - 0x400000 bit is not set.
> +
> +# Generic test cleanup function.
> +_cleanup()
> +{
> + cd /
> + rm -f $tmp.*
> +}
> +
> +# Checks the state of the sample file in the filesystem and returns whether
> +# the inode flag 0x400000 is set or not.
> +_check_file_state()
> +{
> + bit_set=1
> +
> + # Check whether EOFBLOCK_FL is set.
> + if [ "${FSTYP}" == "ext4" ]; then
> + # Unmount the ${TEST_DEV}
> + umount ${TEST_DEV}
> +
> + # Run debugfs to gather file_parameters - specifically iflags.
> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
> + iflags=${file_params#*Flags: }
> +
> + # Ensure that the iflags value was parsed correctly.
> + if [ -z ${iflags} ]; then
> + echo "iFlags value was not parsed successfully."
> + status=1
> + exit ${status}
> + fi
> +
> + if ((${iflags} & 0x400000)); then
> + echo "EOFBLOCK_FL bit is set."
> + bit_set=1
> + else
> + echo "EOFBLOCK_FL bit is not set."
> + bit_set=0
> + fi
> +
> + # Check current bit state to expected value.
> + if [ ${bit_set} -ne ${2} ]; then
> + echo "Error: Current bit state incorrect."
> + exit ${status}
That needs to be:
status=1
exit
For the cleanup trap to set the exit status correctly.
> + fi
> +
> + # Mount the ${TEST_DEV}
> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
> + else
> + # Run fsck on the fs. fsck -t ${FSTYP} -fn ${TEST_DEV}.
> + _check_test_fs
> + fi
> +
> + # Remove test file
> + rm -f ${TEST_DIR}/${1}
> +}
> +
> +# Get standard environment, filters and checks.
> +. ./common.rc
> +. ./common.filter
> +
> +# Prerequisites for the test run.
> +_supported_fs generic
I'm not sure this really is a generic test - it's testing an ext4
specific bug. We've got other generic tests that exercise fallocate,
and some filesystems (like XFS) don't have special bits to say there
are extents beyond EOF and checking a filesystem repeated won't
report any problems. So perhaps if should be '_supported_fs ext4'
> +_supported_os Linux
> +_require_xfs_io_falloc
> +
> +# Real QA test starts here.
> +rm -f $seq.full
> +
> +# Begin test cases.
> +
> +# Using FALLOC_FL_KEEP_SIZE
> +# Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)."
No need for the comment and the echo. Just remove the comments.
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
> +_check_file_state test_1 ${BIT_SET}
> +
> +# Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)."
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
> +_check_file_state test_2 ${BIT_SET}
> +
> +# Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)."
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
> +_check_file_state test_3 ${BIT_NOT_SET}
> +
> +# Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)."
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
> +_check_file_state test_4 ${BIT_NOT_SET}
> +
> +# Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io).
> +echo "Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io)."
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
> +_check_file_state test_5 ${BIT_NOT_SET}
> +
> +# Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)."
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
> +_check_file_state test_6 ${BIT_NOT_SET}
> +
> +
> +status=0
> +exit ${status}
> diff --git a/243.out b/243.out
> new file mode 100644
> index 0000000..35583e8
> --- /dev/null
> +++ b/243.out
> @@ -0,0 +1,25 @@
> +QA output created by 243
> +Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io).
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io).
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io).
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io).
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is set.
> +Test 5: Fallocate 128k, seek to 256k and write a 4k block (buffered io).
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is not set.
> +Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io).
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +EOFBLOCK_FL bit is not set.
> diff --git a/group b/group
> index ff16bb3..e6dab13 100644
> --- a/group
> +++ b/group
> @@ -356,3 +356,4 @@ deprecated
> 240 auto aio quick rw
> 241 auto
> 242 auto quick prealloc
> +243 auto quick prealloc
> --
> 1.7.1
>
> _______________________________________________
> xfs mailing list
> xfs@oss.sgi.com
> http://oss.sgi.com/mailman/listinfo/xfs
>
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-27 23:32 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode Dave Chinner
@ 2010-08-28 0:03 ` Eric Sandeen
2010-08-28 0:17 ` Dave Chinner
0 siblings, 1 reply; 14+ messages in thread
From: Eric Sandeen @ 2010-08-28 0:03 UTC (permalink / raw)
To: Dave Chinner; +Cc: xfs, Akshay Lal
Dave Chinner wrote:
> I'm not sure this really is a generic test - it's testing an ext4
> specific bug. We've got other generic tests that exercise fallocate,
> and some filesystems (like XFS) don't have special bits to say there
> are extents beyond EOF and checking a filesystem repeated won't
> report any problems. So perhaps if should be '_supported_fs ext4'
Oops we're giving conflicting advice :) I thought a test that
exercises blocks-past-eof-filling at various boundaries made
sense in general, even if the specific regression test is ext4-specific.
Seems like at least ocfs2/btrfs might benefit from the basic exercise,
so I was recommending that it be generic.
I don't think there is any other test that makes a point of
allocating X blocks past eof and then filling them exactly,
overwriting/extending past them, etc. Seems like a good addition
in general.
-Eric
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-28 0:03 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly Eric Sandeen
@ 2010-08-28 0:17 ` Dave Chinner
2010-08-28 0:23 ` Eric Sandeen
0 siblings, 1 reply; 14+ messages in thread
From: Dave Chinner @ 2010-08-28 0:17 UTC (permalink / raw)
To: Eric Sandeen; +Cc: xfs, Akshay Lal
On Fri, Aug 27, 2010 at 07:03:32PM -0500, Eric Sandeen wrote:
> Dave Chinner wrote:
>
> > I'm not sure this really is a generic test - it's testing an ext4
> > specific bug. We've got other generic tests that exercise fallocate,
> > and some filesystems (like XFS) don't have special bits to say there
> > are extents beyond EOF and checking a filesystem repeated won't
> > report any problems. So perhaps if should be '_supported_fs ext4'
>
>
> Oops we're giving conflicting advice :) I thought a test that
> exercises blocks-past-eof-filling at various boundaries made
> sense in general, even if the specific regression test is ext4-specific.
>
> Seems like at least ocfs2/btrfs might benefit from the basic exercise,
> so I was recommending that it be generic.
Ok, that seems reasonable. If the bug results in filesystem
corruption, then maybe just relying on the check at the end of the
test to fail it would be appropriate?
Cheers,
Dave.
--
Dave Chinner
david@fromorbit.com
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-28 0:17 ` Dave Chinner
@ 2010-08-28 0:23 ` Eric Sandeen
2010-08-30 17:33 ` Akshay Lal
0 siblings, 1 reply; 14+ messages in thread
From: Eric Sandeen @ 2010-08-28 0:23 UTC (permalink / raw)
To: Dave Chinner; +Cc: xfs, Akshay Lal
Dave Chinner wrote:
> On Fri, Aug 27, 2010 at 07:03:32PM -0500, Eric Sandeen wrote:
>> Dave Chinner wrote:
>>
>>> I'm not sure this really is a generic test - it's testing an ext4
>>> specific bug. We've got other generic tests that exercise fallocate,
>>> and some filesystems (like XFS) don't have special bits to say there
>>> are extents beyond EOF and checking a filesystem repeated won't
>>> report any problems. So perhaps if should be '_supported_fs ext4'
>>
>> Oops we're giving conflicting advice :) I thought a test that
>> exercises blocks-past-eof-filling at various boundaries made
>> sense in general, even if the specific regression test is ext4-specific.
>>
>> Seems like at least ocfs2/btrfs might benefit from the basic exercise,
>> so I was recommending that it be generic.
>
> Ok, that seems reasonable. If the bug results in filesystem
> corruption, then maybe just relying on the check at the end of the
> test to fail it would be appropriate?
That's fine by me, if e2fsck will squawk, that's enough.
-Eric
> Cheers,
>
> Dave.
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-28 0:23 ` Eric Sandeen
@ 2010-08-30 17:33 ` Akshay Lal
2010-09-07 18:23 ` Eric Sandeen
0 siblings, 1 reply; 14+ messages in thread
From: Akshay Lal @ 2010-08-30 17:33 UTC (permalink / raw)
To: Eric Sandeen; +Cc: xfs
I reckon I've addressed all the concerns (yes even the comment mismatch)
---------------------------------------------------------------------------------------
Updated patch:
---------------------------------------------------------------------------------------
>From 6bf876f2b95e61409abbab24754c80354988bcc9 Mon Sep 17 00:00:00 2001
From: Akshay Lal <alal@google.com>
Date: Fri, 27 Aug 2010 13:14:18 -0700
Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
As found by Theodore Ts'o:
If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
This forces e2fsck to complain about that inode.
Bug reference:
http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
---
243 | 177 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
243.out | 13 +++++
group | 1 +
3 files changed, 191 insertions(+), 0 deletions(-)
create mode 100644 243
create mode 100644 243.out
diff --git a/243 b/243
new file mode 100644
index 0000000..1a6c4a5
--- /dev/null
+++ b/243
@@ -0,0 +1,177 @@
+#! /bin/bash
+# FS QA Test No. 243
+#
+# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
+#
+# As found by Theodore Ts'o:
+# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
+# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
+# This is bad since it forces e2fsck to complain about that inode.
+# If you have a large number of inodes that are written with fallocate
+# using KEEP_SIZE, and then fill them up to their expected size,
+# e2fsck will potentially complain about a _huge_ number of inodes.
+# This would also cause a huge increase in the time taken by e2fsck
+# to complete its check.
+#
+# Test scenarios covered:
+# 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
+# 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
+# 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
+#
+# These test cases exercise the normal and edge case conditions using
+# falloc (and KEEP_SIZE).
+#
+# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
+#
+#-----------------------------------------------------------------------
+# Copyright (c) 2010 Google, 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
+#-----------------------------------------------------------------------
+#
+# creator
+owner=alal@google.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+tmp=/tmp/$$
+status=1 # failure is the default!
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# Test specific macros.
+BIT_NOT_SET=0 # inode flag - 0x400000 bit is not set.
+BIT_SET=1 # inode flag - 0x400000 bit is set.
+
+# Generic test cleanup function.
+_cleanup()
+{
+ cd /
+ rm -f $tmp.*
+}
+
+# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
+# enabled. The only time this bit should be set is when extending the allocated
+# blocks further than what the i_size represents. In the situations wherein the
+# i_size covers all allocated blocks, this bit should be cleared.
+
+# Checks the state of the sample file in the filesystem and returns whether
+# the inode flag 0x400000 is set or not.
+_check_ext4_eof_flag()
+{
+ bit_set=1
+
+ # Check whether EOFBLOCK_FL is set.
+ # For ext4 filesystems: use debugfs to check if EOFBLOCKS_FL is set.
+ # Other filesystems: do nothing. The default fsck at the end of the test
+ # should catch any potential errors.
+ if [ "${FSTYP}" == "ext4" ]; then
+ # Unmount the ${TEST_DEV}
+ umount ${TEST_DEV}
+
+ # Run debugfs to gather file_parameters - specifically iflags.
+ file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
+ iflags=${file_params#*Flags: }
+
+ # Ensure that the iflags value was parsed correctly.
+ if [ -z ${iflags} ]; then
+ echo "iFlags value was not parsed successfully." >> $seq.full
+ status=1
+ exit ${status}
+ fi
+
+ # Check if EOFBLOCKS_FL is set.
+ if ((${iflags} & 0x400000)); then
+ echo "EOFBLOCK_FL bit is set." >> $seq.full
+ bit_set=1
+ else
+ echo "EOFBLOCK_FL bit is not set." >> $seq.full
+ bit_set=0
+ fi
+
+ # Check current bit state to expected value.
+ if [ ${bit_set} -ne ${2} ]; then
+ echo "Error: Current bit state incorrect." >> $seq.full
+ status=1
+ exit ${status}
+ fi
+
+ # Mount the ${TEST_DEV}
+ mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
+}
+
+# Get standard environment, filters and checks.
+. ./common.rc
+. ./common.filter
+
+# Prerequisites for the test run.
+_supported_fs ext4 xfs btrfs gfs2
+_supported_os Linux
+_require_xfs_io_falloc
+
+# Real QA test starts here.
+rm -f $seq.full
+
+# Begin test cases.
+echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_1 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_1 ${BIT_SET}
+
+echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_2 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_2 ${BIT_SET}
+
+echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_3 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
+
+echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_4 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
+
+echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_5 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
+
+echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_6 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
+
+status=0
+exit ${status}
diff --git a/243.out b/243.out
new file mode 100644
index 0000000..290a005
--- /dev/null
+++ b/243.out
@@ -0,0 +1,13 @@
+QA output created by 243
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
diff --git a/group b/group
index ff16bb3..e6dab13 100644
--- a/group
+++ b/group
@@ -356,3 +356,4 @@ deprecated
240 auto aio quick rw
241 auto
242 auto quick prealloc
+243 auto quick prealloc
--
1.7.1
---
Cheers!
Akshay Lal
On Fri, Aug 27, 2010 at 5:23 PM, Eric Sandeen <sandeen@sandeen.net> wrote:
> Dave Chinner wrote:
>> On Fri, Aug 27, 2010 at 07:03:32PM -0500, Eric Sandeen wrote:
>>> Dave Chinner wrote:
>>>
>>>> I'm not sure this really is a generic test - it's testing an ext4
>>>> specific bug. We've got other generic tests that exercise fallocate,
>>>> and some filesystems (like XFS) don't have special bits to say there
>>>> are extents beyond EOF and checking a filesystem repeated won't
>>>> report any problems. So perhaps if should be '_supported_fs ext4'
>>>
>>> Oops we're giving conflicting advice :) I thought a test that
>>> exercises blocks-past-eof-filling at various boundaries made
>>> sense in general, even if the specific regression test is ext4-specific.
>>>
>>> Seems like at least ocfs2/btrfs might benefit from the basic exercise,
>>> so I was recommending that it be generic.
>>
>> Ok, that seems reasonable. If the bug results in filesystem
>> corruption, then maybe just relying on the check at the end of the
>> test to fail it would be appropriate?
>
> That's fine by me, if e2fsck will squawk, that's enough.
>
> -Eric
>
>> Cheers,
>>
>> Dave.
>
>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-08-30 17:33 ` Akshay Lal
@ 2010-09-07 18:23 ` Eric Sandeen
2010-09-07 19:58 ` Akshay Lal
0 siblings, 1 reply; 14+ messages in thread
From: Eric Sandeen @ 2010-09-07 18:23 UTC (permalink / raw)
To: alal; +Cc: xfs
Akshay Lal wrote:
> I reckon I've addressed all the concerns (yes even the comment mismatch)
perhaps, but there is a syntax error in the test now ;)
Apply the patch & run it and you'll see...
Other than that it looks ok to me.
When you resend, please include a:
Signed-off-by: Akshay Lal <alal@google.com>
after the description and before the:
---
<patch>
Thanks,
-Eric
> ---------------------------------------------------------------------------------------
> Updated patch:
> ---------------------------------------------------------------------------------------
> From 6bf876f2b95e61409abbab24754c80354988bcc9 Mon Sep 17 00:00:00 2001
> From: Akshay Lal <alal@google.com>
> Date: Fri, 27 Aug 2010 13:14:18 -0700
> Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
> As found by Theodore Ts'o:
> If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> This forces e2fsck to complain about that inode.
>
> Bug reference:
> http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
> ---
> 243 | 177 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 243.out | 13 +++++
> group | 1 +
> 3 files changed, 191 insertions(+), 0 deletions(-)
> create mode 100644 243
> create mode 100644 243.out
>
> diff --git a/243 b/243
> new file mode 100644
> index 0000000..1a6c4a5
> --- /dev/null
> +++ b/243
> @@ -0,0 +1,177 @@
> +#! /bin/bash
> +# FS QA Test No. 243
> +#
> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
> +#
> +# As found by Theodore Ts'o:
> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> +# This is bad since it forces e2fsck to complain about that inode.
> +# If you have a large number of inodes that are written with fallocate
> +# using KEEP_SIZE, and then fill them up to their expected size,
> +# e2fsck will potentially complain about a _huge_ number of inodes.
> +# This would also cause a huge increase in the time taken by e2fsck
> +# to complete its check.
> +#
> +# Test scenarios covered:
> +# 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
> +# 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
> +# 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
> +#
> +# These test cases exercise the normal and edge case conditions using
> +# falloc (and KEEP_SIZE).
> +#
> +# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
> +#
> +#-----------------------------------------------------------------------
> +# Copyright (c) 2010 Google, 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
> +#-----------------------------------------------------------------------
> +#
> +# creator
> +owner=alal@google.com
> +
> +seq=`basename $0`
> +echo "QA output created by $seq"
> +
> +here=`pwd`
> +tmp=/tmp/$$
> +status=1 # failure is the default!
> +trap "_cleanup; exit \$status" 0 1 2 3 15
> +
> +# Test specific macros.
> +BIT_NOT_SET=0 # inode flag - 0x400000 bit is not set.
> +BIT_SET=1 # inode flag - 0x400000 bit is set.
> +
> +# Generic test cleanup function.
> +_cleanup()
> +{
> + cd /
> + rm -f $tmp.*
> +}
> +
> +# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
> +# enabled. The only time this bit should be set is when extending the allocated
> +# blocks further than what the i_size represents. In the situations wherein the
> +# i_size covers all allocated blocks, this bit should be cleared.
> +
> +# Checks the state of the sample file in the filesystem and returns whether
> +# the inode flag 0x400000 is set or not.
> +_check_ext4_eof_flag()
> +{
> + bit_set=1
> +
> + # Check whether EOFBLOCK_FL is set.
> + # For ext4 filesystems: use debugfs to check if EOFBLOCKS_FL is set.
> + # Other filesystems: do nothing. The default fsck at the end of the test
> + # should catch any potential errors.
> + if [ "${FSTYP}" == "ext4" ]; then
> + # Unmount the ${TEST_DEV}
> + umount ${TEST_DEV}
> +
> + # Run debugfs to gather file_parameters - specifically iflags.
> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
> + iflags=${file_params#*Flags: }
> +
> + # Ensure that the iflags value was parsed correctly.
> + if [ -z ${iflags} ]; then
> + echo "iFlags value was not parsed successfully." >> $seq.full
> + status=1
> + exit ${status}
> + fi
> +
> + # Check if EOFBLOCKS_FL is set.
> + if ((${iflags} & 0x400000)); then
> + echo "EOFBLOCK_FL bit is set." >> $seq.full
> + bit_set=1
> + else
> + echo "EOFBLOCK_FL bit is not set." >> $seq.full
> + bit_set=0
> + fi
> +
> + # Check current bit state to expected value.
> + if [ ${bit_set} -ne ${2} ]; then
> + echo "Error: Current bit state incorrect." >> $seq.full
> + status=1
> + exit ${status}
> + fi
> +
> + # Mount the ${TEST_DEV}
> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
> +}
> +
> +# Get standard environment, filters and checks.
> +. ./common.rc
> +. ./common.filter
> +
> +# Prerequisites for the test run.
> +_supported_fs ext4 xfs btrfs gfs2
> +_supported_os Linux
> +_require_xfs_io_falloc
> +
> +# Real QA test starts here.
> +rm -f $seq.full
> +
> +# Begin test cases.
> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_1 ${BIT_SET}
> +
> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_2 ${BIT_SET}
> +
> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
> +
> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
> +
> +echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
> +
> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
> +
> +status=0
> +exit ${status}
> diff --git a/243.out b/243.out
> new file mode 100644
> index 0000000..290a005
> --- /dev/null
> +++ b/243.out
> @@ -0,0 +1,13 @@
> +QA output created by 243
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> diff --git a/group b/group
> index ff16bb3..e6dab13 100644
> --- a/group
> +++ b/group
> @@ -356,3 +356,4 @@ deprecated
> 240 auto aio quick rw
> 241 auto
> 242 auto quick prealloc
> +243 auto quick prealloc
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-09-07 18:23 ` Eric Sandeen
@ 2010-09-07 19:58 ` Akshay Lal
2010-09-08 18:51 ` Eric Sandeen
0 siblings, 1 reply; 14+ messages in thread
From: Akshay Lal @ 2010-09-07 19:58 UTC (permalink / raw)
To: Eric Sandeen; +Cc: xfs
There was a missing fi at the the end of the _check_ext4_eof_flag method.
Also corrected some indentation.
Signed-off-by: Akshay Lal <alal@google.com>
---------------------------------------------------------------------------------------
Updated patch:
---------------------------------------------------------------------------------------
>From e6906071ab6c0ad38d3ee0a463b5c7944e71fd00 Mon Sep 17 00:00:00 2001
From: Akshay Lal <alal@google.com>
Date: Tue, 7 Sep 2010 12:54:33 -0700
Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
As found by Theodore Ts'o:
If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
This is bad since it forces e2fsck to complain about that inode.
If you have a large number of inodes that are written with fallocate
using KEEP_SIZE, and then fill them up to their expected size,
e2fsck will potentially complain about a _huge_ number of inodes.
This would also cause a huge increase in the time taken by e2fsck
to complete its check.
Test scenarios covered:
1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
These test cases exercise the normal and edge case conditions using
falloc (and KEEP_SIZE).
Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
---
243 | 178 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
243.out | 13 +++++
group | 1 +
3 files changed, 192 insertions(+), 0 deletions(-)
create mode 100644 243
create mode 100644 243.out
diff --git a/243 b/243
new file mode 100644
index 0000000..8b2e647
--- /dev/null
+++ b/243
@@ -0,0 +1,178 @@
+#! /bin/bash
+# FS QA Test No. 243
+#
+# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
+#
+# As found by Theodore Ts'o:
+# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
+# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
+# This is bad since it forces e2fsck to complain about that inode.
+# If you have a large number of inodes that are written with fallocate
+# using KEEP_SIZE, and then fill them up to their expected size,
+# e2fsck will potentially complain about a _huge_ number of inodes.
+# This would also cause a huge increase in the time taken by e2fsck
+# to complete its check.
+#
+# Test scenarios covered:
+# 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
+# 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
+# 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
+#
+# These test cases exercise the normal and edge case conditions using
+# falloc (and KEEP_SIZE).
+#
+# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
+#
+#-----------------------------------------------------------------------
+# Copyright (c) 2010 Google, 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
+#-----------------------------------------------------------------------
+#
+# creator
+owner=alal@google.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+here=`pwd`
+tmp=/tmp/$$
+status=1 # failure is the default!
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# Test specific macros.
+BIT_NOT_SET=0 # inode flag - 0x400000 bit is not set.
+BIT_SET=1 # inode flag - 0x400000 bit is set.
+
+# Generic test cleanup function.
+_cleanup()
+{
+ cd /
+ rm -f $tmp.*
+}
+
+# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
+# enabled. The only time this bit should be set is when extending the allocated
+# blocks further than what the i_size represents. In the situations wherein the
+# i_size covers all allocated blocks, this bit should be cleared.
+
+# Checks the state of the sample file in the filesystem and returns whether
+# the inode flag 0x400000 is set or not.
+_check_ext4_eof_flag()
+{
+ # Check whether EOFBLOCK_FL is set.
+ # For ext4 filesystems: use debugfs to check if EOFBLOCKS_FL is set.
+ # Other filesystems: do nothing. The default fsck at the end of the test
+ # should catch any potential errors.
+ if [ "${FSTYP}" == "ext4" ]; then
+ bit_set=1
+
+ # Unmount the ${TEST_DEV}
+ umount ${TEST_DEV}
+
+ # Run debugfs to gather file_parameters - specifically iflags.
+ file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
+ iflags=${file_params#*Flags: }
+
+ # Ensure that the iflags value was parsed correctly.
+ if [ -z ${iflags} ]; then
+ echo "iFlags value was not parsed successfully." >> $seq.full
+ status=1
+ exit ${status}
+ fi
+
+ # Check if EOFBLOCKS_FL is set.
+ if ((${iflags} & 0x400000)); then
+ echo "EOFBLOCK_FL bit is set." >> $seq.full
+ bit_set=1
+ else
+ echo "EOFBLOCK_FL bit is not set." >> $seq.full
+ bit_set=0
+ fi
+
+ # Check current bit state to expected value.
+ if [ ${bit_set} -ne ${2} ]; then
+ echo "Error: Current bit state incorrect." >> $seq.full
+ status=1
+ exit ${status}
+ fi
+
+ # Mount the ${TEST_DEV}
+ mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
+ fi
+}
+
+# Get standard environment, filters and checks.
+. ./common.rc
+. ./common.filter
+
+# Prerequisites for the test run.
+_supported_fs ext4 xfs btrfs gfs2
+_supported_os Linux
+_require_xfs_io_falloc
+
+# Real QA test starts here.
+rm -f $seq.full
+
+# Begin test cases.
+echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_1 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_1 ${BIT_SET}
+
+echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 4096' \
+ ${TEST_DIR}/test_2 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_2 ${BIT_SET}
+
+echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_3 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
+
+echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 40960' \
+ -c 'pwrite 0 40960' \
+ ${TEST_DIR}/test_4 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
+
+echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_5 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
+
+echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
+ >> $seq.full
+${XFS_IO_PROG} -F -f -d \
+ -c 'falloc -k 0 128k' \
+ -c 'pwrite 256k 4k' \
+ ${TEST_DIR}/test_6 | _filter_xfs_io_unique
+_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
+
+status=0
+exit ${status}
diff --git a/243.out b/243.out
new file mode 100644
index 0000000..290a005
--- /dev/null
+++ b/243.out
@@ -0,0 +1,13 @@
+QA output created by 243
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 40960/40960 bytes at offset 0
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 4096/4096 bytes at offset 262144
+XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
diff --git a/group b/group
index ff16bb3..e6dab13 100644
--- a/group
+++ b/group
@@ -356,3 +356,4 @@ deprecated
240 auto aio quick rw
241 auto
242 auto quick prealloc
+243 auto quick prealloc
--
1.7.1
---
Cheers!
Akshay Lal
On Tue, Sep 7, 2010 at 11:23 AM, Eric Sandeen <sandeen@sandeen.net> wrote:
> Akshay Lal wrote:
>> I reckon I've addressed all the concerns (yes even the comment mismatch)
>
> perhaps, but there is a syntax error in the test now ;)
>
> Apply the patch & run it and you'll see...
>
> Other than that it looks ok to me.
>
> When you resend, please include a:
>
> Signed-off-by: Akshay Lal <alal@google.com>
>
> after the description and before the:
>
> ---
> <patch>
>
> Thanks,
> -Eric
>
>
>> ---------------------------------------------------------------------------------------
>> Updated patch:
>> ---------------------------------------------------------------------------------------
>> From 6bf876f2b95e61409abbab24754c80354988bcc9 Mon Sep 17 00:00:00 2001
>> From: Akshay Lal <alal@google.com>
>> Date: Fri, 27 Aug 2010 13:14:18 -0700
>> Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
>> As found by Theodore Ts'o:
>> If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
>> write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
>> This forces e2fsck to complain about that inode.
>>
>> Bug reference:
>> http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
>> ---
>> 243 | 177 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>> 243.out | 13 +++++
>> group | 1 +
>> 3 files changed, 191 insertions(+), 0 deletions(-)
>> create mode 100644 243
>> create mode 100644 243.out
>>
>> diff --git a/243 b/243
>> new file mode 100644
>> index 0000000..1a6c4a5
>> --- /dev/null
>> +++ b/243
>> @@ -0,0 +1,177 @@
>> +#! /bin/bash
>> +# FS QA Test No. 243
>> +#
>> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
>> +#
>> +# As found by Theodore Ts'o:
>> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
>> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
>> +# This is bad since it forces e2fsck to complain about that inode.
>> +# If you have a large number of inodes that are written with fallocate
>> +# using KEEP_SIZE, and then fill them up to their expected size,
>> +# e2fsck will potentially complain about a _huge_ number of inodes.
>> +# This would also cause a huge increase in the time taken by e2fsck
>> +# to complete its check.
>> +#
>> +# Test scenarios covered:
>> +# 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
>> +# 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
>> +# 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
>> +#
>> +# These test cases exercise the normal and edge case conditions using
>> +# falloc (and KEEP_SIZE).
>> +#
>> +# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
>> +#
>> +#-----------------------------------------------------------------------
>> +# Copyright (c) 2010 Google, 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
>> +#-----------------------------------------------------------------------
>> +#
>> +# creator
>> +owner=alal@google.com
>> +
>> +seq=`basename $0`
>> +echo "QA output created by $seq"
>> +
>> +here=`pwd`
>> +tmp=/tmp/$$
>> +status=1 # failure is the default!
>> +trap "_cleanup; exit \$status" 0 1 2 3 15
>> +
>> +# Test specific macros.
>> +BIT_NOT_SET=0 # inode flag - 0x400000 bit is not set.
>> +BIT_SET=1 # inode flag - 0x400000 bit is set.
>> +
>> +# Generic test cleanup function.
>> +_cleanup()
>> +{
>> + cd /
>> + rm -f $tmp.*
>> +}
>> +
>> +# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
>> +# enabled. The only time this bit should be set is when extending the allocated
>> +# blocks further than what the i_size represents. In the situations wherein the
>> +# i_size covers all allocated blocks, this bit should be cleared.
>> +
>> +# Checks the state of the sample file in the filesystem and returns whether
>> +# the inode flag 0x400000 is set or not.
>> +_check_ext4_eof_flag()
>> +{
>> + bit_set=1
>> +
>> + # Check whether EOFBLOCK_FL is set.
>> + # For ext4 filesystems: use debugfs to check if EOFBLOCKS_FL is set.
>> + # Other filesystems: do nothing. The default fsck at the end of the test
>> + # should catch any potential errors.
>> + if [ "${FSTYP}" == "ext4" ]; then
>> + # Unmount the ${TEST_DEV}
>> + umount ${TEST_DEV}
>> +
>> + # Run debugfs to gather file_parameters - specifically iflags.
>> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
>> + iflags=${file_params#*Flags: }
>> +
>> + # Ensure that the iflags value was parsed correctly.
>> + if [ -z ${iflags} ]; then
>> + echo "iFlags value was not parsed successfully." >> $seq.full
>> + status=1
>> + exit ${status}
>> + fi
>> +
>> + # Check if EOFBLOCKS_FL is set.
>> + if ((${iflags} & 0x400000)); then
>> + echo "EOFBLOCK_FL bit is set." >> $seq.full
>> + bit_set=1
>> + else
>> + echo "EOFBLOCK_FL bit is not set." >> $seq.full
>> + bit_set=0
>> + fi
>> +
>> + # Check current bit state to expected value.
>> + if [ ${bit_set} -ne ${2} ]; then
>> + echo "Error: Current bit state incorrect." >> $seq.full
>> + status=1
>> + exit ${status}
>> + fi
>> +
>> + # Mount the ${TEST_DEV}
>> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
>> +}
>> +
>> +# Get standard environment, filters and checks.
>> +. ./common.rc
>> +. ./common.filter
>> +
>> +# Prerequisites for the test run.
>> +_supported_fs ext4 xfs btrfs gfs2
>> +_supported_os Linux
>> +_require_xfs_io_falloc
>> +
>> +# Real QA test starts here.
>> +rm -f $seq.full
>> +
>> +# Begin test cases.
>> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 4096' \
>> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_1 ${BIT_SET}
>> +
>> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f -d \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 4096' \
>> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_2 ${BIT_SET}
>> +
>> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 40960' \
>> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
>> +
>> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f -d \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 40960' \
>> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
>> +
>> +echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f \
>> + -c 'falloc -k 0 128k' \
>> + -c 'pwrite 256k 4k' \
>> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
>> +
>> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f -d \
>> + -c 'falloc -k 0 128k' \
>> + -c 'pwrite 256k 4k' \
>> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
>> +
>> +status=0
>> +exit ${status}
>> diff --git a/243.out b/243.out
>> new file mode 100644
>> index 0000000..290a005
>> --- /dev/null
>> +++ b/243.out
>> @@ -0,0 +1,13 @@
>> +QA output created by 243
>> +wrote 4096/4096 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 4096/4096 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 40960/40960 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 40960/40960 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 4096/4096 bytes at offset 262144
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 4096/4096 bytes at offset 262144
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> diff --git a/group b/group
>> index ff16bb3..e6dab13 100644
>> --- a/group
>> +++ b/group
>> @@ -356,3 +356,4 @@ deprecated
>> 240 auto aio quick rw
>> 241 auto
>> 242 auto quick prealloc
>> +243 auto quick prealloc
>
>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply related [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-09-07 19:58 ` Akshay Lal
@ 2010-09-08 18:51 ` Eric Sandeen
2010-09-08 18:52 ` Akshay Lal
0 siblings, 1 reply; 14+ messages in thread
From: Eric Sandeen @ 2010-09-08 18:51 UTC (permalink / raw)
To: alal; +Cc: xfs
Akshay Lal wrote:
> There was a missing fi at the the end of the _check_ext4_eof_flag method.
>
> Also corrected some indentation.
Thanks, I've committed this version.
In the future, keeping patch resubmissions tidy is helpful, i.e.
Subject: [PATCH Vx] subsystem: description
patch description
Signed-off-by:
---
other information that won't go into the commit
patch itself
... without the other cruft, forwarded snippets, etc :)
see also Documentation/SubmittingPatches
in the kernel tree.
Thanks,
-Eric
> Signed-off-by: Akshay Lal <alal@google.com>
> ---------------------------------------------------------------------------------------
> Updated patch:
> ---------------------------------------------------------------------------------------
> From e6906071ab6c0ad38d3ee0a463b5c7944e71fd00 Mon Sep 17 00:00:00 2001
> From: Akshay Lal <alal@google.com>
> Date: Tue, 7 Sep 2010 12:54:33 -0700
> Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
>
> As found by Theodore Ts'o:
> If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> This is bad since it forces e2fsck to complain about that inode.
> If you have a large number of inodes that are written with fallocate
> using KEEP_SIZE, and then fill them up to their expected size,
> e2fsck will potentially complain about a _huge_ number of inodes.
> This would also cause a huge increase in the time taken by e2fsck
> to complete its check.
>
> Test scenarios covered:
> 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
> 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
> 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
>
> These test cases exercise the normal and edge case conditions using
> falloc (and KEEP_SIZE).
>
> Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
> ---
> 243 | 178 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
> 243.out | 13 +++++
> group | 1 +
> 3 files changed, 192 insertions(+), 0 deletions(-)
> create mode 100644 243
> create mode 100644 243.out
>
> diff --git a/243 b/243
> new file mode 100644
> index 0000000..8b2e647
> --- /dev/null
> +++ b/243
> @@ -0,0 +1,178 @@
> +#! /bin/bash
> +# FS QA Test No. 243
> +#
> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
> +#
> +# As found by Theodore Ts'o:
> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
> +# This is bad since it forces e2fsck to complain about that inode.
> +# If you have a large number of inodes that are written with fallocate
> +# using KEEP_SIZE, and then fill them up to their expected size,
> +# e2fsck will potentially complain about a _huge_ number of inodes.
> +# This would also cause a huge increase in the time taken by e2fsck
> +# to complete its check.
> +#
> +# Test scenarios covered:
> +# 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
> +# 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
> +# 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
> +#
> +# These test cases exercise the normal and edge case conditions using
> +# falloc (and KEEP_SIZE).
> +#
> +# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
> +#
> +#-----------------------------------------------------------------------
> +# Copyright (c) 2010 Google, 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
> +#-----------------------------------------------------------------------
> +#
> +# creator
> +owner=alal@google.com
> +
> +seq=`basename $0`
> +echo "QA output created by $seq"
> +
> +here=`pwd`
> +tmp=/tmp/$$
> +status=1 # failure is the default!
> +trap "_cleanup; exit \$status" 0 1 2 3 15
> +
> +# Test specific macros.
> +BIT_NOT_SET=0 # inode flag - 0x400000 bit is not set.
> +BIT_SET=1 # inode flag - 0x400000 bit is set.
> +
> +# Generic test cleanup function.
> +_cleanup()
> +{
> + cd /
> + rm -f $tmp.*
> +}
> +
> +# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
> +# enabled. The only time this bit should be set is when extending the allocated
> +# blocks further than what the i_size represents. In the situations wherein the
> +# i_size covers all allocated blocks, this bit should be cleared.
> +
> +# Checks the state of the sample file in the filesystem and returns whether
> +# the inode flag 0x400000 is set or not.
> +_check_ext4_eof_flag()
> +{
> + # Check whether EOFBLOCK_FL is set.
> + # For ext4 filesystems: use debugfs to check if EOFBLOCKS_FL is set.
> + # Other filesystems: do nothing. The default fsck at the end of the test
> + # should catch any potential errors.
> + if [ "${FSTYP}" == "ext4" ]; then
> + bit_set=1
> +
> + # Unmount the ${TEST_DEV}
> + umount ${TEST_DEV}
> +
> + # Run debugfs to gather file_parameters - specifically iflags.
> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
> + iflags=${file_params#*Flags: }
> +
> + # Ensure that the iflags value was parsed correctly.
> + if [ -z ${iflags} ]; then
> + echo "iFlags value was not parsed successfully." >> $seq.full
> + status=1
> + exit ${status}
> + fi
> +
> + # Check if EOFBLOCKS_FL is set.
> + if ((${iflags} & 0x400000)); then
> + echo "EOFBLOCK_FL bit is set." >> $seq.full
> + bit_set=1
> + else
> + echo "EOFBLOCK_FL bit is not set." >> $seq.full
> + bit_set=0
> + fi
> +
> + # Check current bit state to expected value.
> + if [ ${bit_set} -ne ${2} ]; then
> + echo "Error: Current bit state incorrect." >> $seq.full
> + status=1
> + exit ${status}
> + fi
> +
> + # Mount the ${TEST_DEV}
> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
> + fi
> +}
> +
> +# Get standard environment, filters and checks.
> +. ./common.rc
> +. ./common.filter
> +
> +# Prerequisites for the test run.
> +_supported_fs ext4 xfs btrfs gfs2
> +_supported_os Linux
> +_require_xfs_io_falloc
> +
> +# Real QA test starts here.
> +rm -f $seq.full
> +
> +# Begin test cases.
> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_1 ${BIT_SET}
> +
> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 4096' \
> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_2 ${BIT_SET}
> +
> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
> +
> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 40960' \
> + -c 'pwrite 0 40960' \
> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
> +
> +echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
> +
> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
> + >> $seq.full
> +${XFS_IO_PROG} -F -f -d \
> + -c 'falloc -k 0 128k' \
> + -c 'pwrite 256k 4k' \
> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
> +_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
> +
> +status=0
> +exit ${status}
> diff --git a/243.out b/243.out
> new file mode 100644
> index 0000000..290a005
> --- /dev/null
> +++ b/243.out
> @@ -0,0 +1,13 @@
> +QA output created by 243
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 40960/40960 bytes at offset 0
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> +wrote 4096/4096 bytes at offset 262144
> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
> diff --git a/group b/group
> index ff16bb3..e6dab13 100644
> --- a/group
> +++ b/group
> @@ -356,3 +356,4 @@ deprecated
> 240 auto aio quick rw
> 241 auto
> 242 auto quick prealloc
> +243 auto quick prealloc
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-09-08 18:51 ` Eric Sandeen
@ 2010-09-08 18:52 ` Akshay Lal
2010-09-08 19:11 ` Eric Sandeen
0 siblings, 1 reply; 14+ messages in thread
From: Akshay Lal @ 2010-09-08 18:52 UTC (permalink / raw)
To: Eric Sandeen; +Cc: xfs
Thanks Eric, as we move fwd, these patch will be better.
---
Cheers!
Akshay Lal
On Wed, Sep 8, 2010 at 11:51 AM, Eric Sandeen <sandeen@sandeen.net> wrote:
> Akshay Lal wrote:
>> There was a missing fi at the the end of the _check_ext4_eof_flag method.
>>
>> Also corrected some indentation.
>
> Thanks, I've committed this version.
>
> In the future, keeping patch resubmissions tidy is helpful, i.e.
>
> Subject: [PATCH Vx] subsystem: description
>
> patch description
>
> Signed-off-by:
> ---
> other information that won't go into the commit
>
> patch itself
>
> ... without the other cruft, forwarded snippets, etc :)
>
> see also Documentation/SubmittingPatches
> in the kernel tree.
>
> Thanks,
>
> -Eric
>
>> Signed-off-by: Akshay Lal <alal@google.com>
>> ---------------------------------------------------------------------------------------
>> Updated patch:
>> ---------------------------------------------------------------------------------------
>> From e6906071ab6c0ad38d3ee0a463b5c7944e71fd00 Mon Sep 17 00:00:00 2001
>> From: Akshay Lal <alal@google.com>
>> Date: Tue, 7 Sep 2010 12:54:33 -0700
>> Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
>>
>> As found by Theodore Ts'o:
>> If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
>> write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
>> This is bad since it forces e2fsck to complain about that inode.
>> If you have a large number of inodes that are written with fallocate
>> using KEEP_SIZE, and then fill them up to their expected size,
>> e2fsck will potentially complain about a _huge_ number of inodes.
>> This would also cause a huge increase in the time taken by e2fsck
>> to complete its check.
>>
>> Test scenarios covered:
>> 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
>> 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
>> 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
>>
>> These test cases exercise the normal and edge case conditions using
>> falloc (and KEEP_SIZE).
>>
>> Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
>> ---
>> 243 | 178 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>> 243.out | 13 +++++
>> group | 1 +
>> 3 files changed, 192 insertions(+), 0 deletions(-)
>> create mode 100644 243
>> create mode 100644 243.out
>>
>> diff --git a/243 b/243
>> new file mode 100644
>> index 0000000..8b2e647
>> --- /dev/null
>> +++ b/243
>> @@ -0,0 +1,178 @@
>> +#! /bin/bash
>> +# FS QA Test No. 243
>> +#
>> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
>> +#
>> +# As found by Theodore Ts'o:
>> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
>> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
>> +# This is bad since it forces e2fsck to complain about that inode.
>> +# If you have a large number of inodes that are written with fallocate
>> +# using KEEP_SIZE, and then fill them up to their expected size,
>> +# e2fsck will potentially complain about a _huge_ number of inodes.
>> +# This would also cause a huge increase in the time taken by e2fsck
>> +# to complete its check.
>> +#
>> +# Test scenarios covered:
>> +# 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
>> +# 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
>> +# 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
>> +#
>> +# These test cases exercise the normal and edge case conditions using
>> +# falloc (and KEEP_SIZE).
>> +#
>> +# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
>> +#
>> +#-----------------------------------------------------------------------
>> +# Copyright (c) 2010 Google, 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
>> +#-----------------------------------------------------------------------
>> +#
>> +# creator
>> +owner=alal@google.com
>> +
>> +seq=`basename $0`
>> +echo "QA output created by $seq"
>> +
>> +here=`pwd`
>> +tmp=/tmp/$$
>> +status=1 # failure is the default!
>> +trap "_cleanup; exit \$status" 0 1 2 3 15
>> +
>> +# Test specific macros.
>> +BIT_NOT_SET=0 # inode flag - 0x400000 bit is not set.
>> +BIT_SET=1 # inode flag - 0x400000 bit is set.
>> +
>> +# Generic test cleanup function.
>> +_cleanup()
>> +{
>> + cd /
>> + rm -f $tmp.*
>> +}
>> +
>> +# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
>> +# enabled. The only time this bit should be set is when extending the allocated
>> +# blocks further than what the i_size represents. In the situations wherein the
>> +# i_size covers all allocated blocks, this bit should be cleared.
>> +
>> +# Checks the state of the sample file in the filesystem and returns whether
>> +# the inode flag 0x400000 is set or not.
>> +_check_ext4_eof_flag()
>> +{
>> + # Check whether EOFBLOCK_FL is set.
>> + # For ext4 filesystems: use debugfs to check if EOFBLOCKS_FL is set.
>> + # Other filesystems: do nothing. The default fsck at the end of the test
>> + # should catch any potential errors.
>> + if [ "${FSTYP}" == "ext4" ]; then
>> + bit_set=1
>> +
>> + # Unmount the ${TEST_DEV}
>> + umount ${TEST_DEV}
>> +
>> + # Run debugfs to gather file_parameters - specifically iflags.
>> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
>> + iflags=${file_params#*Flags: }
>> +
>> + # Ensure that the iflags value was parsed correctly.
>> + if [ -z ${iflags} ]; then
>> + echo "iFlags value was not parsed successfully." >> $seq.full
>> + status=1
>> + exit ${status}
>> + fi
>> +
>> + # Check if EOFBLOCKS_FL is set.
>> + if ((${iflags} & 0x400000)); then
>> + echo "EOFBLOCK_FL bit is set." >> $seq.full
>> + bit_set=1
>> + else
>> + echo "EOFBLOCK_FL bit is not set." >> $seq.full
>> + bit_set=0
>> + fi
>> +
>> + # Check current bit state to expected value.
>> + if [ ${bit_set} -ne ${2} ]; then
>> + echo "Error: Current bit state incorrect." >> $seq.full
>> + status=1
>> + exit ${status}
>> + fi
>> +
>> + # Mount the ${TEST_DEV}
>> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
>> + fi
>> +}
>> +
>> +# Get standard environment, filters and checks.
>> +. ./common.rc
>> +. ./common.filter
>> +
>> +# Prerequisites for the test run.
>> +_supported_fs ext4 xfs btrfs gfs2
>> +_supported_os Linux
>> +_require_xfs_io_falloc
>> +
>> +# Real QA test starts here.
>> +rm -f $seq.full
>> +
>> +# Begin test cases.
>> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 4096' \
>> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_1 ${BIT_SET}
>> +
>> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f -d \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 4096' \
>> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_2 ${BIT_SET}
>> +
>> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 40960' \
>> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
>> +
>> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f -d \
>> + -c 'falloc -k 0 40960' \
>> + -c 'pwrite 0 40960' \
>> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
>> +
>> +echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f \
>> + -c 'falloc -k 0 128k' \
>> + -c 'pwrite 256k 4k' \
>> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
>> +
>> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
>> + >> $seq.full
>> +${XFS_IO_PROG} -F -f -d \
>> + -c 'falloc -k 0 128k' \
>> + -c 'pwrite 256k 4k' \
>> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
>> +_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
>> +
>> +status=0
>> +exit ${status}
>> diff --git a/243.out b/243.out
>> new file mode 100644
>> index 0000000..290a005
>> --- /dev/null
>> +++ b/243.out
>> @@ -0,0 +1,13 @@
>> +QA output created by 243
>> +wrote 4096/4096 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 4096/4096 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 40960/40960 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 40960/40960 bytes at offset 0
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 4096/4096 bytes at offset 262144
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> +wrote 4096/4096 bytes at offset 262144
>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>> diff --git a/group b/group
>> index ff16bb3..e6dab13 100644
>> --- a/group
>> +++ b/group
>> @@ -356,3 +356,4 @@ deprecated
>> 240 auto aio quick rw
>> 241 auto
>> 242 auto quick prealloc
>> +243 auto quick prealloc
>
>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
* Re: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
2010-09-08 18:52 ` Akshay Lal
@ 2010-09-08 19:11 ` Eric Sandeen
0 siblings, 0 replies; 14+ messages in thread
From: Eric Sandeen @ 2010-09-08 19:11 UTC (permalink / raw)
To: alal; +Cc: xfs
Akshay Lal wrote:
> Thanks Eric, as we move fwd, these patch will be better.
>
No problem, I appreciate the testcase... a lot! :)
-Eric
> ---
> Cheers!
> Akshay Lal
>
>
>
> On Wed, Sep 8, 2010 at 11:51 AM, Eric Sandeen <sandeen@sandeen.net> wrote:
>> Akshay Lal wrote:
>>> There was a missing fi at the the end of the _check_ext4_eof_flag method.
>>>
>>> Also corrected some indentation.
>> Thanks, I've committed this version.
>>
>> In the future, keeping patch resubmissions tidy is helpful, i.e.
>>
>> Subject: [PATCH Vx] subsystem: description
>>
>> patch description
>>
>> Signed-off-by:
>> ---
>> other information that won't go into the commit
>>
>> patch itself
>>
>> ... without the other cruft, forwarded snippets, etc :)
>>
>> see also Documentation/SubmittingPatches
>> in the kernel tree.
>>
>> Thanks,
>>
>> -Eric
>>
>>> Signed-off-by: Akshay Lal <alal@google.com>
>>> ---------------------------------------------------------------------------------------
>>> Updated patch:
>>> ---------------------------------------------------------------------------------------
>>> From e6906071ab6c0ad38d3ee0a463b5c7944e71fd00 Mon Sep 17 00:00:00 2001
>>> From: Akshay Lal <alal@google.com>
>>> Date: Tue, 7 Sep 2010 12:54:33 -0700
>>> Subject: [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
>>>
>>> As found by Theodore Ts'o:
>>> If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
>>> write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
>>> This is bad since it forces e2fsck to complain about that inode.
>>> If you have a large number of inodes that are written with fallocate
>>> using KEEP_SIZE, and then fill them up to their expected size,
>>> e2fsck will potentially complain about a _huge_ number of inodes.
>>> This would also cause a huge increase in the time taken by e2fsck
>>> to complete its check.
>>>
>>> Test scenarios covered:
>>> 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
>>> 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
>>> 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
>>>
>>> These test cases exercise the normal and edge case conditions using
>>> falloc (and KEEP_SIZE).
>>>
>>> Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
>>> ---
>>> 243 | 178 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++++
>>> 243.out | 13 +++++
>>> group | 1 +
>>> 3 files changed, 192 insertions(+), 0 deletions(-)
>>> create mode 100644 243
>>> create mode 100644 243.out
>>>
>>> diff --git a/243 b/243
>>> new file mode 100644
>>> index 0000000..8b2e647
>>> --- /dev/null
>>> +++ b/243
>>> @@ -0,0 +1,178 @@
>>> +#! /bin/bash
>>> +# FS QA Test No. 243
>>> +#
>>> +# Test to ensure that the EOFBLOCK_FL gets set/unset correctly.
>>> +#
>>> +# As found by Theodore Ts'o:
>>> +# If a 128K file is falloc'ed using the KEEP_SIZE flag, and then
>>> +# write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly.
>>> +# This is bad since it forces e2fsck to complain about that inode.
>>> +# If you have a large number of inodes that are written with fallocate
>>> +# using KEEP_SIZE, and then fill them up to their expected size,
>>> +# e2fsck will potentially complain about a _huge_ number of inodes.
>>> +# This would also cause a huge increase in the time taken by e2fsck
>>> +# to complete its check.
>>> +#
>>> +# Test scenarios covered:
>>> +# 1. Fallocating X bytes and writing Y (Y<X) (buffered and direct io)
>>> +# 2. Fallocating X bytes and writing Y (Y=X) (buffered and direct io)
>>> +# 3. Fallocating X bytes and writing Y (Y>X) (buffered and direct io)
>>> +#
>>> +# These test cases exercise the normal and edge case conditions using
>>> +# falloc (and KEEP_SIZE).
>>> +#
>>> +# Ref: http://thread.gmane.org/gmane.comp.file-systems.ext4/20682
>>> +#
>>> +#-----------------------------------------------------------------------
>>> +# Copyright (c) 2010 Google, 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
>>> +#-----------------------------------------------------------------------
>>> +#
>>> +# creator
>>> +owner=alal@google.com
>>> +
>>> +seq=`basename $0`
>>> +echo "QA output created by $seq"
>>> +
>>> +here=`pwd`
>>> +tmp=/tmp/$$
>>> +status=1 # failure is the default!
>>> +trap "_cleanup; exit \$status" 0 1 2 3 15
>>> +
>>> +# Test specific macros.
>>> +BIT_NOT_SET=0 # inode flag - 0x400000 bit is not set.
>>> +BIT_SET=1 # inode flag - 0x400000 bit is set.
>>> +
>>> +# Generic test cleanup function.
>>> +_cleanup()
>>> +{
>>> + cd /
>>> + rm -f $tmp.*
>>> +}
>>> +
>>> +# Ext4 uses the EOFBLOCKS_FL bit when fallocating blocks with KEEP_SIZE
>>> +# enabled. The only time this bit should be set is when extending the allocated
>>> +# blocks further than what the i_size represents. In the situations wherein the
>>> +# i_size covers all allocated blocks, this bit should be cleared.
>>> +
>>> +# Checks the state of the sample file in the filesystem and returns whether
>>> +# the inode flag 0x400000 is set or not.
>>> +_check_ext4_eof_flag()
>>> +{
>>> + # Check whether EOFBLOCK_FL is set.
>>> + # For ext4 filesystems: use debugfs to check if EOFBLOCKS_FL is set.
>>> + # Other filesystems: do nothing. The default fsck at the end of the test
>>> + # should catch any potential errors.
>>> + if [ "${FSTYP}" == "ext4" ]; then
>>> + bit_set=1
>>> +
>>> + # Unmount the ${TEST_DEV}
>>> + umount ${TEST_DEV}
>>> +
>>> + # Run debugfs to gather file_parameters - specifically iflags.
>>> + file_params=`debugfs ${TEST_DEV} -R "stat ${1}" 2>&1 | grep -e Flags:`
>>> + iflags=${file_params#*Flags: }
>>> +
>>> + # Ensure that the iflags value was parsed correctly.
>>> + if [ -z ${iflags} ]; then
>>> + echo "iFlags value was not parsed successfully." >> $seq.full
>>> + status=1
>>> + exit ${status}
>>> + fi
>>> +
>>> + # Check if EOFBLOCKS_FL is set.
>>> + if ((${iflags} & 0x400000)); then
>>> + echo "EOFBLOCK_FL bit is set." >> $seq.full
>>> + bit_set=1
>>> + else
>>> + echo "EOFBLOCK_FL bit is not set." >> $seq.full
>>> + bit_set=0
>>> + fi
>>> +
>>> + # Check current bit state to expected value.
>>> + if [ ${bit_set} -ne ${2} ]; then
>>> + echo "Error: Current bit state incorrect." >> $seq.full
>>> + status=1
>>> + exit ${status}
>>> + fi
>>> +
>>> + # Mount the ${TEST_DEV}
>>> + mount ${TEST_DEV} -t ${FSTYP} ${TEST_DIR}
>>> + fi
>>> +}
>>> +
>>> +# Get standard environment, filters and checks.
>>> +. ./common.rc
>>> +. ./common.filter
>>> +
>>> +# Prerequisites for the test run.
>>> +_supported_fs ext4 xfs btrfs gfs2
>>> +_supported_os Linux
>>> +_require_xfs_io_falloc
>>> +
>>> +# Real QA test starts here.
>>> +rm -f $seq.full
>>> +
>>> +# Begin test cases.
>>> +echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
>>> + >> $seq.full
>>> +${XFS_IO_PROG} -F -f \
>>> + -c 'falloc -k 0 40960' \
>>> + -c 'pwrite 0 4096' \
>>> + ${TEST_DIR}/test_1 | _filter_xfs_io_unique
>>> +_check_ext4_eof_flag test_1 ${BIT_SET}
>>> +
>>> +echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
>>> + >> $seq.full
>>> +${XFS_IO_PROG} -F -f -d \
>>> + -c 'falloc -k 0 40960' \
>>> + -c 'pwrite 0 4096' \
>>> + ${TEST_DIR}/test_2 | _filter_xfs_io_unique
>>> +_check_ext4_eof_flag test_2 ${BIT_SET}
>>> +
>>> +echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
>>> + >> $seq.full
>>> +${XFS_IO_PROG} -F -f \
>>> + -c 'falloc -k 0 40960' \
>>> + -c 'pwrite 0 40960' \
>>> + ${TEST_DIR}/test_3 | _filter_xfs_io_unique
>>> +_check_ext4_eof_flag test_3 ${BIT_NOT_SET}
>>> +
>>> +echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
>>> + >> $seq.full
>>> +${XFS_IO_PROG} -F -f -d \
>>> + -c 'falloc -k 0 40960' \
>>> + -c 'pwrite 0 40960' \
>>> + ${TEST_DIR}/test_4 | _filter_xfs_io_unique
>>> +_check_ext4_eof_flag test_4 ${BIT_NOT_SET}
>>> +
>>> +echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
>>> + >> $seq.full
>>> +${XFS_IO_PROG} -F -f \
>>> + -c 'falloc -k 0 128k' \
>>> + -c 'pwrite 256k 4k' \
>>> + ${TEST_DIR}/test_5 | _filter_xfs_io_unique
>>> +_check_ext4_eof_flag test_5 ${BIT_NOT_SET}
>>> +
>>> +echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
>>> + >> $seq.full
>>> +${XFS_IO_PROG} -F -f -d \
>>> + -c 'falloc -k 0 128k' \
>>> + -c 'pwrite 256k 4k' \
>>> + ${TEST_DIR}/test_6 | _filter_xfs_io_unique
>>> +_check_ext4_eof_flag test_6 ${BIT_NOT_SET}
>>> +
>>> +status=0
>>> +exit ${status}
>>> diff --git a/243.out b/243.out
>>> new file mode 100644
>>> index 0000000..290a005
>>> --- /dev/null
>>> +++ b/243.out
>>> @@ -0,0 +1,13 @@
>>> +QA output created by 243
>>> +wrote 4096/4096 bytes at offset 0
>>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>>> +wrote 4096/4096 bytes at offset 0
>>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>>> +wrote 40960/40960 bytes at offset 0
>>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>>> +wrote 40960/40960 bytes at offset 0
>>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>>> +wrote 4096/4096 bytes at offset 262144
>>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>>> +wrote 4096/4096 bytes at offset 262144
>>> +XXX Bytes, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
>>> diff --git a/group b/group
>>> index ff16bb3..e6dab13 100644
>>> --- a/group
>>> +++ b/group
>>> @@ -356,3 +356,4 @@ deprecated
>>> 240 auto aio quick rw
>>> 241 auto
>>> 242 auto quick prealloc
>>> +243 auto quick prealloc
>>
>
_______________________________________________
xfs mailing list
xfs@oss.sgi.com
http://oss.sgi.com/mailman/listinfo/xfs
^ permalink raw reply [flat|nested] 14+ messages in thread
end of thread, other threads:[~2010-09-08 19:10 UTC | newest]
Thread overview: 14+ messages (download: mbox.gz / follow: Atom feed)
-- links below jump to the message on this page --
2010-08-27 20:33 [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode Akshay Lal
2010-08-27 21:49 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly Eric Sandeen
2010-08-27 23:10 ` Akshay Lal
2010-08-27 23:23 ` Eric Sandeen
2010-08-27 23:32 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly. As found by Theodore Ts'o: If a 128K file is falloc'ed using the KEEP_SIZE flag, and then write exactly 128K, the EOFBLOCK_FL doesn't get cleared correctly. This forces e2fsck to complain about that inode Dave Chinner
2010-08-28 0:03 ` [PATCH] Test to ensure that the EOFBLOCK_FL gets set/unset correctly Eric Sandeen
2010-08-28 0:17 ` Dave Chinner
2010-08-28 0:23 ` Eric Sandeen
2010-08-30 17:33 ` Akshay Lal
2010-09-07 18:23 ` Eric Sandeen
2010-09-07 19:58 ` Akshay Lal
2010-09-08 18:51 ` Eric Sandeen
2010-09-08 18:52 ` Akshay Lal
2010-09-08 19:11 ` Eric Sandeen
This is an external index of several public inboxes,
see mirroring instructions on how to clone and mirror
all data and code used by this external index.