dd()
{
- if [ "$HOSTOS" == "Linux" ]
- then
command dd --help 2>&1 | grep noxfer >/dev/null
-
if [ "$?" -eq 0 ]
then
command dd status=noxfer $@
else
command dd $@
- fi
- else
- command dd $@
- fi
+ fi
}
# Prints the md5 checksum of a given file
9p)
;;
ceph)
+ . ./common/ceph
;;
glusterfs)
;;
_assert_report_list
fi
+_get_filesize()
+{
+ stat -c %s "$1"
+}
+
+# Get hugepagesize in bytes
+_get_hugepagesize()
+{
+ local hugepgsz=$(awk '/Hugepagesize/ {print $2}' /proc/meminfo)
+ # Call _notrun if $hugepgsz is not a number
+ echo "$hugepgsz" | egrep -q ^[0-9]+$ || \
+ _notrun "Cannot get the value of Hugepagesize"
+ echo $((hugepgsz * 1024))
+}
+
_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 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
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
}
_scratch_mkfs_ext4()
{
local mkfs_cmd="$MKFS_EXT4_PROG -F"
- local mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
+ local mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \" | grep -v \"^$\""
local tmp=`mktemp -u`
local mkfs_status
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()
{
- local fssize=$1
- local blocksize=$2
- local def_blksz
-
- case $FSTYP in
- xfs)
- def_blksz=`echo $MKFS_OPTIONS|sed -rn 's/.*-b ?size= ?+([0-9]+).*/\1/p'`
- ;;
- ext2|ext3|ext4|ext4dev|udf|btrfs|reiser4|ocfs2|reiserfs)
- def_blksz=`echo $MKFS_OPTIONS| sed -rn 's/.*-b ?+([0-9]+).*/\1/p'`
- ;;
- jfs)
- def_blksz=4096
- ;;
- esac
-
- [ -n "$def_blksz" ] && blocksize=$def_blksz
- [ -z "$blocksize" ] && blocksize=4096
+ local fssize=$1
+ local blocksize=$2
+ local def_blksz
+ case $FSTYP in
+ xfs)
+ def_blksz=`echo $MKFS_OPTIONS | sed -rn 's/.*-b ?size= ?+([0-9]+).*/\1/p'`
+ ;;
+ ext2|ext3|ext4|ext4dev|udf|btrfs|reiser4|ocfs2|reiserfs)
+ def_blksz=`echo $MKFS_OPTIONS | sed -rn 's/.*-b ?+([0-9]+).*/\1/p'`
+ ;;
+ jfs)
+ def_blksz=4096
+ ;;
+ esac
- local re='^[0-9]+$'
- if ! [[ $fssize =~ $re ]] ; then
- _notrun "error: _scratch_mkfs_sized: fs size \"$fssize\" not an integer."
- fi
- if ! [[ $blocksize =~ $re ]] ; then
- _notrun "error: _scratch_mkfs_sized: block size \"$blocksize\" not an integer."
- fi
+ [ -n "$def_blksz" ] && blocksize=$def_blksz
+ [ -z "$blocksize" ] && blocksize=4096
- local blocks=`expr $fssize / $blocksize`
+ local re='^[0-9]+$'
+ if ! [[ $fssize =~ $re ]] ; then
+ _notrun "error: _scratch_mkfs_sized: fs size \"$fssize\" not an integer."
+ fi
+ if ! [[ $blocksize =~ $re ]] ; then
+ _notrun "error: _scratch_mkfs_sized: block size \"$blocksize\" not an integer."
+ fi
- if [ "$HOSTOS" == "Linux" -a -b "$SCRATCH_DEV" ]; then
- local devsize=`blockdev --getsize64 $SCRATCH_DEV`
- [ "$fssize" -gt "$devsize" ] && _notrun "Scratch device too small"
- fi
+ local blocks=`expr $fssize / $blocksize`
- case $FSTYP in
- xfs)
- # don't override MKFS_OPTIONS that set a block size.
- echo $MKFS_OPTIONS |egrep -q "b?size="
- if [ $? -eq 0 ]; then
- _scratch_mkfs_xfs -d size=$fssize
- else
- _scratch_mkfs_xfs -d size=$fssize -b size=$blocksize
+ if [ -b "$SCRATCH_DEV" ]; then
+ local devsize=`blockdev --getsize64 $SCRATCH_DEV`
+ [ "$fssize" -gt "$devsize" ] && _notrun "Scratch device too small"
fi
- ;;
- ext2|ext3|ext4|ext4dev)
- ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
- ;;
- gfs2)
- # mkfs.gfs2 doesn't automatically shrink journal files on small
- # filesystems, so the journal files may end up being bigger than the
- # filesystem, which will cause mkfs.gfs2 to fail. Until that's fixed,
- # shrink the journal size to at most one eigth of the filesystem and at
- # least 8 MiB, the minimum size allowed.
- local min_journal_size=8
- local default_journal_size=128
- if (( fssize/8 / (1024*1024) < default_journal_size )); then
- local journal_size=$(( fssize/8 / (1024*1024) ))
- (( journal_size >= min_journal_size )) || journal_size=$min_journal_size
- MKFS_OPTIONS="-J $journal_size $MKFS_OPTIONS"
- fi
- ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -O -b $blocksize $SCRATCH_DEV $blocks
- ;;
- ocfs2)
- yes | ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
- ;;
- udf)
- $MKFS_UDF_PROG $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
- ;;
- btrfs)
- local mixed_opt=
- # 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)
- ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS $SCRATCH_DEV $blocks
- ;;
- reiserfs)
- ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
- ;;
- reiser4)
- # mkfs.resier4 requires size in KB as input for creating filesystem
- $MKFS_REISER4_PROG $MKFS_OPTIONS -y -b $blocksize $SCRATCH_DEV \
- `expr $fssize / 1024`
- ;;
- f2fs)
- # mkfs.f2fs requires # of sectors as an input for the size
- local sector_size=`blockdev --getss $SCRATCH_DEV`
- $MKFS_F2FS_PROG $MKFS_OPTIONS $SCRATCH_DEV `expr $fssize / $sector_size`
- ;;
- tmpfs)
- local free_mem=`_free_memory_bytes`
- if [ "$free_mem" -lt "$fssize" ] ; then
- _notrun "Not enough memory ($free_mem) for tmpfs with $fssize bytes"
+
+ if [ "$FSTYP" = "xfs" ] && [ -b "$SCRATCH_RTDEV" ]; then
+ local rtdevsize=`blockdev --getsize64 $SCRATCH_RTDEV`
+ [ "$fssize" -gt "$rtdevsize" ] && _notrun "Scratch rt device too small"
+ rt_ops="-r size=$fssize"
fi
- export MOUNT_OPTIONS="-o size=$fssize $TMPFS_MOUNT_OPTIONS"
- ;;
- *)
- _notrun "Filesystem $FSTYP not supported in _scratch_mkfs_sized"
- ;;
- esac
+
+ case $FSTYP in
+ xfs)
+ # don't override MKFS_OPTIONS that set a block size.
+ echo $MKFS_OPTIONS |egrep -q "b?size="
+ if [ $? -eq 0 ]; then
+ _scratch_mkfs_xfs -d size=$fssize $rt_ops
+ else
+ _scratch_mkfs_xfs -d size=$fssize $rt_ops -b size=$blocksize
+ fi
+ ;;
+ ext2|ext3|ext4|ext4dev)
+ ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
+ ;;
+ gfs2)
+ # mkfs.gfs2 doesn't automatically shrink journal files on small
+ # filesystems, so the journal files may end up being bigger than the
+ # filesystem, which will cause mkfs.gfs2 to fail. Until that's fixed,
+ # shrink the journal size to at most one eigth of the filesystem and at
+ # least 8 MiB, the minimum size allowed.
+ local min_journal_size=8
+ local default_journal_size=128
+ if (( fssize/8 / (1024*1024) < default_journal_size )); then
+ local journal_size=$(( fssize/8 / (1024*1024) ))
+ (( journal_size >= min_journal_size )) || journal_size=$min_journal_size
+ MKFS_OPTIONS="-J $journal_size $MKFS_OPTIONS"
+ fi
+ ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -O -b $blocksize $SCRATCH_DEV $blocks
+ ;;
+ ocfs2)
+ yes | ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
+ ;;
+ udf)
+ $MKFS_UDF_PROG $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
+ ;;
+ btrfs)
+ local mixed_opt=
+ # 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)
+ ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS $SCRATCH_DEV $blocks
+ ;;
+ reiserfs)
+ ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
+ ;;
+ reiser4)
+ # mkfs.resier4 requires size in KB as input for creating filesystem
+ $MKFS_REISER4_PROG $MKFS_OPTIONS -y -b $blocksize $SCRATCH_DEV \
+ `expr $fssize / 1024`
+ ;;
+ f2fs)
+ # mkfs.f2fs requires # of sectors as an input for the size
+ local sector_size=`blockdev --getss $SCRATCH_DEV`
+ $MKFS_F2FS_PROG $MKFS_OPTIONS $SCRATCH_DEV `expr $fssize / $sector_size`
+ ;;
+ tmpfs)
+ local free_mem=`_free_memory_bytes`
+ if [ "$free_mem" -lt "$fssize" ] ; then
+ _notrun "Not enough memory ($free_mem) for tmpfs with $fssize bytes"
+ fi
+ export MOUNT_OPTIONS="-o size=$fssize $TMPFS_MOUNT_OPTIONS"
+ ;;
+ *)
+ _notrun "Filesystem $FSTYP not supported in _scratch_mkfs_sized"
+ ;;
+ esac
}
# Emulate an N-data-disk stripe w/ various stripe units
case $FSTYP in
xfs)
- MKFS_OPTIONS+=" -b size=$blocksize, -d su=$sunit_bytes,sw=$swidth_mult"
+ if echo "$MKFS_OPTIONS" | egrep -q "b?size="; then
+ MKFS_OPTIONS=$(echo "$MKFS_OPTIONS" | sed -r "s/(b?size=)[0-9]+/\1$blocksize/")
+ else
+ MKFS_OPTIONS+=" -b size=$blocksize"
+ fi
+
+ if echo "$MKFS_OPTIONS" | egrep -q "(su|sunit|sw|swidth)="; then
+ MKFS_OPTIONS=$(echo "$MKFS_OPTIONS" | sed -r \
+ -e "s/(su|sunit)=[0-9kmg]+/su=$sunit_bytes/" \
+ -e "s/(sw|swidth)=[0-9kmg]+/sw=$swidth_mult/")
+ else
+ MKFS_OPTIONS+=" -d su=$sunit_bytes,sw=$swidth_mult"
+ fi
;;
ext4|ext4dev)
MKFS_OPTIONS+=" -b $blocksize -E stride=$sunit_blocks,stripe_width=$swidth_blocks"
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
}
_notrun "not suitable for this filesystem type: $FSTYP"
}
-
-# tests whether $FSTYP is one of the supported OSes for a test
-#
-_supported_os()
-{
- local h
-
- for h
- do
- if [ "$h" = "$HOSTOS" ]
- then
- return
- fi
- done
-
- _notrun "not suitable for this OS: $HOSTOS"
-}
-
# check if a FS on a device is mounted
# if so, verify that it is mounted on mount point
# if fstype is given as argument, verify that it is also
_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
_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_loop()
{
- if [ "$HOSTOS" != "Linux" ]
- then
- _notrun "This test requires linux for loopback device support"
- fi
-
modprobe loop >/dev/null 2>&1
if grep loop /proc/devices >/dev/null 2>&1
then
#
_require_ext2()
{
- if [ "$HOSTOS" != "Linux" ]
- then
- _notrun "This test requires linux for ext2 filesystem support"
- fi
-
modprobe ext2 >/dev/null 2>&1
if grep ext2 /proc/filesystems >/dev/null 2>&1
then
_require_sane_bdev_flush $SCRATCH_DEV
_require_command "$DMSETUP_PROG" dmsetup
+ _normalize_mount_options | egrep -q "dax(=always| |$)"
+ 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 param="$*"
local param_checked=""
local opts=""
+ local attr_info=""
local testfile=$TEST_DIR/$$.xfs_io
local testio
case $command in
+ "lsattr")
+ # Test xfs_io lsattr support and filesystem FS_IOC_FSSETXATTR
+ # support.
+ testio=`$XFS_IO_PROG -F -f -c "lsattr $param" $testfile 2>&1`
+ param_checked="$param"
+ ;;
"chattr")
+ local testdir=$TEST_DIR/$$.attr_dir
+ mkdir $TEST_DIR/$$.attr_dir
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
+ # 'tPnE' flags are only valid for a directory so check them on a directory.
+ if echo "$param" | egrep -q 't|P|n|E'; then
+ testio=`$XFS_IO_PROG -F -c "chattr +$param" $testdir 2>&1`
+ attr_info=`$XFS_IO_PROG -F -r -c "lsattr" $testdir | awk '{print $1}'`
+ $XFS_IO_PROG -F -r -c "chattr -$param" $testdir 2>&1
+ else
+ testio=`$XFS_IO_PROG -F -f -c "chattr +$param" $testfile 2>&1`
+ attr_info=`$XFS_IO_PROG -F -r -c "lsattr" $testfile | awk '{print $1}'`
+ $XFS_IO_PROG -F -r -c "chattr -$param" $testfile 2>&1
+ fi
param_checked="+$param"
+ rm -rf $testdir 2>&1 > /dev/null
;;
"chproj")
testio=`$XFS_IO_PROG -F -f -c "chproj 0" $testfile 2>&1`
_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
_notrun "xfs_io $command $param_checked not supported on $FSTYP"
echo $testio | grep -q "Function not implemented" && \
_notrun "xfs_io $command $param_checked support is missing (missing syscall?)"
+ echo $testio | grep -q "unknown flag" && \
+ _notrun "xfs_io $command $param_checked support is missing (unknown flag)"
[ -n "$param" ] || return
if [ -z "$param_checked" ]; then
- $XFS_IO_PROG -c "help $command" | grep -q "^ $param --" || \
+ $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
echo $testio | grep -q "\(invalid option\|not supported\)" && \
_notrun "xfs_io $command doesn't support $param"
fi
+
+ # On XFS, ioctl(FSSETXATTR)(called by xfs_io -c "chattr") maskes off unsupported
+ # or invalid flags silently so need to check these flags by extra ioctl(FSGETXATTR)
+ # (called by xfs_io -c "lsattr").
+ # The following URL explains why we don't change the behavior of XFS.
+ # https://www.spinics.net/lists/linux-xfs/msg44725.html
+ if [ -n "$attr_info" -a "$FSTYP" = "xfs" ]; then
+ local num=${#param}
+ for i in $(seq 0 $((num-1))); do
+ echo $attr_info | grep -q "${param:$i:1}" || \
+ _notrun "xfs_io $command +${param:$i:1} support is missing (unknown flag in kernel)"
+ done
+ fi
}
# 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
_require_scratch
_require_command "$MKSWAP_PROG" "mkswap"
- _scratch_mkfs >/dev/null
+ _scratch_mkfs >/dev/null 2>&1
# With mounting SELinux context(e.g. system_u:object_r:root_t:s0),
# standard mkswap tried to reset the type of default context to
_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
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 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
# 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
# running shutdown to avoid shutting down base fs accidently.
_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
_scratch_unmount
}
-# Does dax mount option work on this dev/fs?
-_require_scratch_dax()
+_check_s_dax()
{
+ local target=$1
+ local exp_s_dax=$2
+
+ local attributes=$($XFS_IO_PROG -c 'statx -r' $target | awk '/stat.attributes / { print $3 }')
+ if [ $exp_s_dax -eq 0 ]; then
+ (( attributes & 0x2000 )) && echo "$target has unexpected S_DAX flag"
+ else
+ (( attributes & 0x2000 )) || echo "$target doesn't have expected S_DAX flag"
+ fi
+}
+
+_check_xflag()
+{
+ local target=$1
+ local exp_xflag=$2
+
+ if [ $exp_xflag -eq 0 ]; then
+ _test_inode_flag dax $target && echo "$target has unexpected FS_XFLAG_DAX flag"
+ else
+ _test_inode_flag dax $target || echo "$target doesn't have expected FS_XFLAG_DAX flag"
+ fi
+}
+
+# Check if dax mount options are supported
+#
+# $1 can be either 'dax=always' or 'dax'
+#
+# dax=always
+# Check for the new dax options (dax=inode, dax=always or dax=never)
+# by passing "dax=always".
+# dax
+# Check for the old dax or new dax=always by passing "dax".
+#
+# This only accepts 'dax=always' because dax=always, dax=inode and
+# dax=never are always supported together. So if the other options are
+# required checking for 'dax=always' indicates support for the other 2.
+#
+# Return 0 if filesystem/device supports the specified dax option.
+# Return 1 if mount fails with the specified dax option.
+# Return 2 if /proc/mounts shows wrong dax option.
+_check_scratch_dax_mountopt()
+{
+ local option=$1
+
_require_scratch
_scratch_mkfs > /dev/null 2>&1
- _try_scratch_mount -o dax || \
- _notrun "mount $SCRATCH_DEV with dax failed"
- # Check options to be sure. XFS ignores dax option
- # and goes on if dev underneath does not support dax.
- _fs_options $SCRATCH_DEV | grep -qw "dax" || \
- _notrun "$SCRATCH_DEV $FSTYP does not support -o dax"
- _scratch_unmount
+
+ _try_scratch_mount "-o $option" > /dev/null 2>&1 || return 1
+
+ if _fs_options $SCRATCH_DEV | egrep -q "dax(=always|,|$)"; then
+ _scratch_unmount
+ return 0
+ else
+ _scratch_unmount
+ return 2
+ fi
+}
+
+# Throw notrun if _check_scratch_dax_mountopt() returns a non-zero value.
+_require_scratch_dax_mountopt()
+{
+ local mountopt=$1
+
+ _check_scratch_dax_mountopt "$mountopt"
+ local res=$?
+
+ [ $res -eq 1 ] && _notrun "mount $SCRATCH_DEV with $mountopt failed"
+ [ $res -eq 2 ] && _notrun "$SCRATCH_DEV $FSTYP does not support -o $mountopt"
+}
+
+_require_dax_iflag()
+{
+ _require_xfs_io_command "chattr" "x"
}
# Does norecovery support by this fs?
# 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()
}
# skip test if MOUNT_OPTIONS contains the given strings
+# Both dax and dax=always are excluded if dax or dax=always is passed
_exclude_scratch_mount_option()
{
local mnt_opts=$(_normalize_mount_options)
while [ $# -gt 0 ]; do
- if echo $mnt_opts | grep -qw "$1"; then
+ local pattern=$1
+ echo "$pattern" | egrep -q "dax(=always|$)" && \
+ pattern="dax(=always| |$)"
+ if echo $mnt_opts | egrep -q "$pattern"; then
_notrun "mount option \"$1\" not allowed in this test"
fi
shift
_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.
_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
}
{
case "$(getconf LONG_BIT)" in
"32")
- echo $(( ($(getconf PAGE_SIZE) << ($(getconf LONG_BIT) - 1) ) - 1))
+ local ulong_max=$(getconf ULONG_MAX)
+ local page_size=$(getconf PAGE_SIZE)
+ echo $(( ulong_max * page_size ))
;;
"64")
echo 9223372036854775807
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
+}
+
+_require_sysctl_variable()
+{
+ local name=$1
+ sysctl $name &>/dev/null || _notrun "$name sysctl unavailable"
+}
+
+_require_mknod()
+{
+ mknod $TEST_DIR/$seq.null c 1 3 \
+ || _notrun "$FSTYP does not support mknod/mkfifo"
+ rm -f $TEST_DIR/$seq.null
+}
+
+_getcap()
+{
+ $GETCAP_PROG "$@" | _filter_getcap
+ return ${PIPESTATUS[0]}
+}
+
init_rc
################################################################################