* [PATCH xfstests 2/2] ext4/035: Add tests for filename casefolding feature
2019-05-06 18:59 [PATCH xfstests 1/2] common/casefold: Add infrastructure to test filename casefold feature Gabriel Krisman Bertazi
@ 2019-05-06 18:59 ` Gabriel Krisman Bertazi
2019-05-06 20:03 ` [PATCH xfstests 1/2] common/casefold: Add infrastructure to test filename casefold feature Theodore Ts'o
1 sibling, 0 replies; 4+ messages in thread
From: Gabriel Krisman Bertazi @ 2019-05-06 18:59 UTC (permalink / raw)
To: fstests; +Cc: tytso, linux-ext4, Lakshmipathi.G, Gabriel Krisman Bertazi
From: "Lakshmipathi.G" <lakshmipathi.ganapathi@collabora.co.uk>
This new test implements verification for the per-directory
case-insensitive feature, as supported in the reference implementation
in Ext4. Currently, this test only runs for Ext4, but it could be run
with minimal modifications on other filesystems, once they support the
feature.
Signed-off-by: Lakshmipathi.G <lakshmipathi.ganapathi@collabora.co.uk>
Signed-off-by: Gabriel Krisman Bertazi <krisman@collabora.com>
[Rewrite to support feature design]
[Refactor to simplify implementation]
---
tests/ext4/035 | 475 +++++++++++++++++++++++++++++++++++++++++++++
tests/ext4/035.out | 2 +
tests/ext4/group | 1 +
3 files changed, 478 insertions(+)
create mode 100755 tests/ext4/035
create mode 100644 tests/ext4/035.out
diff --git a/tests/ext4/035 b/tests/ext4/035
new file mode 100755
index 000000000000..120a76474973
--- /dev/null
+++ b/tests/ext4/035
@@ -0,0 +1,475 @@
+#! /bin/bash
+# FSQA Test No. 035
+#
+# Test the creation, mounting and basic functionality of file name
+# casefolding on Ext4
+#
+#-----------------------------------------------------------------------
+# Copyright (c) 2018 Collabora Ltd. All Rights Reserved.
+#
+# This program is free software; you can redistribute it and/or
+# modify it under the terms of the GNU General Public License as
+# published by the Free Software Foundation.
+#
+# This program is distributed in the hope that it would be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program; if not, write the Free Software Foundation,
+# Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
+#
+#-----------------------------------------------------------------------
+
+seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+echo "QA output created by $seq"
+status=1 # failure is thea default
+
+. ./common/rc
+. ./common/casefold
+
+_supported_fs ext4
+_supported_os Linux
+_require_scratch
+_require_check_dmesg
+
+sdev=$(_short_dev ${SCRATCH_DEV})
+test_casefold=${SCRATCH_MNT}
+
+filename1="file.txt"
+filename2="FILE.TXT"
+
+pt_file1=$(echo -e "coração")
+pt_file2=$(echo -e "corac\xcc\xa7\xc3\xa3o" | tr a-z A-Z)
+
+fr_file2=$(echo -e "french_caf\xc3\xa9.txt")
+fr_file1=$(echo -e "french_cafe\xcc\x81.txt")
+
+ar_file1=$(echo -e "arabic_\xdb\x92\xd9\x94.txt")
+ar_file2=$(echo -e "arabic_\xdb\x93.txt" | tr a-z A-Z)
+
+jp_file1=$(echo -e "japanese_\xe3\x82\xb2.txt")
+jp_file2=$(echo -e "japanese_\xe3\x82\xb1\xe3\x82\x99.txt")
+
+# '\xc3\x00' is an invalid sequence. Despite that, the sequences below
+# could match, if we ignored the error. But we don't want to be greedy
+# at normalization, so at the first error we treat the entire sequence
+# as an opaque blob. Therefore, these two must NOT match.
+blob_file1=$(echo -e "corac\xcc\xa7\xc3")
+blob_file2=$(echo -e "coraç\xc3")
+
+# Test helpers
+basic_create_lookup() {
+ touch "${basedir}/${1}"
+ stat "${basedir}/${2}" &> /dev/null || \
+ _fail "Casefolded lookup of ${1} ${2} failed"
+ _casefold_check_exact_name "${basedir}" "${1}" || \
+ _fail "Created file with wrong name."
+
+}
+
+# CI search should fail.
+bad_basic_create_lookup() {
+ touch "${basedir}/${1}"
+ stat "${basedir}/${2}" &> /dev/null && \
+ _fail "Lookup of ${1} using ${2} should have failed"
+}
+
+# Testcases
+test_casefold_lookup () {
+ basedir=${test_casefold}/casefold_lookup
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+
+ basic_create_lookup "${filename1}" "${filename2}"
+ basic_create_lookup "${pt_file1}" "${pt_file2}"
+ basic_create_lookup "${fr_file1}" "${fr_file2}"
+ basic_create_lookup "${ar_file1}" "${ar_file2}"
+ basic_create_lookup "${jp_file1}" "${jp_file2}"
+}
+
+test_bad_casefold_lookup () {
+ bad_basic_create_lookup ${blob_file1} ${blob_file2}
+}
+
+# remove and recreate
+test_create_and_remove() {
+ __create_and_remove() {
+ basic_create_lookup ${1}
+ rm -f ${basedir}/"${1}"
+ stat ${basedir}/"${1}" &> /dev/null && \
+ _fail "File ${1} was not removed using exact name"
+
+ basic_create_lookup ${1}
+ rm -f ${basedir}/"${2}"
+ stat ${basedir}/"${1}" &> /dev/null && \
+ _fail "File ${1} was not removed using inexact name"
+ }
+
+ basedir=${test_casefold}/create_and_remove
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+
+ __create_and_remove "${pt_file1}" "${pt_file2}"
+ __create_and_remove "${jp_file1}" "${jp_file2}"
+ __create_and_remove "${ar_file1}" "${ar_file2}"
+ __create_and_remove "${fr_file1}" "${fr_file2}"
+
+}
+
+test_casefold_flag_basic () {
+ basedir=${test_casefold}/basic
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+ _is_casefolded_dir ${basedir} || _fail "Casefold attribute wasn't set"
+
+ _unset_casefold_attr ${basedir}
+ _is_casefolded_dir ${basedir} && _fail "Casefold attribute is still set"
+}
+
+test_casefold_flag_removal () {
+ basedir=${test_casefold}/casefold_flag_removal
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+ touch ${basedir}/${filename1}
+
+ # Try to remove +F attribute on non empty directory
+ _try_unset_casefold_attr ${basedir} && \
+ _fail "Shouldn't be able to remove casefold attribute of non-empty directory"
+}
+
+
+# Test Inheritance of casefold flag
+test_casefold_flag_inheritance () {
+ dirpath1="d1/d2/d3"
+ dirpath2="D1/D2/D3"
+
+ basedir=${test_casefold}/flag_inheritance
+
+ mkdir -p ${basedir}
+ _set_casefold_attr ${basedir}
+
+ mkdir -p ${basedir}/${dirpath1}
+
+ _is_casefolded_dir ${basedir}/${dirpath1} || \
+ _fail "Casefold attribute should be inherited"
+ ls ${basedir}/${dirpath2} &>/dev/null || \
+ _fail "Dir Lookup failed."
+ _casefold_check_exact_name "${basedir}" "${dirpath1}" || \
+ _fail "Created directories wrong name."
+
+ touch ${basedir}/${dirpath2}/${filename1}
+ ls ${basedir}/${dirpath1}/${filename2} &>/dev/null || \
+ _fail "Couldn't create file on casefolded parent."
+}
+
+# Test nesting of sensitive directory inside insensitive directory.
+test_nesting_sensitive_insensitive_tree_simple() {
+ basedir=${test_casefold}/sd1
+ mkdir -p ${basedir}
+ _set_casefold_attr ${basedir}
+
+ mkdir -p ${basedir}/sd1
+ _set_casefold_attr ${basedir}/sd1
+
+ mkdir ${basedir}/sd1/sd2
+ _unset_casefold_attr ${basedir}/sd1/sd2
+
+ touch ${basedir}/sd1/sd2/${filename1}
+ ls ${basedir}/sd1/sd2/${filename1} &>/dev/null || \
+ _fail "Exact nested file lookup failed."
+ ls ${basedir}/sd1/SD2/${filename1} &>/dev/null || \
+ _fail "Nested file lookup failed."
+ ls ${basedir}/sd1/SD2/${filename2} &>/dev/null && \
+ _fail "Wrong file lookup passed, should have fail."
+}
+
+test_nesting_sensitive_insensitive_tree_complex() {
+ # Test nested-directories
+ basedir=${test_casefold}/nesting
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+
+ mkdir ${basedir}/nd1
+ _set_casefold_attr ${basedir}/nd1
+ mkdir ${basedir}/nd1/nd2
+ _unset_casefold_attr ${basedir}/nd1/nd2
+ mkdir ${basedir}/nd1/nd2/nd3
+ _set_casefold_attr ${basedir}/nd1/nd2/nd3
+ mkdir ${basedir}/nd1/nd2/nd3/nd4
+ _unset_casefold_attr ${basedir}/nd1/nd2/nd3/nd4
+ mkdir ${basedir}/nd1/nd2/nd3/nd4/nd5
+ _set_casefold_attr ${basedir}/nd1/nd2/nd3/nd4/nd5
+
+ ls ${basedir}/ND1/ND2/nd3/ND4/nd5 &>/dev/null || \
+ _fail "Nest-dir Lookup failed."
+ ls ${basedir}/nd1/nd2/nd3/nd4/ND5 &>/dev/null && \
+ _fail "ND5: Nest-dir Lookup passed, it should fail."
+ ls ${basedir}/nd1/nd2/nd3/ND4/nd5 &>/dev/null || \
+ _fail "Nest-dir Lookup failed."
+ ls ${basedir}/nd1/nd2/ND3/nd4/ND5 &>/dev/null && \
+ _fail "ND3: Nest-dir Lookup passed, it should fail."
+}
+
+
+test_symlink_with_inexact_name () {
+ basedir=${test_casefold}/symlink
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+
+ mkdir ${basedir}/ind1
+ mkdir ${basedir}/ind2
+ _set_casefold_attr ${basedir}/ind1
+ touch ${basedir}/ind1/target
+ ln -s ${basedir}/ind1/TARGET ${basedir}/ind2/link
+ [ -L ${basedir}/ind2/link ] || _fail "Not a symlink."
+ readlink -e ${basedir}/ind2/link &>/dev/null || _fail "Symlink failed"
+}
+
+
+# Name-preserving tests
+# We create a file with a name, delete it and create again with an
+# equivalent name. If the negative dentry wasn't invalidated, the
+# file might be created using $1 instead of $2.
+test_name_preserve () {
+ __test_name_preserve () {
+ touch ${basedir}/${1}
+ rm ${basedir}/${1}
+
+ touch ${basedir}/${2}
+ _casefold_check_exact_name ${basedir} ${2} ||
+ _fail "${2} was not created with exact name"
+ }
+ basedir=${test_casefold}/"test_name_preserve"
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+
+ __test_name_preserve "${pt_file1}" "${pt_file2}"
+ __test_name_preserve "${jp_file1}" "${jp_file2}"
+ __test_name_preserve "${ar_file1}" "${ar_file2}"
+ __test_name_preserve "${fr_file1}" "${fr_file2}"
+}
+
+test_dir_name_preserve () {
+
+ __test_dir_name_preserve () {
+ mkdir ${basedir}/${1}
+ rmdir ${basedir}/${1}
+
+ mkdir ${basedir}/${2}
+ _casefold_check_exact_name ${basedir} ${2} ||
+ _fail "${2} was not created with exact name"
+ }
+
+ basedir=${test_casefold}/"dir-test_name_preserve"
+ mkdir -p ${basedir}
+
+ _set_casefold_attr ${basedir}
+
+ __test_dir_name_preserve "${pt_file1}" "${pt_file2}"
+ __test_dir_name_preserve "${jp_file1}" "${jp_file2}"
+ __test_dir_name_preserve "${ar_file1}" "${ar_file2}"
+ __test_dir_name_preserve "${fr_file1}" "${fr_file2}"
+}
+
+# Name reuse for CI search
+test_name_reuse () {
+ basedir=${test_casefold}/reuse
+
+ mkdir ${basedir}
+ _set_casefold_attr ${basedir}
+
+ reuse1=fileX
+ reuse2=FILEX
+
+ touch ${basedir}/${reuse1}
+ rm -f ${basedir}/${reuse1} || _fail "File lookup failed."
+ touch ${basedir}/${reuse2}
+ _casefold_check_exact_name "${basedir}" "${reuse2}" || \
+ _fail "File created with wrong name"
+ _casefold_check_exact_name "${basedir}" "${reuse1}" && \
+ _fail "File created with the old name"
+}
+
+# filepath same name
+test_create_with_same_name () {
+ basedir=${test_casefold}/same_name
+ mkdir ${basedir}
+
+ _set_casefold_attr ${basedir}
+
+ mkdir -p ${basedir}/same1/same1
+ touch ${basedir}/SAME1/sAME1/sAMe1
+ touch -c ${basedir}/SAME1/sAME1/same1 ||
+ _fail "Trying to create a new file instead of using old one"
+}
+
+# file Rename
+test_file_rename () {
+ basedir=${test_casefold}/rename
+ mkdir -p ${basedir}
+ _set_casefold_attr ${basedir}
+
+ mv ${basedir}/rename ${basedir}/rename &>/dev/null && \
+ _fail "mv to an equivalent name shouldn't work"
+ _casefold_check_exact_name ${basedir} "rename" || \
+ _fail "Name shouldn't change."
+}
+
+test_casefold_openfd () {
+ # Test openfd with casefold.
+ # 1. Delete a file after gettings its fd.
+ # 2. Then create new dir with same name
+ ofd1="openfd"
+ ofd2="OPENFD"
+
+ basedir=${test_casefold}/openfd
+ mkdir -p ${basedir}
+ _set_casefold_attr ${basedir}
+
+ exec 3<> ${basedir}/${ofd1}
+ rm -rf ${basedir}/${ofd1}
+ mkdir ${basedir}/${ofd2}
+ [ -d ${basedir}/${ofd2} ] || _fail "Not a directory"
+ _casefold_check_exact_name ${basedir} "${ofd2}" ||
+ _fail "openfd file was created using old name"
+ rm -rf ${basedir}/${ofd2}
+ exec 3>&-
+}
+
+test_casefold_openfd2 () {
+ # Test openfd with casefold.
+ # 1. Delete a file after gettings its fd.
+ # 2. Then create new file with same name
+ # 3. Read from open-fd and write into new file.
+
+ basedir=${test_casefold}/openfd2
+ mkdir ${basedir}
+ _set_casefold_attr ${basedir}
+
+ date > ${basedir}/${ofd1}
+ exec 3<> ${basedir}/${ofd1}
+ rm -rf ${basedir}/${ofd1}
+ touch ${basedir}/${ofd1}
+ [ -f ${basedir}/${ofd2} ] || _fail "Not a file"
+ read data <&3
+ echo $data >> ${basedir}/${ofd1}
+ exec 3>&-
+}
+
+test_hard_link_lookups () {
+ # Create hardlink for casefold dir file and inside regular dir.
+ basedir=${test_casefold}/hard_link
+ mkdir ${basedir}
+ _set_casefold_attr ${basedir}
+
+ touch ${basedir}/h1
+ ln ${basedir}/H1 ${SCRATCH_MNT}/h1
+ cnt=`stat -c %h ${basedir}/h1`
+ [ $cnt -eq 1 ] && _fail "Unable to create hardlink"
+
+ # Create hardlink for casefold dir file and inside regular dir.
+ touch ${SCRATCH_MNT}/h2
+ ln ${SCRATCH_MNT}/h2 ${basedir}/H2
+ cnt=`stat -c %h ${basedir}/h2`
+ [ $cnt -eq 1 ] && _fail "Unable to create hardlink"
+}
+
+test_xattrs_lookups () {
+ basedir=${test_casefold}/xattrs
+ mkdir ${basedir}
+ _set_casefold_attr ${basedir}
+
+ mkdir -p ${basedir}/x
+ setfattr -n user.foo -v bar ${basedir}/x
+ getfattr -n user.foo ${basedir}/x &>/dev/null || \
+ _fail "Casefold xattr lookup failed."
+
+ touch ${basedir}/x/f1
+ setfattr -n user.foo -v bar ${basedir}/x/f1
+ getfattr -n user.foo ${basedir}/x/f1 &>/dev/null || \
+ _fail "Casefold xattr lookup failed."
+}
+
+test_lookup_large_directory() {
+ # Perform Casefold lookup on large dir
+
+ basedir=${test_casefold}/large
+ mkdir ${basedir}
+ _set_casefold_attr ${basedir}
+
+ touch $(seq -f "${basedir}/file%g" 0 2000)
+ stat $(seq -f "${basedir}/FILE%g" 0 2000) &>/dev/null || \
+ _fail "Case on large dir failed"
+}
+
+test_strict_mode_invalid_filename () {
+ __strict_mode_invalid_filename () {
+ touch "${basedir}/${1}" &>/dev/null && \
+ _fail "Invalid UTF-8 sequence ${1} should fail at creation time."
+ }
+
+ __strict_mode_invalid_filename ${blob1}
+ __strict_mode_invalid_filename ${blob2}
+}
+
+#############
+# Run tests #
+#############
+
+_scratch_mkfs_ext4 "-O casefold" 2>&1 1>/dev/null
+
+_has_casefold_feature ${SCRATCH_DEV} || \
+ _fail "encoding flag wasn't configured for ${sdev}"
+
+_scratch_mount
+
+_check_dmesg_for \
+ "\(${sdev}\): Using encoding defined by superblock: utf8" || \
+ _fail "Could not mount with encoding: utf8"
+
+test_casefold_flag_basic
+test_casefold_lookup
+test_bad_casefold_lookup
+test_create_and_remove
+test_casefold_flag_removal
+test_casefold_flag_inheritance
+test_nesting_sensitive_insensitive_tree_simple
+test_nesting_sensitive_insensitive_tree_complex
+test_symlink_with_inexact_name
+test_name_preserve
+test_dir_name_preserve
+test_name_reuse
+test_create_with_same_name
+test_file_rename
+test_casefold_openfd
+test_casefold_openfd2
+test_hard_link_lookups
+test_xattrs_lookups
+test_lookup_large_directory
+
+_scratch_unmount 2>&1
+_check_scratch_fs
+
+# Test Strict Mode
+_scratch_mkfs_ext4 \
+ "-O casefold -E encoding_flags=strict" 2>&1 1>/dev/null
+_scratch_mount 2>&1
+
+test_strict_mode_invalid_filename
+
+_scratch_unmount 2>&1
+_check_scratch_fs
+
+echo "Silence is golden"
+status=0
+exit
diff --git a/tests/ext4/035.out b/tests/ext4/035.out
new file mode 100644
index 000000000000..5c8f63c3e4f3
--- /dev/null
+++ b/tests/ext4/035.out
@@ -0,0 +1,2 @@
+QA output created by 035
+Silence is golden
diff --git a/tests/ext4/group b/tests/ext4/group
index eb744a121650..39ffa06ef036 100644
--- a/tests/ext4/group
+++ b/tests/ext4/group
@@ -37,6 +37,7 @@
032 auto quick ioctl resize
033 auto ioctl resize
034 auto quick quota
+035 auto quick casefold
271 auto rw quick
301 aio auto ioctl rw stress defrag
302 aio auto ioctl rw stress defrag
--
2.20.1
^ permalink raw reply related [flat|nested] 4+ messages in thread* Re: [PATCH xfstests 1/2] common/casefold: Add infrastructure to test filename casefold feature
2019-05-06 18:59 [PATCH xfstests 1/2] common/casefold: Add infrastructure to test filename casefold feature Gabriel Krisman Bertazi
2019-05-06 18:59 ` [PATCH xfstests 2/2] ext4/035: Add tests for filename casefolding feature Gabriel Krisman Bertazi
@ 2019-05-06 20:03 ` Theodore Ts'o
2019-05-06 20:32 ` Gabriel Krisman Bertazi
1 sibling, 1 reply; 4+ messages in thread
From: Theodore Ts'o @ 2019-05-06 20:03 UTC (permalink / raw)
To: Gabriel Krisman Bertazi; +Cc: fstests, linux-ext4
On Mon, May 06, 2019 at 02:59:40PM -0400, Gabriel Krisman Bertazi wrote:
> +_require_test_casefold_feature () {
> + _has_casefold_feature $TEST_DEV || \
> + _notrun "Feature casefold required for this test"
> +}
> +_require_scratch_casefold_feature () {
> + _has_casefold_feature $SCRATCH_DEV || \
> + _notrun "Feature casefold required for this test"
> +}
I've just pushed out a commit to ext4.git tree which will cause
/sys/fs/ext4/features/casefold will exist iff CONFIG_UNICODE is
present. This will allow the test to check whether or not the kernel
version and configuration will support the casefold feature.
Could you add a check for this flag if the file system type is ext4?
A file system independent way of doing this would be to create a test
file system on the test file system, calling "chattr +F" on the
directory. If it fails, then either the file system doesn't support
it or the chattr program is too old and doesn't support casefold. If
the chattr +F succeeds, then the test should call lsattr -d on the
directory and make sure the request to set casefold flag was actually
honored; some file systems will simply fail to set flags that they
don't support, so we do need to do a SETFLAGS followed by a GETFLAGS
to be sure that it was supported.
Speaking of file system independent casefold, I believe that it will
be likely that the casefold feature will be supported by f2fs in the
fullness of time. If that happens, how to test for the file system
feature will be different (since dumpe2fs is ext4-specific), but I
would expect "chattr +F" interface to be the same between ext4 and
f2fs.
This might mean that we should add casefold tests to either generic/
or shared/ instead of ext4/ --- I think it would be shared since at
least initially it would only be ext4 and f2fs, and I haven't seen any
indication than other file systems would be interested in adding
casefold support. Or we can move the casefold tests later from ext4/
to shared/ once the f2fs support materializes.
Cheers,
- Ted
^ permalink raw reply [flat|nested] 4+ messages in thread