* [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 a public inbox, see mirroring instructions for how to clone and mirror all data and code used for this inbox