##/bin/bash
-#-----------------------------------------------------------------------
-# Copyright (c) 2000-2006 Silicon Graphics, Inc. All Rights Reserved.
-# This program is free software; you can redistribute it and/or modify
-# it under the terms of the GNU General Public License as published by
-# the Free Software Foundation; either version 2 of the License, or
-# (at your option) any later version.
-#
-# This program is distributed in the hope that it will 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 to the Free Software
-# Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307
-# USA
-#
-# Contact information: Silicon Graphics, Inc., 1500 Crittenden Lane,
-# Mountain View, CA 94043, USA, or: http://www.sgi.com
-#-----------------------------------------------------------------------
+# SPDX-License-Identifier: GPL-2.0+
+# Copyright (c) 2000-2006 Silicon Graphics, Inc. All Rights Reserved.
-BC=$(which bc 2> /dev/null) || BC=
+. common/config
-# Valid test names start with 3 digits "NNN":
-# "[0-9]\{3\}"
-# followed by an optional "-":
-# "-\?"
-# followed by an optional combination of alphanumeric and "-" chars:
-# "[[:alnum:]-]*"
-# e.g. 999-the-mark-of-fstests
-#
-VALID_TEST_ID="[0-9]\{3\}"
-VALID_TEST_NAME="$VALID_TEST_ID-\?[[:alnum:]-]*"
+BC=$(which bc 2> /dev/null) || BC=
# Some tests are not relevant or functional when testing XFS realtime
# subvolumes along with the rtinherit=1 mkfs option. In these cases,
ls -l $* | sed "s/\(^[-rwxdlbcpsStT]*\)\. /\1 /" | grep -v 'lost+found'
}
-# we need common/config
-if [ "$iam" != "check" ]
-then
- if ! . ./common/config
- then
- echo "$iam: failed to source common/config"
- exit 1
- fi
-fi
-
_dump_err()
{
_err_msg="$*"
echo "$_err_msg"
}
+_dump_err_cont()
+{
+ _err_msg="$*"
+ echo -n "$_err_msg"
+}
+
_dump_err2()
{
_err_msg="$*"
- >2& echo "$_err_msg"
+ >&2 echo "$_err_msg"
}
_log_err()
[ "$XFS_REPAIR_PROG" = "" ] && _fatal "xfs_repair not found"
[ "$XFS_DB_PROG" = "" ] && _fatal "xfs_db not found"
[ "$MKFS_XFS_PROG" = "" ] && _fatal "mkfs_xfs not found"
+ [ "$XFS_INFO_PROG" = "" ] && _fatal "xfs_info not found"
. ./common/xfs
;;
_assert_report_list
fi
+_get_filesize()
+{
+ stat -c %s "$1"
+}
+
_mount()
{
$MOUNT_PROG `_mount_ops_filter $*`
_mount $scratch_opts $*
if [ $? -eq 0 ]; then
+ # mount --move operation updates the mountpoint, so remove
+ # the old one and insert the new one
+ if [[ "$*" =~ --move|-M ]]; then
+ MOUNTED_POINT_STACK=`echo $MOUNTED_POINT_STACK | \
+ cut -d\ -f2-`
+ fi
MOUNTED_POINT_STACK="$mnt_point $MOUNTED_POINT_STACK"
else
return 1
local fstyp=`$DF_PROG $dir | tail -1 | $AWK_PROG '{print $2}'`
case "$fstyp" in
xfs)
- xfs_info $dir | grep -q "ftype=1"
+ $XFS_INFO_PROG $dir | grep -q "ftype=1"
;;
ext2|ext3|ext4)
local dev=`$DF_PROG $dir | tail -1 | $AWK_PROG '{print $1}'`
local testfile=$dir/$$.ftype
touch $testfile
# look for DT_UNKNOWN files
- local unknowns=$(src/t_dir_type $dir u | wc -l)
+ local unknowns=$($here/src/t_dir_type $dir u | wc -l)
rm $testfile
# 0 unknowns is success
return $unknowns
local opts="$1"
if test -n "$opts"; then
- mount -o "remount,$opts" $SCRATCH_MNT
+ _try_scratch_mount "-o remount,$opts"
fi
}
if [ -z $OVL_BASE_SCRATCH_DEV ]; then
_fail "_scratch_shutdown: call _require_scratch_shutdown first in test"
else
- src/godown $* $OVL_BASE_SCRATCH_MNT
+ $here/src/godown $* $OVL_BASE_SCRATCH_MNT
fi
else
- src/godown $* $SCRATCH_MNT
+ $here/src/godown $* $SCRATCH_MNT
+ fi
+}
+
+# Return a file path that can be used to shut down the scratch filesystem.
+# Caller should _require_scratch_shutdown before using this.
+_scratch_shutdown_handle()
+{
+ if [ $FSTYP = "overlay" ]; then
+ echo $OVL_BASE_SCRATCH_MNT
+ else
+ echo $SCRATCH_MNT
fi
}
9p)
# do nothing for 9p
;;
+ virtiofs)
+ # do nothing for virtiofs
+ ;;
ceph)
# do nothing for ceph
;;
9p)
# do nothing for 9p
;;
+ virtiofs)
+ # do nothing for virtiofs
+ ;;
overlay)
# do nothing for overlay
;;
local mkfs_status
case $FSTYP in
- nfs*|cifs|ceph|overlay|glusterfs|pvfs2|9p)
+ nfs*|cifs|ceph|overlay|glusterfs|pvfs2|9p|virtiofs)
# unable to re-create this fstyp, just remove all files in
# $SCRATCH_MNT to avoid EEXIST caused by the leftover files
# created in previous runs
{
case $FSTYP in
btrfs)
- # if dup profile is in mkfs options call _scratch_mkfs instead
- # because dup profile only works with single device
- if [[ "$*" =~ dup ]]; then
- _scratch_mkfs $*
- else
- $MKFS_BTRFS_PROG $MKFS_OPTIONS $* $SCRATCH_DEV_POOL > /dev/null
- fi
+ $MKFS_BTRFS_PROG $MKFS_OPTIONS $* $SCRATCH_DEV_POOL > /dev/null
;;
*)
echo "_scratch_pool_mkfs is not implemented for $FSTYP" 1>&2
free -b | grep ^Mem | awk '{print $4}'
}
+_available_memory_bytes()
+{
+ nf=`free -b | grep ^Mem | awk '{print NF}'`
+ if [[ nf -lt 7 ]]; then
+ # Doesn't have available field. Fallback.
+ _free_memory_bytes
+ else
+ free -b | grep ^Mem | awk '{print $7}'
+ fi
+}
+
# Create fs of certain size on scratch device
# _scratch_mkfs_sized <size in bytes> [optional blocksize]
_scratch_mkfs_sized()
;;
btrfs)
local mixed_opt=
- (( fssize <= 1024 * 1024 * 1024 )) && mixed_opt='--mixed'
+ # minimum size that's needed without the mixed option.
+ # Ref: btrfs-prog: btrfs_min_dev_size()
+ # Non mixed mode is also the default option.
+ (( fssize < $((256 * 1024 *1024)) )) && mixed_opt='--mixed'
$MKFS_BTRFS_PROG $MKFS_OPTIONS $mixed_opt -b $fssize $SCRATCH_DEV
;;
jfs)
return $res
;;
*)
- # Let's hope fsck -y suffices...
- fsck -t $FSTYP -y $SCRATCH_DEV 2>&1
+ local dev=$SCRATCH_DEV
+ local fstyp=$FSTYP
+ if [ $FSTYP = "overlay" -a -n "$OVL_BASE_SCRATCH_DEV" ]; then
+ _repair_overlay_scratch_fs
+ # Fall through to repair base fs
+ dev=$OVL_BASE_SCRATCH_DEV
+ fstyp=$OVL_BASE_FSTYP
+ $UMOUNT_PROG $OVL_BASE_SCRATCH_MNT
+ fi
+ # Let's hope fsck -y suffices...
+ fsck -t $fstyp -y $dev 2>&1
local res=$?
case $res in
- 0|1|2)
+ $FSCK_OK|$FSCK_NONDESTRUCT|$FSCK_REBOOT)
res=0
;;
*)
-e "/[0-9]:[0-9][0-9] *$1 /s/ .*//p"
}
-# fix malloc libs output
-#
-_fix_malloc()
-{
- # filter out the Electric Fence notice
- $PERL_PROG -e '
- while (<>) {
- if (defined $o && /^\s+Electric Fence/) {
- chomp($o);
- print "$o";
- undef $o;
- next;
- }
- print $o if (defined $o);
-
- $o=$_;
- }
- print $o if (defined $o);
- '
-}
-
#
# _df_device : get an IRIX style df line for a given device
#
fi
if [ -b "$dev" ]; then
- src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
+ $here/src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
fi
}
fi
if [ -c "$dev" ]; then
- src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
+ $here/src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
fi
}
(eval "echo '---' \"$cmd\"") >>$seqres.full
(eval "$cmd") >$tmp._out 2>&1
local ret=$?
- cat $tmp._out | _fix_malloc >>$seqres.full
+ cat $tmp._out >>$seqres.full
rm -f $tmp._out
if [ $# -eq 2 ]; then
if [ $ret -eq 0 ]; then
_notrun "this test requires a valid \$SCRATCH_MNT"
fi
;;
- 9p)
+ 9p|virtiofs)
if [ -z "$SCRATCH_DEV" ]; then
_notrun "this test requires a valid \$SCRATCH_DEV"
fi
touch ${RESULT_DIR}/require_scratch
}
+# require a scratch dev of a minimum size (in kb)
+_require_scratch_size()
+{
+ [ $# -eq 1 ] || _fail "_require_scratch_size: expected size param"
+
+ _require_scratch
+ local devsize=`_get_device_size $SCRATCH_DEV`
+ [ $devsize -lt $1 ] && _notrun "scratch dev too small"
+}
+
# this test needs a test partition - check we're ok & mount it
#
_notrun "this test requires a valid \$TEST_DIR"
fi
;;
- 9p)
+ 9p|virtiofs)
if [ -z "$TEST_DEV" ]; then
_notrun "this test requires a valid \$TEST_DEV"
fi
_require_sane_bdev_flush $SCRATCH_DEV
_require_command "$DMSETUP_PROG" dmsetup
+ echo $MOUNT_OPTIONS | grep -q dax
+ if [ $? -eq 0 ]; then
+ case $target in
+ stripe|linear|log-writes)
+ ;;
+ *)
+ _notrun "Cannot run tests with DAX on $target devices."
+ ;;
+ esac
+ fi
+
modprobe dm-$target >/dev/null 2>&1
$DMSETUP_PROG targets 2>&1 | grep -q ^$target
{
if [ -z "$1" ]
then
- AIO_TEST=src/aio-dio-regress/aiodio_sparse2
+ AIO_TEST=$here/src/aio-dio-regress/aiodio_sparse2
[ -x $AIO_TEST ] || _notrun "aio-dio utilities required"
else
- AIO_TEST=src/aio-dio-regress/$1
+ AIO_TEST=$here/src/aio-dio-regress/$1
[ -x $AIO_TEST ] || _notrun "$AIO_TEST not built"
fi
_require_aio
#
_require_test_program()
{
- local prog=src/$1
+ local prog=$here/src/$1
[ -x $prog ] || _notrun "$prog not built"
}
return $status
}
-# this test requires y2038 sysfs switch and filesystem
-# timestamp ranges support.
-_require_y2038()
+_require_timestamp_range()
{
local device=${1:-$TEST_DEV}
- local sysfsdir=/proc/sys/fs/fs-timestamp-check-on
-
- if [ ! -e $sysfsdir ]; then
- _notrun "no kernel support for y2038 sysfs switch"
- fi
local tsmin tsmax
read tsmin tsmax <<<$(_filesystem_timestamp_range $device)
if [ $tsmin -eq -1 -a $tsmax -eq -1 ]; then
_notrun "filesystem $FSTYP timestamp bounds are unknown"
fi
+
+ # expect console warning from rw scratch mount if fs limit is near
+ if [ $tsmax -le $((1<<31)) ] && \
+ ! _check_dmesg_for "filesystem being mounted at .* supports timestamps until"
+ then
+ _notrun "Kernel does not support timestamp limits"
+ fi
}
_filesystem_timestamp_range()
{
local device=${1:-$TEST_DEV}
- case $FSTYP in
- ext4)
+ local fstyp=${2:-$FSTYP}
+ u32max=$(((1<<32)-1))
+ s32min=-$((1<<31))
+ s32max=$(((1<<31)-1))
+ s64max=$(((1<<63)-1))
+ s64min=$((1<<63))
+
+ case $fstyp in
+ ext2)
+ echo "$s32min $s32max"
+ ;;
+ ext3|ext4)
if [ $(dumpe2fs -h $device 2>/dev/null | grep "Inode size:" | cut -d: -f2) -gt 128 ]; then
- echo "-2147483648 15032385535"
+ printf "%d %d\n" $s32min 0x37fffffff
else
- echo "-2147483648 2147483647"
+ echo "$s32min $s32max"
fi
;;
+ jfs)
+ echo "0 $u32max"
+ ;;
xfs)
- echo "-2147483648 2147483647"
+ echo "$s32min $s32max"
;;
- jfs)
- echo "0 4294967295"
+ btrfs)
+ echo "$s64min $s64max"
;;
- f2fs)
- echo "-2147483648 2147483647"
+ overlay)
+ if [ ! -z $OVL_BASE_FSTYP -a $OVL_BASE_FSTYP != "overlay" ]; then
+ _filesystem_timestamp_range $OVL_BASE_TEST_DEV $OVL_BASE_FSTYP
+ else
+ echo "-1 -1"
+ fi
;;
*)
echo "-1 -1"
local dn
dn=$(domainname 2>/dev/null)
local ypcat=$(type -P ypcat)
- test -n "${dn}" -a "${dn}" != "(none)" -a "${dn}" != "localdomain" -a -n "${ypcat}"
+ local rpcinfo=$(type -P rpcinfo)
+ test -n "${dn}" -a "${dn}" != "(none)" -a "${dn}" != "localdomain" -a -n "${ypcat}" -a -n "${rpcinfo}" && \
+ "${rpcinfo}" -p localhost 2>/dev/null | grep -q ypbind
echo $?
}
local command=$1
shift
local param="$*"
- local param_checked=0
+ local param_checked=""
local opts=""
local testfile=$TEST_DIR/$$.xfs_io
local testio
case $command in
+ "chattr")
+ if [ -z "$param" ]; then
+ param=s
+ fi
+ # Test xfs_io chattr support AND
+ # filesystem FS_IOC_FSSETXATTR support
+ testio=`$XFS_IO_PROG -F -f -c "chattr +$param" $testfile 2>&1`
+ $XFS_IO_PROG -F -f -r -c "chattr -$param" $testfile 2>&1
+ param_checked="+$param"
+ ;;
"chproj")
testio=`$XFS_IO_PROG -F -f -c "chproj 0" $testfile 2>&1`
;;
"copy_range")
local testcopy=$TEST_DIR/$$.copy.xfs_io
+ local copy_opts=$testfile
+ if [ "$param" == "-f" ]; then
+ # source file is the open destination file
+ testcopy=$testfile
+ copy_opts="0 -d 4k -l 4k"
+ fi
$XFS_IO_PROG -F -f -c "pwrite 0 4k" $testfile > /dev/null 2>&1
- testio=`$XFS_IO_PROG -F -f -c "copy_range $testfile" $testcopy 2>&1`
+ testio=`$XFS_IO_PROG -F -f -c "copy_range $param $copy_opts" $testcopy 2>&1`
rm -f $testcopy > /dev/null 2>&1
+ param_checked="$param"
;;
"falloc" )
testio=`$XFS_IO_PROG -F -f -c "falloc $param 0 1m" $testfile 2>&1`
- param_checked=1
+ param_checked="$param"
;;
"fpunch" | "fcollapse" | "zero" | "fzero" | "finsert" | "funshare")
local blocksize=$(_get_block_size $TEST_DIR)
fi
testio=`$XFS_IO_PROG -F -f -c "pwrite 0 20k" -c "fsync" \
-c "fiemap -v $param" $testfile 2>&1`
- param_checked=1
+ param_checked="$param"
;;
- "flink" )
- testio=`$XFS_IO_PROG -T -F -c "flink $testfile" \
- $TEST_DIR 2>&1`
+ "flink")
+ local testlink=$TEST_DIR/$$.link.xfs_io
+ testio=`$XFS_IO_PROG -F -f -c "flink $testlink" $testfile 2>&1`
+ rm -f $testlink > /dev/null 2>&1
+ ;;
+ "-T")
+ # Check O_TMPFILE support in xfs_io, kernel and fs
+ testio=`$XFS_IO_PROG -T -c quit $TEST_DIR 2>&1`
echo $testio | egrep -q "invalid option|Is a directory" && \
_notrun "xfs_io $command support is missing"
+ echo $testio | grep -q "Operation not supported" && \
+ _notrun "O_TMPFILE is not supported"
;;
- "fsmap" )
+ "fsmap")
testio=`$XFS_IO_PROG -f -c "fsmap" $testfile 2>&1`
echo $testio | grep -q "Inappropriate ioctl" && \
_notrun "xfs_io $command support is missing"
;;
+ "label")
+ testio=`$XFS_IO_PROG -c "label" $TEST_DIR 2>&1`
+ ;;
"open")
# -c "open $f" is broken in xfs_io <= 4.8. Along with the fix,
# a new -C flag was introduced to execute one shot commands.
fi
testio=`$XFS_IO_PROG -f $opts -c \
"pwrite $pwrite_opts $param 0 4k" $testfile 2>&1`
- param_checked=1
+ param_checked="$pwrite_opts $param"
;;
"scrub"|"repair")
- testio=`$XFS_IO_PROG -x -c "$command probe 0" $TEST_DIR 2>&1`
+ testio=`$XFS_IO_PROG -x -c "$command probe" $TEST_DIR 2>&1`
echo $testio | grep -q "Inappropriate ioctl" && \
_notrun "xfs_io $command support is missing"
;;
"utimes" )
- testio=`$XFS_IO_PROG -f -c "utimes" 0 0 0 0 $testfile 2>&1`
+ testio=`$XFS_IO_PROG -f -c "utimes 0 0 0 0" $testfile 2>&1`
;;
"syncfs")
touch $testfile
rm -f $testfile 2>&1 > /dev/null
echo $testio | grep -q "not found" && \
- _notrun "xfs_io $command support is missing"
- echo $testio | grep -q "Operation not supported" && \
- _notrun "xfs_io $command failed (old kernel/wrong fs?)"
+ _notrun "xfs_io $command $param_checked support is missing"
+ echo $testio | grep -q "Operation not supported\|Inappropriate ioctl" && \
+ _notrun "xfs_io $command $param_checked failed (old kernel/wrong fs?)"
echo $testio | grep -q "Invalid" && \
- _notrun "xfs_io $command failed (old kernel/wrong fs/bad args?)"
+ _notrun "xfs_io $command $param_checked failed (old kernel/wrong fs/bad args?)"
echo $testio | grep -q "foreign file active" && \
- _notrun "xfs_io $command not supported on $FSTYP"
+ _notrun "xfs_io $command $param_checked not supported on $FSTYP"
echo $testio | grep -q "Function not implemented" && \
- _notrun "xfs_io $command support is missing (missing syscall?)"
+ _notrun "xfs_io $command $param_checked support is missing (missing syscall?)"
[ -n "$param" ] || return
- if [ $param_checked -eq 0 ]; then
- $XFS_IO_PROG -c "help $command" | grep -q "^ $param --" || \
+ if [ -z "$param_checked" ]; then
+ $XFS_IO_PROG -c "help $command" | grep -E -q "^ $param ([a-zA-Z_]+ )?--" || \
_notrun "xfs_io $command doesn't support $param"
else
# xfs_io could result in "command %c not supported" if it was
# check that kernel and filesystem support direct I/O
_require_odirect()
{
- if [ $FSTYP = "ext4" ] ; then
+ if [ $FSTYP = "ext4" ] || [ $FSTYP = "f2fs" ] ; then
if echo "$MOUNT_OPTIONS" | grep -q "test_dummy_encryption"; then
- _notrun "ext4 encryption doesn't support O_DIRECT"
- elif echo "$MOUNT_OPTIONS" | grep -q "data=journal"; then
+ _notrun "$FSTYP encryption doesn't support O_DIRECT"
+ fi
+ fi
+ if [ $FSTYP = "ext4" ] ; then
+ if echo "$MOUNT_OPTIONS" | grep -q "data=journal"; then
_notrun "ext4 data journaling doesn't support O_DIRECT"
fi
fi
rm -f $testfile 2>&1 > /dev/null
}
+_format_swapfile() {
+ local fname="$1"
+ local sz="$2"
+
+ rm -f "$fname"
+ touch "$fname"
+ chmod 0600 "$fname"
+ # Swap files must be nocow on Btrfs.
+ $CHATTR_PROG +C "$fname" > /dev/null 2>&1
+ _pwrite_byte 0x61 0 "$sz" "$fname" >> $seqres.full
+ $MKSWAP_PROG "$fname" >> $seqres.full
+}
+
# Check that the filesystem supports swapfiles
_require_scratch_swapfile()
{
_require_scratch
+ _require_command "$MKSWAP_PROG" "mkswap"
_scratch_mkfs >/dev/null
+
+ # With mounting SELinux context(e.g. system_u:object_r:root_t:s0),
+ # standard mkswap tried to reset the type of default context to
+ # swapfile_t if it's not swapfile_t, and then it failed and returned
+ # ENOTSUP expectedly as we don't want to create any SELinux attr on
+ # purpose. standard mkswap ignored this relabel error by commit
+ # d97dc0e of util-linux, but it still reported the error before
+ # commit d97dc0e. We mount swapfile context directly to skip the
+ # reset step.
+ [ -n "$SELINUX_MOUNT_OPTIONS" ] && export \
+ SELINUX_MOUNT_OPTIONS="-o context=system_u:object_r:swapfile_t:s0"
+
_scratch_mount
# Minimum size for mkswap is 10 pages
- local size=$(($(get_page_size) * 10))
+ _format_swapfile "$SCRATCH_MNT/swap" $(($(get_page_size) * 10))
- _pwrite_byte 0x61 0 "$size" "$SCRATCH_MNT/swap" >/dev/null 2>&1
- mkswap "$SCRATCH_MNT/swap" >/dev/null 2>&1
if ! swapon "$SCRATCH_MNT/swap" >/dev/null 2>&1; then
_scratch_unmount
_notrun "swapfiles are not supported"
_require_sparse_files()
{
case $FSTYP in
- hfsplus)
+ hfsplus|exfat)
_notrun "Sparse files not supported by this filesystem type: $FSTYP"
;;
*)
{
[ -f "$DEBUGFS_MNT/fail_make_request/probability" ] \
|| _notrun "$DEBUGFS_MNT/fail_make_request \
- not found. Seems that CONFIG_FAIL_MAKE_REQUEST kernel config option not enabled"
+ not found. Seems that CONFIG_FAULT_INJECTION_DEBUG_FS kernel config option not enabled"
}
# Disable extent zeroing for ext4 on the given device
echo 0 >/sys/fs/ext4/$sdev/extent_max_zeroout_kb
}
+# The default behavior of SEEK_HOLE is to always return EOF.
+# Filesystems that implement non-default behavior return the offset
+# of holes with SEEK_HOLE. There is no way to query the filesystem
+# of which behavior it is implementing.
+# We use this whitelist FSTYP, to set expectation and avoid silent
+# regression of filesystem seek hole behavior.
+#
+# Return 0 for true
+_fstyp_has_non_default_seek_data_hole()
+{
+ if [ -z $1 ]; then
+ local fstyp=$FSTYP
+ else
+ local fstyp=$1
+ fi
+
+ case "$fstyp" in
+ btrfs|ext4|xfs|cifs|f2fs|gfs2|ocfs2|tmpfs)
+ return 0
+ ;;
+ nfs*)
+ # NFSv2 and NFSv3 only support default behavior of SEEK_HOLE,
+ # while NFSv4 supports non-default behavior
+ local nfsvers=`_df_device $TEST_DEV | $AWK_PROG '{ print $2 }'`
+ [ "$nfsvers" = "nfs4" ]
+ return $?
+ ;;
+ overlay)
+ if [ ! -z $OVL_BASE_FSTYP -a $OVL_BASE_FSTYP != "overlay" ]; then
+ _fstyp_has_non_default_seek_data_hole $OVL_BASE_FSTYP
+ return $?
+ else
+ # Assume that base fs has default behavior
+ return 1
+ fi
+ ;;
+ *)
+ # by default fstyp has default SEEK_HOLE behavior;
+ # if your fs has non-default behavior, add it to whitelist above!
+ return 1
+ ;;
+ esac
+}
+
+# Run seek sanity test with predefined expectation for SEEK_DATA/HOLE behavior
+_run_seek_sanity_test()
+{
+ local testseekargs
+ if _fstyp_has_non_default_seek_data_hole; then
+ testseekargs+="-f"
+ fi
+ $here/src/seek_sanity_test $testseekargs $*
+}
+
# Check if the file system supports seek_data/hole
_require_seek_data_hole()
{
9p)
# no way to check consistency for 9p
;;
+ virtiofs)
+ # no way to check consistency for virtiofs
+ ;;
ceph)
# no way to check consistency for CephFS
;;
9p)
# no way to check consistency for 9p
;;
+ virtiofs)
+ # no way to check consistency for virtiofs
+ ;;
ceph)
# no way to check consistency for CephFS
;;
{
local os=`uname -s`
local host=`hostname -s`
- local kernel=`uname -r`
+ local kernel=`uname -rv`
local platform=`uname -m`
echo "$os/$platform $host $kernel"
}
local features
if [ $# -eq 0 ]; then
- features="$(_get_os_name)"
+ features="$(_get_os_name),$FSTYP"
if [ -n "$MOUNT_OPTIONS" ]; then
features=$features,${MOUNT_OPTIONS##"-o "}
fi
done
}
-# We will check if the device is deletable
-_require_deletable_scratch_dev_pool()
-{
- local i
- local x
- for i in $SCRATCH_DEV_POOL; do
- x=`echo $i | cut -d"/" -f 3`
- if [ ! -f /sys/class/block/${x}/device/delete ]; then
- _notrun "$i is a device which is not deletable"
- fi
- done
-}
# Check that fio is present, and it is able to execute given jobfile
_require_fio()
# Does shutdown work on this fs?
_require_scratch_shutdown()
{
- [ -x src/godown ] || _notrun "src/godown executable not found"
+ [ -x $here/src/godown ] || _notrun "src/godown executable not found"
_scratch_mkfs > /dev/null 2>&1 || _notrun "_scratch_mkfs failed on $SCRATCH_DEV"
_scratch_mount
# SCRATCH_DEV, in this case OVL_BASE_SCRATCH_DEV
# will be null, so check OVL_BASE_SCRATCH_DEV before
# running shutdown to avoid shutting down base fs accidently.
- _notrun "$SCRATCH_DEV is not a block device"
+ _notrun "This test requires a valid $OVL_BASE_SCRATCH_DEV as ovl base fs"
else
- src/godown -f $OVL_BASE_SCRATCH_MNT 2>&1 \
+ $here/src/godown -f $OVL_BASE_SCRATCH_MNT 2>&1 \
|| _notrun "Underlying filesystem does not support shutdown"
fi
else
- src/godown -f $SCRATCH_MNT 2>&1 \
+ $here/src/godown -f $SCRATCH_MNT 2>&1 \
|| _notrun "$FSTYP does not support shutdown"
fi
# It's possible that TEST_DEV and SCRATCH_DEV have different features (it'd be
# odd, but possible) so check $TEST_DEV by default, but we can optionall pass
# any dev we want.
-_require_metadata_journaling()
+_has_metadata_journaling()
{
if [ -z $1 ]; then
local dev=$TEST_DEV
fi
case "$FSTYP" in
- ext2|vfat|msdos|udf)
- _notrun "$FSTYP does not support metadata journaling"
+ ext2|vfat|msdos|udf|exfat)
+ echo "$FSTYP does not support metadata journaling"
+ return 1
;;
ext4)
# ext4 could be mkfs'd without a journal...
_require_dumpe2fs
- $DUMPE2FS_PROG -h $dev 2>&1 | grep -q has_journal || \
- _notrun "$FSTYP on $dev not configured with metadata journaling"
+ $DUMPE2FS_PROG -h $dev 2>&1 | grep -q has_journal || {
+ echo "$FSTYP on $dev not configured with metadata journaling"
+ return 1
+ }
# ext4 might not load a journal
- _exclude_scratch_mount_option "noload"
+ if _normalize_mount_options | grep -qw "noload"; then
+ echo "mount option \"noload\" not allowed in this test"
+ return 1
+ fi
;;
overlay)
# metadata journaling check is based on base filesystem configurations
# and because -overlay option saves those configurations to OVL_BASE_*,
# adding restore/override the configurations before/after the check.
if [ ! -z $OVL_BASE_FSTYP -a $OVL_BASE_FSTYP != "overlay" ]; then
+ local ret
+
_overlay_config_restore
- _require_metadata_journaling
+ _has_metadata_journaling
+ ret=$?
_overlay_config_override
+ return $ret
else
- _notrun "No metadata journaling support for legacy overlay setup"
+ echo "No metadata journaling support for legacy overlay setup"
+ return 1
fi
;;
*)
# by default we pass; if you need to, add your fs above!
;;
esac
+ return 0
+}
+
+_require_metadata_journaling()
+{
+ local msg=$(_has_metadata_journaling $@)
+ if [ -n "$msg" ]; then
+ _notrun "$msg"
+ fi
}
_count_extents()
{
- $XFS_IO_PROG -c "fiemap" $1 | tail -n +2 | grep -v hole | wc -l
+ $XFS_IO_PROG -r -c "fiemap" $1 | tail -n +2 | grep -v hole | wc -l
+}
+
+# Similar to _count_extents() but if any extent is shared multiples times in
+# the file (reflinked to different file offsets), it is accounted as 1 extent
+# instead of N extents.
+_count_exclusive_extents()
+{
+ $XFS_IO_PROG -r -c "fiemap" $1 | tail -n +2 | grep -v hole | \
+ cut -d ' ' -f 3 | sort | uniq | wc -l
}
_count_holes()
{
- $XFS_IO_PROG -c "fiemap" $1 | tail -n +2 | grep hole | wc -l
+ $XFS_IO_PROG -r -c "fiemap" $1 | tail -n +2 | grep hole | wc -l
}
_count_attr_extents()
_require_atime()
{
_exclude_scratch_mount_option "noatime"
- if [ "$FSTYP" == "nfs" ]; then
- _notrun "atime related mount options have no effect on NFS"
- fi
+ case $FSTYP in
+ nfs|cifs)
+ _notrun "atime related mount options have no effect on $FSTYP"
+ ;;
+ esac
+
}
_require_relatime()
_require_userns()
{
- [ -x src/nsexec ] || _notrun "src/nsexec executable not found"
- src/nsexec -U true 2>/dev/null || _notrun "userns not supported by this kernel"
+ [ -x $here/src/nsexec ] || _notrun "src/nsexec executable not found"
+ $here/src/nsexec -U true 2>/dev/null || _notrun "userns not supported by this kernel"
}
_create_loop_device()
esac
shift
done
- echo $args
+ printf '%s\n' "$args"
}
#
"$@" >> $seqres.full 2>&1 || _fail "failed: '$@'"
}
-_require_test_symlinks()
+_require_symlinks()
{
local target=`mktemp -p $TEST_DIR`
local link=`mktemp -p $TEST_DIR -u`
rm -f $target $link
}
+_require_hardlinks()
+{
+ local target=`mktemp -p $TEST_DIR`
+ local link=`mktemp -p $TEST_DIR -u`
+ ln $target $link
+ if [ "$?" -ne 0 ]; then
+ rm -f $target
+ _notrun "No hardlink support"
+ fi
+ rm -f $target $link
+}
+
_require_test_fcntl_advisory_locks()
{
[ "$FSTYP" != "cifs" ] && return 0
_notrun "Require fcntl advisory locks support"
}
+_require_test_fcntl_setlease()
+{
+ _require_test_program "locktest"
+ touch $TEST_DIR/setlease_testfile
+ $here/src/locktest -t $TEST_DIR/setlease_testfile >/dev/null 2>&1
+ [ $? -eq 22 ] && _notrun "Require fcntl setlease support"
+}
+
_require_ofd_locks()
{
# Give a test run by getlk wrlck on testfile.
# EINVAL will be returned.
_require_test_program "t_ofd_locks"
touch $TEST_DIR/ofd_testfile
- src/t_ofd_locks -t $TEST_DIR/ofd_testfile > /dev/null 2>&1
+ $here/src/t_ofd_locks -t $TEST_DIR/ofd_testfile > /dev/null 2>&1
[ $? -eq 22 ] && _notrun "Require OFD locks support"
}
# return device size in kb
_get_device_size()
{
- grep `_short_dev $1` /proc/partitions | awk '{print $3}'
+ grep -w `_short_dev $1` /proc/partitions | awk '{print $3}'
}
# Make sure we actually have dmesg checking set up.
_dmesg_since_test_start | egrep -q "$1"
}
+# Default filter for dmesg scanning.
+# Ignore lockdep complaining about its own bugginess when scanning dmesg
+# output, because we shouldn't be failing filesystem tests on account of
+# lockdep.
+_check_dmesg_filter()
+{
+ egrep -v -e "BUG: MAX_LOCKDEP_CHAIN_HLOCKS too low" \
+ -e "BUG: MAX_STACK_TRACE_ENTRIES too low"
+}
+
# check dmesg log for WARNING/Oops/etc.
_check_dmesg()
{
# default filter is a simple cat command, caller could provide a
# customized filter and pass the name through the first argument, to
# filter out intentional WARNINGs or Oopses
- local filter=${1:-cat}
+ local filter=${1:-_check_dmesg_filter}
_dmesg_since_test_start | $filter >$seqres.dmesg
egrep -q -e "kernel BUG at" \
-e "WARNING:" \
- -e "BUG:" \
+ -e "\bBUG:" \
-e "Oops:" \
-e "possible recursive locking detected" \
-e "Internal error" \
_dump_err "_check_dmesg: something found in dmesg (see $seqres.dmesg)"
return 1
else
- rm -f $seqres.dmesg
+ if [ "$KEEP_DMESG" != "yes" ]; then
+ rm -f $seqres.dmesg
+ fi
return 0
fi
}
# capture the kmemleak report
_capture_kmemleak()
{
- local kern_knob="${DEBUGFS_MNT}/kmemleak"
+ local kern_knob="$DEBUGFS_MNT/kmemleak"
local leak_file="$1"
# Tell the kernel to scan for memory leaks. Apparently the write
echo "clear" > "$kern_knob"
}
-# set up kmemleak
-_init_kmemleak()
+# Figure out if the running kernel supports kmemleak; if it does, clear out
+# anything that leaked before we even started testing. The leak checker only
+# needs to be primed like this once per ./check invocation.
+_detect_kmemleak()
{
- local kern_knob="${DEBUGFS_MNT}/kmemleak"
+ local kern_knob="$DEBUGFS_MNT/kmemleak"
+ KMEMLEAK_CHECK_FILE="/tmp/check_kmemleak"
+
+ # Since kernel v4.19-rc3, the kmemleak knob exists even if kmemleak is
+ # disabled, but returns EBUSY on write. So instead of relying on
+ # existance of writable knob file, we use a test file to indicate that
+ # _check_kmemleak() is enabled only if we actually managed to write to
+ # the knob file.
+ rm -f "$KMEMLEAK_CHECK_FILE"
if [ ! -w "$kern_knob" ]; then
return 0
# Disable the automatic scan so that we can control it completely,
# then dump all the leaks recorded so far.
- echo "scan=off" > "$kern_knob"
- _capture_kmemleak /dev/null
+ if echo "scan=off" > "$kern_knob" 2>/dev/null; then
+ _capture_kmemleak /dev/null
+ touch "$KMEMLEAK_CHECK_FILE"
+ fi
}
-# check kmemleak log
+# Kick the kmemleak checker to scan for leaks. Background leak scan mode is
+# not enabled, so we must call the kernel to ask for a scan and deal with the
+# results appropriately. This we do after every test completes, whether or not
+# it was successful.
_check_kmemleak()
{
- local kern_knob="${DEBUGFS_MNT}/kmemleak"
- local leak_file="${seqres}.kmemleak"
+ local kern_knob="$DEBUGFS_MNT/kmemleak"
+ local leak_file="$seqres.kmemleak"
- if [ ! -w "$kern_knob" ]; then
+ if [ ! -f "$KMEMLEAK_CHECK_FILE" ]; then
+ return 0
+ fi
+
+ # Not enabled, so discard any report of leaks found.
+ if [ "$USE_KMEMLEAK" != "yes" ]; then
+ _capture_kmemleak /dev/null
return 0
fi
init_rc()
{
- if [ "$iam" == new ]
- then
- return
- fi
# make some further configuration checks here
if [ "$TEST_DEV" = "" ]
then
esac
}
+# Get the maximum size of a file in $TEST_DIR (s_maxbytes). On ext4 this will
+# be UINT32_MAX * block_size, but other filesystems may allow up to LLONG_MAX.
+_get_max_file_size()
+{
+ local testfile=$TEST_DIR/maxfilesize.$seq
+ local l=0
+ local r=9223372036854775807 # LLONG_MAX
+
+ rm -f $testfile
+ while (( l < r )); do
+ # Use _math() to avoid signed integer overflow.
+ local m=$(_math "($l + $r + 1) / 2")
+ if $XFS_IO_PROG -f -c "truncate $m" $testfile \
+ |& grep -q 'File too large'
+ then
+ r=$(( m - 1 ))
+ else
+ l=$m
+ fi
+ done
+ echo $l
+}
+
+# get MAX_LFS_FILESIZE
+_get_max_lfs_filesize()
+{
+ case "$(getconf LONG_BIT)" in
+ "32")
+ local ulong_max=$(getconf ULONG_MAX)
+ local page_size=$(getconf PAGE_SIZE)
+ echo $(( ulong_max * page_size ))
+ ;;
+ "64")
+ echo 9223372036854775807
+ ;;
+ *)
+ _fail "sizeof(long) == $(getconf LONG_BIT)?"
+ ;;
+ esac
+}
+
+# The maximum filesystem label length, /not/ including terminating NULL
+_label_get_max()
+{
+ case $FSTYP in
+ xfs)
+ echo 12
+ ;;
+ btrfs)
+ echo 255
+ ;;
+ f2fs)
+ echo 255
+ ;;
+ *)
+ _notrun "$FSTYP does not define maximum label length"
+ ;;
+ esac
+}
+
+# Helper to check above early in a script
+_require_label_get_max()
+{
+ # Just call _label_get_max which will notrun if appropriate
+ dummy=$(_label_get_max)
+}
+
+_dmsetup_remove()
+{
+ $UDEV_SETTLE_PROG >/dev/null 2>&1
+ $DMSETUP_PROG remove "$@" >>$seqres.full 2>&1
+ $DMSETUP_PROG mknodes >/dev/null 2>&1
+}
+
+_dmsetup_create()
+{
+ $DMSETUP_PROG create "$@" >>$seqres.full 2>&1 || return 1
+ $DMSETUP_PROG mknodes >/dev/null 2>&1
+ $UDEV_SETTLE_PROG >/dev/null 2>&1
+}
+
+_require_btime()
+{
+ # Note: filesystems are not required to report btime (creation time)
+ # if the caller doesn't ask for it, so we define STATX_BTIME here and
+ # pass it in to the statx command.
+ export STATX_BTIME=0x800
+ $XFS_IO_PROG -f $TEST_DIR/test_creation_time -c "statx -m $STATX_BTIME -v" \
+ | grep btime >>$seqres.full 2>&1 || \
+ _notrun "inode creation time not supported by this filesystem"
+ rm -f $TEST_DIR/test_creation_time
+}
+
+_require_scratch_btime()
+{
+ _require_scratch
+ _scratch_mkfs > /dev/null 2>&1
+ _scratch_mount
+
+ # Note: filesystems are not required to report btime (creation time)
+ # if the caller doesn't ask for it, so we define STATX_BTIME here and
+ # pass it in to the statx command.
+ export STATX_BTIME=0x800
+ $XFS_IO_PROG -f $SCRATCH_MNT/test_creation_time -c "statx -m $STATX_BTIME -v" \
+ | grep btime >>$seqres.full 2>&1 || \
+ _notrun "inode creation time not supported by this filesystem"
+
+ _scratch_unmount
+}
+
+_require_inode_limits()
+{
+ if [ $(_get_free_inode $TEST_DIR) -eq 0 ]; then
+ _notrun "$FSTYP does not have a fixed number of inodes available"
+ fi
+}
+
+_require_filefrag_options()
+{
+ _require_command "$FILEFRAG_PROG" filefrag
+
+ local options=$1
+ local file="$TEST_DIR/options_testfile"
+
+ echo "XX" > $file
+ ${FILEFRAG_PROG} -$options $file 2>&1 | grep -q "invalid option" && \
+ _notrun "filefrag doesn't support $options option"
+ rm -f $file
+}
+
+_require_fibmap()
+{
+ _require_filefrag_options "B"
+
+ local file="$TEST_DIR/fibmap_testfile"
+
+ echo "XX" > $file
+ ${FILEFRAG_PROG} -B $file 2>&1 | grep -q "FIBMAP[[:space:]]*unsupported"
+ if [ $? -eq 0 ]; then
+ _notrun "FIBMAP not supported by this filesystem"
+ fi
+ rm -f $file
+}
+
+_try_wipe_scratch_devs()
+{
+ test -x "$WIPEFS_PROG" || return 0
+
+ # Do specified filesystem wipe at first
+ case "$FSTYP" in
+ "xfs")
+ _try_wipe_scratch_xfs
+ ;;
+ esac
+
+ # Then do wipefs on all scratch devices
+ for dev in $SCRATCH_DEV_POOL $SCRATCH_DEV $SCRATCH_LOGDEV $SCRATCH_RTDEV; do
+ test -b $dev && $WIPEFS_PROG -a $dev
+ done
+}
+
+# Only run this on xfs if xfs_scrub is available and has the unicode checker
+_check_xfs_scrub_does_unicode() {
+ [ "${FSTYP}" == "xfs" ] || return 1
+
+ local mount="$1"
+ local dev="$2"
+
+ _supports_xfs_scrub "${mount}" "${dev}" || return 1
+
+ # We only care if xfs_scrub has unicode string support...
+ if ! type ldd > /dev/null 2>&1 || \
+ ! ldd "${XFS_SCRUB_PROG}" | grep -q libicui18n; then
+ return 1
+ fi
+
+ return 0
+}
+
+# exfat timestamps start at 1980 and cannot be prior to epoch
+_require_negative_timestamps() {
+ case "$FSTYP" in
+ ceph|exfat)
+ _notrun "$FSTYP does not support negative timestamps"
+ ;;
+ esac
+}
+
+# Require the 'accton' userspace tool and CONFIG_BSD_PROCESS_ACCT=y.
+_require_bsd_process_accounting()
+{
+ _require_command "$ACCTON_PROG" accton
+ $ACCTON_PROG on &> $tmp.test_accton
+ cat $tmp.test_accton >> $seqres.full
+ if grep 'Function not implemented' $tmp.test_accton; then
+ _notrun "BSD process accounting support unavailable"
+ fi
+ $ACCTON_PROG off >> $seqres.full
+}
+
init_rc
################################################################################
projects / xfstests-dev.git / blobdiff