##/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.
+
+. common/config
BC=$(which bc 2> /dev/null) || BC=
-# 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:]-]*"
+# Some tests are not relevant or functional when testing XFS realtime
+# subvolumes along with the rtinherit=1 mkfs option. In these cases,
+# this test will opt-out of the test.
+_require_no_rtinherit()
+{
+ [ "$FSTYP" = "xfs" ] && echo "$MKFS_OPTIONS" |
+ egrep -q "rtinherit([^=]|=1|$)" && \
+ _notrun "rtinherit mkfs option is not supported by this test."
+}
_require_math()
{
_math()
{
[ $# -le 0 ] && return
- if [ "$BC" ]; then
- result=$(LANG=C echo "scale=0; $@" | "$BC" -q 2> /dev/null)
- else
- _notrun "this test requires 'bc' tool for doing math operations"
- fi
- echo "$result"
+ LANG=C echo "scale=0; $@" | "$BC" -q 2> /dev/null
}
dd()
# Write a byte into a range of a file
_pwrite_byte() {
- pattern="$1"
- offset="$2"
- len="$3"
- file="$4"
- xfs_io_args="$5"
+ local pattern="$1"
+ local offset="$2"
+ local len="$3"
+ local file="$4"
+ local xfs_io_args="$5"
$XFS_IO_PROG $xfs_io_args -f -c "pwrite -S $pattern $offset $len" "$file"
}
# mmap-write a byte into a range of a file
_mwrite_byte() {
- pattern="$1"
- offset="$2"
- len="$3"
- mmap_len="$4"
- file="$5"
+ local pattern="$1"
+ local offset="$2"
+ local len="$3"
+ local mmap_len="$4"
+ local file="$5"
$XFS_IO_PROG -f -c "mmap -rw 0 $mmap_len" -c "mwrite -S $pattern $offset $len" "$file"
}
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"
+ _err_msg="$*"
+ echo "$_err_msg"
+}
+
+_dump_err_cont()
+{
+ _err_msg="$*"
+ echo -n "$_err_msg"
}
_dump_err2()
{
- err_msg="$*"
- >2& echo "$err_msg"
+ _err_msg="$*"
+ >&2 echo "$_err_msg"
}
_log_err()
{
- err_msg="$*"
- echo "$err_msg" | tee -a $seqres.full
+ _err_msg="$*"
+ echo "$_err_msg" | tee -a $seqres.full
echo "(see $seqres.full for details)"
}
[ "$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
;;
[ "$MKFS_F2FS_PROG" = "" ] && _fatal "mkfs.f2fs not found"
;;
nfs)
+ . ./common/nfs
;;
cifs)
;;
+ 9p)
+ ;;
ceph)
;;
glusterfs)
;;
overlay)
+ . ./common/overlay
;;
reiser4)
[ "$MKFS_REISER4_PROG" = "" ] && _fatal "mkfs.reiser4 not found"
;;
pvfs2)
;;
+ ubifs)
+ [ "$UBIUPDATEVOL_PROG" = "" ] && _fatal "ubiupdatevol not found"
+ ;;
esac
if [ ! -z "$REPORT_LIST" ]; then
_get_mount()
{
local mnt_point=${!#}
+ local mnt_dev=${@:(-2):1}
+ local scratch_opts=""
+ if [ "$mnt_dev" = "$SCRATCH_DEV" ]; then
+ _scratch_options mount
+ scratch_opts="$SCRATCH_OPTIONS"
+ fi
- _mount $*
+ _mount $scratch_opts $*
if [ $? -eq 0 ]; then
MOUNTED_POINT_STACK="$mnt_point $MOUNTED_POINT_STACK"
else
_scratch_options()
{
- type=$1
+ local type=$1
+ local rt_opt=""
+ local log_opt=""
SCRATCH_OPTIONS=""
if [ "$FSTYP" != "xfs" ]; then
case $type in
mkfs)
- [ "$HOSTOS" != "IRIX" ] && SCRATCH_OPTIONS="$SCRATCH_OPTIONS -f"
+ SCRATCH_OPTIONS="$SCRATCH_OPTIONS -f"
rt_opt="-r"
log_opt="-l"
;;
_test_options()
{
- type=$1
+ local type=$1
+ local rt_opt=""
+ local log_opt=""
TEST_OPTIONS=""
if [ "$FSTYP" != "xfs" ]; then
_mount_ops_filter()
{
- params="$*"
-
+ local params="$*"
+ local last_index=$(( $# - 1 ))
+
#get mount point to handle dmapi mtpt option correctly
- let last_index=$#-1
[ $last_index -gt 0 ] && shift $last_index
- FS_ESCAPED=$1
-
- # irix is fussy about how it is fed its mount options
- # - multiple -o's are not allowed
- # - no spaces between comma delimitered options
- # the sed script replaces all -o's (except the first) with a comma
- # not required for linux, but won't hurt
-
- echo $params | sed -e 's/[[:space:]]\+-o[[:space:]]*/UnIqUe/1; s/[[:space:]]\+-o[[:space:]]*/,/g; s/UnIqUe/ -o /1' \
- | sed -e 's/dmapi/dmi/' \
- | $PERL_PROG -ne "s#mtpt=[^,|^\n|^\s]*#mtpt=$FS_ESCAPED\1\2#; print;"
+ local fs_escaped=$1
+
+ echo $params | sed -e 's/dmapi/dmi/' \
+ | $PERL_PROG -ne "s#mtpt=[^,|^\n|^\s]*#mtpt=$fs_escaped\1\2#; print;"
}
echo $MOUNT_OPTIONS $SELINUX_MOUNT_OPTIONS $*
}
-_overlay_basic_mount_options()
-{
- echo "-o lowerdir=$1/$OVL_LOWER,upperdir=$1/$OVL_UPPER,workdir=$1/$OVL_WORK"
-}
-
-_overlay_mount_options()
-{
- echo `_common_dev_mount_options` \
- `_overlay_basic_mount_options $1` \
- $OVERLAY_MOUNT_OPTIONS
-}
-
_scratch_mount_options()
{
_scratch_options mount
- if [ "$FSTYP" == "overlay" ]; then
- echo `_overlay_mount_options $OVL_BASE_SCRATCH_MNT`
- return 0
- fi
echo `_common_dev_mount_options $*` $SCRATCH_OPTIONS \
$SCRATCH_DEV $SCRATCH_MNT
}
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}'`
esac
}
-# helper function to do the actual overlayfs mount operation
-_overlay_mount_dirs()
-{
- local lowerdir=$1
- local upperdir=$2
- local workdir=$3
- shift 3
-
- $MOUNT_PROG -t overlay -o lowerdir=$lowerdir -o upperdir=$upperdir \
- -o workdir=$workdir $*
-}
-
-_overlay_mkdirs()
-{
- local dir=$1
-
- mkdir -p $dir/$OVL_UPPER
- mkdir -p $dir/$OVL_LOWER
- mkdir -p $dir/$OVL_WORK
- mkdir -p $dir/$OVL_MNT
-}
-
-# Given a base fs dir, set up overlay directories and mount on the given mnt.
-# The dir is used as the mount device so it can be seen from df or mount
-_overlay_mount()
-{
- local dir=$1
- local mnt=$2
- shift 2
-
- _supports_filetype $dir || _notrun "upper fs needs to support d_type"
-
- _overlay_mkdirs $dir
-
- _overlay_mount_dirs $dir/$OVL_LOWER $dir/$OVL_UPPER \
- $dir/$OVL_WORK $OVERLAY_MOUNT_OPTIONS \
- $SELINUX_MOUNT_OPTIONS $* $dir $mnt
-}
-
-_overlay_base_test_mount()
-{
- if [ -z "$OVL_BASE_TEST_DEV" -o -z "$OVL_BASE_TEST_DIR" ] || \
- _check_mounted_on OVL_BASE_TEST_DEV $OVL_BASE_TEST_DEV \
- OVL_BASE_TEST_DIR $OVL_BASE_TEST_DIR
- then
- # no base fs or already mounted
- return 0
- elif [ $? -ne 1 ]
- then
- # base fs mounted but not on mount point
- return 1
- fi
-
- _mount $TEST_FS_MOUNT_OPTS \
- $SELINUX_MOUNT_OPTIONS \
- $OVL_BASE_TEST_DEV $OVL_BASE_TEST_DIR
-}
-
-_overlay_test_mount()
-{
- _overlay_base_test_mount && \
- _overlay_mount $OVL_BASE_TEST_DIR $TEST_DIR $*
-}
-
-_overlay_base_scratch_mount()
+# mount scratch device with given options but don't check mount status
+_try_scratch_mount()
{
- if [ -z "$OVL_BASE_SCRATCH_DEV" -o -z "$OVL_BASE_SCRATCH_MNT" ] || \
- _check_mounted_on OVL_BASE_SCRATCH_DEV $OVL_BASE_SCRATCH_DEV \
- OVL_BASE_SCRATCH_MNT $OVL_BASE_SCRATCH_MNT
- then
- # no base fs or already mounted
- return 0
- elif [ $? -ne 1 ]
- then
- # base fs mounted but not on mount point
- return 1
+ if [ "$FSTYP" == "overlay" ]; then
+ _overlay_scratch_mount $*
+ return $?
fi
-
- _mount $OVL_BASE_MOUNT_OPTIONS \
- $SELINUX_MOUNT_OPTIONS \
- $OVL_BASE_SCRATCH_DEV $OVL_BASE_SCRATCH_MNT
-}
-
-_overlay_base_scratch_unmount()
-{
- [ -n "$OVL_BASE_SCRATCH_DEV" -a -n "$OVL_BASE_SCRATCH_MNT" ] || return 0
-
- $UMOUNT_PROG $OVL_BASE_SCRATCH_MNT
-}
-
-_overlay_scratch_mount()
-{
- _overlay_base_scratch_mount && \
- _overlay_mount $OVL_BASE_SCRATCH_MNT $SCRATCH_MNT $*
-}
-
-_overlay_base_test_unmount()
-{
- [ -n "$OVL_BASE_TEST_DEV" -a -n "$OVL_BASE_TEST_DIR" ] || return 0
-
- $UMOUNT_PROG $OVL_BASE_TEST_DIR
-}
-
-_overlay_test_unmount()
-{
- $UMOUNT_PROG $TEST_DIR
- _overlay_base_test_unmount
-}
-
-_overlay_scratch_unmount()
-{
- $UMOUNT_PROG $SCRATCH_MNT
- _overlay_base_scratch_unmount
+ _mount -t $FSTYP `_scratch_mount_options $*`
}
+# mount scratch device with given options and _fail if mount fails
_scratch_mount()
{
- if [ "$FSTYP" == "overlay" ]; then
- _overlay_scratch_mount $*
- return $?
- fi
- _mount -t $FSTYP `_scratch_mount_options $*`
+ _try_scratch_mount $* || _fail "mount failed"
}
_scratch_unmount()
local opts="$1"
if test -n "$opts"; then
- mount -o "remount,$opts" $SCRATCH_MNT
+ _try_scratch_mount "-o remount,$opts"
fi
}
opts="-o $opts"
fi
_scratch_unmount
- _scratch_mount "$opts"
+ _try_scratch_mount "$opts" || _fail "cycle mount failed"
+}
+
+_scratch_shutdown()
+{
+ if [ $FSTYP = "overlay" ]; then
+ # In lagacy overlay usage, it may specify directory as
+ # 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.
+ if [ -z $OVL_BASE_SCRATCH_DEV ]; then
+ _fail "_scratch_shutdown: call _require_scratch_shutdown first in test"
+ else
+ src/godown $* $OVL_BASE_SCRATCH_MNT
+ fi
+ else
+ 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
}
_test_mount()
shift 2
local extra_mkfs_options=$*
local mkfs_status
- local tmp=`mktemp`
+ local tmp=`mktemp -u`
# save mkfs output in case conflict means we need to run again.
# only the output for the mkfs that applies should be shown
cat $tmp.mkfsstd
eval "cat $tmp.mkfserr | $mkfs_filter" >&2
- rm -f $tmp*
+ rm -f $tmp.mkfserr $tmp.mkfsstd
return $mkfs_status
}
_scratch_metadump()
{
- dumpfile=$1
+ local dumpfile=$1
shift
- options=
+ local options=
[ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
options="-l $SCRATCH_LOGDEV"
_setup_large_ext4_fs()
{
- fs_size=$1
+ local fs_size=$1
local tmp_dir=/tmp/
[ "$LARGE_SCRATCH_DEV" != yes ] && return 0
# Default free space in the FS is 50GB, but you can specify more via
# SCRATCH_DEV_EMPTY_SPACE
- space_to_consume=$(($fs_size - 50*1024*1024*1024 - $SCRATCH_DEV_EMPTY_SPACE))
+ local space_to_consume=$(($fs_size - 50*1024*1024*1024 - $SCRATCH_DEV_EMPTY_SPACE))
# mount the filesystem and create 16TB - 4KB files until we consume
# all the necessary space.
- _scratch_mount 2>&1 >$tmp_dir/mnt.err
+ _try_scratch_mount 2>&1 >$tmp_dir/mnt.err
local status=$?
if [ $status -ne 0 ]; then
echo "mount failed"
fi
rm -f $tmp_dir/mnt.err
- file_size=$((16*1024*1024*1024*1024 - 4096))
- nfiles=0
+ local file_size=$((16*1024*1024*1024*1024 - 4096))
+ local nfiles=0
while [ $space_to_consume -gt $file_size ]; do
xfs_io -F -f \
{
local mkfs_cmd="$MKFS_EXT4_PROG -F"
local mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
- local tmp=`mktemp`
+ local tmp=`mktemp -u`
local mkfs_status
+ [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
+ $mkfs_cmd -O journal_dev $MKFS_OPTIONS $SCRATCH_LOGDEV && \
+ mkfs_cmd="$mkfs_cmd -J device=$SCRATCH_LOGDEV"
_scratch_do_mkfs "$mkfs_cmd" "$mkfs_filter" $* 2>$tmp.mkfserr 1>$tmp.mkfsstd
mkfs_status=$?
if [ $mkfs_status -eq 0 -a "$LARGE_SCRATCH_DEV" = yes ]; then
# manually parse the mkfs output to get the fs size in bytes
- fs_size=`cat $tmp.mkfsstd | awk ' \
+ local fs_size=`cat $tmp.mkfsstd | awk ' \
/^Block size/ { split($2, a, "="); bs = a[2] ; } \
/ inodes, / { blks = $3 } \
/reserved for the super user/ { resv = $1 } \
# output mkfs stdout and stderr
cat $tmp.mkfsstd
cat $tmp.mkfserr >&2
+ rm -f $tmp.mkfserr $tmp.mkfsstd
return $mkfs_status
}
cifs)
# do nothing for cifs
;;
+ 9p)
+ # do nothing for 9p
+ ;;
ceph)
# do nothing for ceph
;;
_mkfs_dev()
{
+ local tmp=`mktemp -u`
case $FSTYP in
nfs*)
# do nothing for nfs
;;
+ 9p)
+ # do nothing for 9p
+ ;;
overlay)
# do nothing for overlay
;;
# do nothing for pvfs2
;;
udf)
- $MKFS_UDF_PROG $MKFS_OPTIONS $* 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
+ $MKFS_UDF_PROG $MKFS_OPTIONS $* 2>$tmp.mkfserr 1>$tmp.mkfsstd
;;
btrfs)
- $MKFS_BTRFS_PROG $MKFS_OPTIONS $* 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
+ $MKFS_BTRFS_PROG $MKFS_OPTIONS $* 2>$tmp.mkfserr 1>$tmp.mkfsstd
;;
ext2|ext3|ext4)
$MKFS_PROG -t $FSTYP -- -F $MKFS_OPTIONS $* \
- 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
+ 2>$tmp.mkfserr 1>$tmp.mkfsstd
+ ;;
+ xfs)
+ $MKFS_PROG -t $FSTYP -- -f $MKFS_OPTIONS $* \
+ 2>$tmp.mkfserr 1>$tmp.mkfsstd
;;
-
*)
yes | $MKFS_PROG -t $FSTYP -- $MKFS_OPTIONS $* \
- 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
+ 2>$tmp.mkfserr 1>$tmp.mkfsstd
;;
esac
if [ $? -ne 0 ]; then
# output stored mkfs output
- cat $tmp_dir.mkfserr >&2
- cat $tmp_dir.mkfsstd
+ cat $tmp.mkfserr >&2
+ cat $tmp.mkfsstd
status=1
exit 1
fi
- rm -f $tmp_dir.mkfserr $tmp_dir.mkfsstd
+ rm -f $tmp.mkfserr $tmp.mkfsstd
}
# remove all files in $SCRATCH_MNT, useful when testing on NFS/CIFS
local mkfs_status
case $FSTYP in
- nfs*|cifs|ceph|overlay|glusterfs|pvfs2)
+ nfs*|cifs|ceph|overlay|glusterfs|pvfs2|9p)
# 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
# do nothing for tmpfs
return 0
;;
+ ubifs)
+ # erase the UBI volume; reformated automatically on next mount
+ $UBIUPDATEVOL_PROG ${SCRATCH_DEV} -t
+ return 0
+ ;;
ext4)
_scratch_mkfs_ext4 $*
return $?
mkfs_cmd="$MKFS_BTRFS_PROG"
mkfs_filter="cat"
;;
- ext2|ext3)
+ ext3)
+ mkfs_cmd="$MKFS_PROG -t $FSTYP -- -F"
+ mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
+
+ # put journal on separate device?
+ [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
+ $mkfs_cmd -O journal_dev $MKFS_OPTIONS $SCRATCH_LOGDEV && \
+ mkfs_cmd="$mkfs_cmd -J device=$SCRATCH_LOGDEV"
+ ;;
+ ext2)
mkfs_cmd="$MKFS_PROG -t $FSTYP -- -F"
mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
;;
_notrun "All devs used no spare"
fi
# Get a dev that is not used
- local devs[]="( $SCRATCH_DEV_POOL_SAVED )"
+ local -a devs="( $SCRATCH_DEV_POOL_SAVED )"
SPARE_DEV=${devs[@]:$ndevs:1}
export SPARE_DEV
}
local test_ndevs=$1
local config_ndevs=`echo $SCRATCH_DEV_POOL| wc -w`
- local devs[]="( $SCRATCH_DEV_POOL )"
+ local -a devs="( $SCRATCH_DEV_POOL )"
typeset -p config_ndevs >/dev/null 2>&1
if [ $? -ne 0 ]; then
# _scratch_mkfs_sized <size in bytes> [optional blocksize]
_scratch_mkfs_sized()
{
- fssize=$1
- blocksize=$2
+ 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)
+ 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
- re='^[0-9]+$'
+ local re='^[0-9]+$'
if ! [[ $fssize =~ $re ]] ; then
_notrun "error: _scratch_mkfs_sized: fs size \"$fssize\" not an integer."
fi
_notrun "error: _scratch_mkfs_sized: block size \"$blocksize\" not an integer."
fi
- blocks=`expr $fssize / $blocksize`
+ local blocks=`expr $fssize / $blocksize`
if [ "$HOSTOS" == "Linux" -a -b "$SCRATCH_DEV" ]; then
- devsize=`blockdev --getsize64 $SCRATCH_DEV`
+ 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
;;
;;
btrfs)
local mixed_opt=
- (( fssize <= 100 * 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)
+ ${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 \
;;
f2fs)
# mkfs.f2fs requires # of sectors as an input for the size
- sector_size=`blockdev --getss $SCRATCH_DEV`
+ local sector_size=`blockdev --getss $SCRATCH_DEV`
$MKFS_F2FS_PROG $MKFS_OPTIONS $SCRATCH_DEV `expr $fssize / $sector_size`
;;
tmpfs)
- free_mem=`_free_memory_bytes`
+ local free_mem=`_free_memory_bytes`
if [ "$free_mem" -lt "$fssize" ] ; then
_notrun "Not enough memory ($free_mem) for tmpfs with $fssize bytes"
fi
# _scratch_mkfs_geom <sunit bytes> <swidth multiplier> [optional blocksize]
_scratch_mkfs_geom()
{
- sunit_bytes=$1
- swidth_mult=$2
- blocksize=$3
+ local sunit_bytes=$1
+ local swidth_mult=$2
+ local blocksize=$3
[ -z "$blocksize" ] && blocksize=4096
- let sunit_blocks=$sunit_bytes/$blocksize
- let swidth_blocks=$sunit_blocks*$swidth_mult
+ local sunit_blocks=$(( sunit_bytes / blocksize ))
+ local swidth_blocks=$(( sunit_blocks * swidth_mult ))
case $FSTYP in
xfs)
# _scratch_mkfs_blocksized blocksize
_scratch_mkfs_blocksized()
{
- blocksize=$1
+ local blocksize=$1
- re='^[0-9]+$'
+ local re='^[0-9]+$'
if ! [[ $blocksize =~ $re ]] ; then
_notrun "error: _scratch_mkfs_sized: block size \"$blocksize\" not an integer."
fi
ext2|ext3|ext4)
${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV
;;
+ gfs2)
+ ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -O -b $blocksize $SCRATCH_DEV
+ ;;
ocfs2)
yes | ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize -C $blocksize $SCRATCH_DEV
;;
case $FSTYP in
xfs)
_scratch_xfs_repair "$@" 2>&1
- res=$?
+ local res=$?
if [ "$res" -ne 0 ]; then
echo "xfs_repair returns $res; replay log?"
- _scratch_mount
+ _try_scratch_mount
res=$?
if [ "$res" -gt 0 ]; then
echo "mount returns $res; zap log?"
return $res
;;
*)
- # Let's hope fsck -y suffices...
- fsck -t $FSTYP -y $SCRATCH_DEV 2>&1
- res=$?
+ 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
#
exit 1
fi
- _dev=$1
- if [ -L "${_dev}" ]; then
- _dev=`readlink -f "${_dev}"`
+ local dev=$1
+ if [ -L "$dev" ]; then
+ dev=`readlink -f "$dev"`
fi
- if [ -b "${_dev}" ]; then
- src/lstat64 "${_dev}" | $AWK_PROG '/Device type:/ { print $9 }'
+ if [ -b "$dev" ]; then
+ src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
fi
}
+# returns device number if a file is a character device
+#
+_is_char_dev()
+{
+ if [ $# -ne 1 ]; then
+ echo "Usage: _is_char_dev dev" 1>&2
+ exit 1
+ fi
+
+ local dev=$1
+ if [ -L "$dev" ]; then
+ dev=`readlink -f "$dev"`
+ fi
+
+ if [ -c "$dev" ]; then
+ src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
+ fi
+}
+
# Do a command, log it to $seqres.full, optionally test return status
# and die if command fails. If called with one argument _do executes the
# command, logs it, and returns its exit status. With two arguments _do
_do()
{
if [ $# -eq 1 ]; then
- _cmd=$1
+ local cmd=$1
elif [ $# -eq 2 ]; then
- _note=$1
- _cmd=$2
- echo -n "$_note... "
+ local note=$1
+ local cmd=$2
+ echo -n "$note... "
else
echo "Usage: _do [note] cmd" 1>&2
status=1; exit
fi
- (eval "echo '---' \"$_cmd\"") >>$seqres.full
- (eval "$_cmd") >$tmp._out 2>&1; ret=$?
- cat $tmp._out | _fix_malloc >>$seqres.full
+ (eval "echo '---' \"$cmd\"") >>$seqres.full
+ (eval "$cmd") >$tmp._out 2>&1
+ local ret=$?
+ cat $tmp._out >>$seqres.full
+ rm -f $tmp._out
if [ $# -eq 2 ]; then
if [ $ret -eq 0 ]; then
echo "done"
-o \( $# -eq 2 -a "$_do_die_on_error" = "message_only" \) ]
then
[ $# -ne 2 ] && echo
- eval "echo \"$_cmd\" failed \(returned $ret\): see $seqres.full"
+ eval "echo \"$cmd\" failed \(returned $ret\): see $seqres.full"
status=1; exit
fi
#
_supported_fs()
{
+ local f
+
for f
do
if [ "$f" = "$FSTYP" -o "$f" = "generic" ]
#
_supported_os()
{
+ local h
+
for h
do
if [ "$h" = "$HOSTOS" ]
_notrun "this test requires a valid \$SCRATCH_MNT"
fi
;;
+ 9p)
+ if [ -z "$SCRATCH_DEV" ]; then
+ _notrun "this test requires a valid \$SCRATCH_DEV"
+ fi
+ if [ ! -d "$SCRATCH_MNT" ]; then
+ _notrun "this test requires a valid \$SCRATCH_MNT"
+ fi
+ ;;
nfs*|ceph)
echo $SCRATCH_DEV | grep -q ":/" > /dev/null 2>&1
if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; then
_notrun "this test requires a valid \$SCRATCH_MNT and unique $SCRATCH_DEV"
fi
;;
+ ubifs)
+ # ubifs needs an UBI volume. This will be a char device, not a block device.
+ if [ ! -c "$SCRATCH_DEV" ]; then
+ _notrun "this test requires a valid UBI volume for \$SCRATCH_DEV"
+ fi
+ if [ ! -d "$SCRATCH_MNT" ]; then
+ _notrun "this test requires a valid \$SCRATCH_MNT"
+ fi
+ ;;
*)
if [ -z "$SCRATCH_DEV" -o "`_is_block_dev "$SCRATCH_DEV"`" = "" ]
then
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)
+ if [ -z "$TEST_DEV" ]; then
+ _notrun "this test requires a valid \$TEST_DEV"
+ fi
+ if [ ! -d "$TEST_DIR" ]; then
+ _notrun "this test requires a valid \$TEST_DIR"
+ fi
+ ;;
nfs*|ceph)
echo $TEST_DEV | grep -q ":/" > /dev/null 2>&1
if [ -z "$TEST_DEV" -o "$?" != "0" ]; then
_notrun "this test requires a valid \$TEST_DIR and unique $TEST_DEV"
fi
;;
+ ubifs)
+ # ubifs needs an UBI volume. This will be a char device, not a block device.
+ if [ ! -c "$TEST_DEV" ]; then
+ _notrun "this test requires a valid UBI volume for \$TEST_DEV"
+ fi
+ if [ ! -d "$TEST_DIR" ]; then
+ _notrun "this test requires a valid \$TEST_DIR"
+ fi
+ ;;
*)
if [ -z "$TEST_DEV" ] || [ "`_is_block_dev "$TEST_DEV"`" = "" ]
then
touch ${RESULT_DIR}/require_test
}
+_has_logdev()
+{
+ local ret=0
+ [ -z "$SCRATCH_LOGDEV" -o ! -b "$SCRATCH_LOGDEV" ] && ret=1
+ [ "$USE_EXTERNAL" != yes ] && ret=1
+
+ return $ret
+}
+
# this test needs a logdev
#
_require_logdev()
_notrun "Realtime device required, skipped this test"
}
+# This test requires that a realtime subvolume is not in use
+#
+_require_no_realtime()
+{
+ [ "$USE_EXTERNAL" = "yes" ] && [ -n "$SCRATCH_RTDEV" ] && \
+ _notrun "Test not compatible with realtime subvolumes, skipped this test"
+}
+
# this test requires that a specified command (executable) exists
# $1 - command, $2 - name for error message
#
_require_command()
{
if [ $# -eq 2 ]; then
- _name="$2"
+ local name="$2"
elif [ $# -eq 1 ]; then
- _name="$1"
+ local name="$1"
else
_fail "usage: _require_command <command> [<name>]"
fi
- _command=`echo "$1" | awk '{ print $1 }'`
- if [ ! -x "$_command" ]; then
- _notrun "$_name utility required, skipped this test"
+ local command=`echo "$1" | awk '{ print $1 }'`
+ if [ ! -x "$command" ]; then
+ _notrun "$name utility required, skipped this test"
fi
}
fi
}
+# this test requires a path to refere to a local block or character device
+# $1 - device
+_require_local_device()
+{
+ if [ -z "$1" ]; then
+ echo "Usage: _require_local_device <dev>" 1>&2
+ exit 1
+ fi
+ if [ "`_is_block_dev "$1"`" != "" ]; then
+ return 0
+ fi
+ if [ "`_is_char_dev "$1"`" != "" ]; then
+ return 0
+ fi
+ _notrun "require $1 to be local device"
+}
+
# brd based ram disks erase the device when they receive a flush command when no
# active references are present. This causes problems for DM devices sitting on
# top of brd devices as DM doesn't hold active references to the brd device.
# this test requires a specific device mapper target
_require_dm_target()
{
- _target=$1
+ local target=$1
# require SCRATCH_DEV to be a valid block device with sane BLKFLSBUF
# behaviour
_require_sane_bdev_flush $SCRATCH_DEV
_require_command "$DMSETUP_PROG" dmsetup
- modprobe dm-$_target >/dev/null 2>&1
+ modprobe dm-$target >/dev/null 2>&1
- $DMSETUP_PROG targets 2>&1 | grep -q ^$_target
+ $DMSETUP_PROG targets 2>&1 | grep -q ^$target
if [ $? -ne 0 ]; then
- _notrun "This test requires dm $_target support"
+ _notrun "This test requires dm $target support"
fi
}
{
_scratch_mkfs_ext4 >/dev/null 2>&1
dumpe2fs -h $SCRATCH_DEV 2> /dev/null | grep -q metadata_csum || _notrun "metadata_csum not supported by this filesystem"
- _scratch_mount >/dev/null 2>&1 \
+ _try_scratch_mount >/dev/null 2>&1 \
|| _notrun "Kernel doesn't support metadata_csum feature"
_scratch_unmount
}
-# Check the specified feature whether it is available in mkfs.ext4 or not.
-_require_ext4_mkfs_feature()
+# Check whether the specified feature whether it is supported by
+# mkfs.ext4 and the kernel.
+_require_scratch_ext4_feature()
{
- local feature=$1
- local testfile=/tmp/$$.ext4_mkfs
-
- if [ -z "$feature" ]; then
- echo "Usage: _require_ext4_mkfs_feature feature"
- exit 1
- fi
-
- touch $testfile
- local result=$($MKFS_EXT4_PROG -F -O $feature -n $testfile 512m 2>&1)
- rm -f $testfile
- echo $result | grep -q "Invalid filesystem option" && \
- _notrun "mkfs.ext4 doesn't support $feature feature"
-}
-
-# this test requires the ext4 kernel support bigalloc feature
-#
-_require_ext4_bigalloc()
-{
- $MKFS_EXT4_PROG -F -O bigalloc $SCRATCH_DEV 512m >/dev/null 2>&1
- _scratch_mount >/dev/null 2>&1 \
- || _notrun "Ext4 kernel doesn't support bigalloc feature"
- _scratch_unmount
+ if [ -z "$1" ]; then
+ echo "Usage: _require_scratch_ext4_feature feature"
+ exit 1
+ fi
+ $MKFS_EXT4_PROG -F $MKFS_OPTIONS -O "$1" \
+ $SCRATCH_DEV 512m >/dev/null 2>&1 \
+ || _notrun "mkfs.ext4 doesn't support $1 feature"
+ _try_scratch_mount >/dev/null 2>&1 \
+ || _notrun "Kernel doesn't support the ext4 feature(s): $1"
+ _scratch_unmount
}
# this test requires that external log/realtime devices are not in use
_notrun "External device testing in progress, skipped this test"
}
+# this test requires that the kernel supports asynchronous I/O
+_require_aio()
+{
+ $here/src/feature -A
+ case $? in
+ 0)
+ ;;
+ 1)
+ _notrun "kernel does not support asynchronous I/O"
+ ;;
+ *)
+ _fail "unexpected error testing for asynchronous I/O support"
+ ;;
+ esac
+}
+
# this test requires that a (specified) aio-dio executable exists
+# and that the kernel supports asynchronous I/O.
# $1 - command (optional)
#
_require_aiodio()
AIO_TEST=src/aio-dio-regress/$1
[ -x $AIO_TEST ] || _notrun "$AIO_TEST not built"
fi
+ _require_aio
_require_odirect
}
#
_require_test_program()
{
- SRC_TEST=src/$1
- [ -x $SRC_TEST ] || _notrun "$SRC_TEST not built"
+ local prog=src/$1
+ [ -x $prog ] || _notrun "$prog not built"
}
# run an aio-dio program
_filesystem_timestamp_range()
{
- device=${1:-$TEST_DEV}
+ local device=${1:-$TEST_DEV}
case $FSTYP in
ext4)
if [ $(dumpe2fs -h $device 2>/dev/null | grep "Inode size:" | cut -d: -f2) -gt 128 ]; then
{
local dn
dn=$(domainname 2>/dev/null)
- test -n "${dn}" -a "${dn}" != "(none)" -a "${dn}" != "localdomain"
+ local ypcat=$(type -P 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 $?
}
qa_group=$1
fi
_cat_group | grep -q $qa_group
- [ "$?" == "0" ] || _notrun "$qa_group user not defined."
+ [ "$?" == "0" ] || _notrun "$qa_group group not defined."
}
_filter_user_do()
_user_do()
{
- if [ "$HOSTOS" == "IRIX" ]
- then
- echo $1 | /bin/bash "su $qa_user 2>&1" | _filter_user_do
- else
echo $1 | su -s /bin/bash $qa_user 2>&1 | _filter_user_do
- fi
}
_require_xfs_io_command()
echo "Usage: _require_xfs_io_command command [switch]" 1>&2
exit 1
fi
- command=$1
+ local command=$1
shift
- param="$*"
+ local param="$*"
+ local param_checked=0
+ local opts=""
- testfile=$TEST_DIR/$$.xfs_io
+ local testfile=$TEST_DIR/$$.xfs_io
+ local testio
case $command in
"chproj")
testio=`$XFS_IO_PROG -F -f -c "chproj 0" $testfile 2>&1`
;;
+ "copy_range")
+ local testcopy=$TEST_DIR/$$.copy.xfs_io
+ $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`
+ rm -f $testcopy > /dev/null 2>&1
+ ;;
"falloc" )
testio=`$XFS_IO_PROG -F -f -c "falloc $param 0 1m" $testfile 2>&1`
+ param_checked=1
;;
"fpunch" | "fcollapse" | "zero" | "fzero" | "finsert" | "funshare")
- testio=`$XFS_IO_PROG -F -f -c "pwrite 0 20k" -c "fsync" \
- -c "$command 4k 8k" $testfile 2>&1`
+ local blocksize=$(_get_block_size $TEST_DIR)
+ testio=`$XFS_IO_PROG -F -f -c "pwrite 0 $((5 * $blocksize))" \
+ -c "fsync" -c "$command $blocksize $((2 * $blocksize))" \
+ $testfile 2>&1`
;;
"fiemap")
+ # If 'ranged' is passed as argument then we check to see if fiemap supports
+ # ranged query params
+ if echo "$param" | grep -q "ranged"; then
+ param=$(echo "$param" | sed "s/ranged//")
+ $XFS_IO_PROG -c "help fiemap" | grep -q "\[offset \[len\]\]"
+ [ $? -eq 0 ] || _notrun "xfs_io $command ranged support is missing"
+ fi
testio=`$XFS_IO_PROG -F -f -c "pwrite 0 20k" -c "fsync" \
- -c "fiemap -v" $testfile 2>&1`
+ -c "fiemap -v $param" $testfile 2>&1`
+ param_checked=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
;;
- "flink" )
- testio=`$XFS_IO_PROG -T -F -c "flink $testfile" \
- $TEST_DIR 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 | egrep -q "Inappropriate ioctl" && \
+ 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.
# Check for -C flag support as an indication for the bug fix.
testio=`$XFS_IO_PROG -F -f -C "open $testfile" $testfile 2>&1`
- echo $testio | egrep -q "invalid option" && \
+ echo $testio | grep -q "invalid option" && \
+ _notrun "xfs_io $command support is missing"
+ ;;
+ "pwrite")
+ # -N (RWF_NOWAIT) only works with direct vectored I/O writes
+ local pwrite_opts=" "
+ if [ "$param" == "-N" ]; then
+ opts+=" -d"
+ pwrite_opts+="-V 1 -b 4k"
+ fi
+ testio=`$XFS_IO_PROG -f $opts -c \
+ "pwrite $pwrite_opts $param 0 4k" $testfile 2>&1`
+ param_checked=1
+ ;;
+ "scrub"|"repair")
+ 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`
;;
+ "syncfs")
+ touch $testfile
+ testio=`$XFS_IO_PROG -c "syncfs" $testfile 2>&1`
+ ;;
*)
- testio=`$XFS_IO_PROG -c "$command help" 2>&1`
+ testio=`$XFS_IO_PROG -c "help $command" 2>&1`
esac
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" && \
+ echo $testio | grep -q "Operation not supported\|Inappropriate ioctl" && \
_notrun "xfs_io $command failed (old kernel/wrong fs?)"
+ echo $testio | grep -q "Invalid" && \
+ _notrun "xfs_io $command failed (old kernel/wrong fs/bad args?)"
echo $testio | grep -q "foreign file active" && \
_notrun "xfs_io $command not supported on $FSTYP"
+ echo $testio | grep -q "Function not implemented" && \
+ _notrun "xfs_io $command support is missing (missing syscall?)"
- test -z "$param" && return
- $XFS_IO_PROG -c "help $command" | grep -q "^ $param --" || \
- _notrun "xfs_io $command doesn't support $param"
+ [ -n "$param" ] || return
+
+ if [ $param_checked -eq 0 ]; then
+ $XFS_IO_PROG -c "help $command" | grep -q "^ $param --" || \
+ _notrun "xfs_io $command doesn't support $param"
+ else
+ # xfs_io could result in "command %c not supported" if it was
+ # built on kernels not supporting pwritev2() calls
+ echo $testio | grep -q "\(invalid option\|not supported\)" && \
+ _notrun "xfs_io $command doesn't support $param"
+ fi
}
# check that kernel and filesystem support direct I/O
if [ $FSTYP = "ext4" ] ; 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 "ext4 data journaling doesn't support O_DIRECT"
fi
fi
- testfile=$TEST_DIR/$$.direct
+ local testfile=$TEST_DIR/$$.direct
$XFS_IO_PROG -F -f -d -c "pwrite 0 20k" $testfile > /dev/null 2>&1
if [ $? -ne 0 ]; then
_notrun "O_DIRECT is not supported"
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_fs_space()
{
- MNT=$1
- BLOCKS=$2 # in units of 1024
- let GB=$BLOCKS/1024/1024
+ local mnt=$1
+ local blocks=$2 # in units of 1024
+ local gb=$(( blocks / 1024 / 1024 ))
- FREE_BLOCKS=`df -kP $MNT | grep -v Filesystem | awk '{print $4}'`
- [ $FREE_BLOCKS -lt $BLOCKS ] && \
- _notrun "This test requires at least ${GB}GB free on $MNT to run"
+ local free_blocks=`df -kP $mnt | grep -v Filesystem | awk '{print $4}'`
+ [ $free_blocks -lt $blocks ] && \
+ _notrun "This test requires at least ${gb}GB free on $mnt to run"
}
#
not found. Seems that CONFIG_FAIL_MAKE_REQUEST kernel config option not enabled"
}
+# Disable extent zeroing for ext4 on the given device
+_ext4_disable_extent_zeroout()
+{
+ local dev=${1:-$TEST_DEV}
+ local sdev=`_short_dev $dev`
+
+ [ -f /sys/fs/ext4/$sdev/extent_max_zeroout_kb ] && \
+ 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|ceph|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()
{
- testfile=$TEST_DIR/$$.seek
- testseek=`$here/src/seek_sanity_test -t $testfile 2>&1`
- rm -f $testfile &>/dev/null
- echo $testseek | grep -q "Kernel does not support" && \
- _notrun "File system does not support llseek(2) SEEK_DATA/HOLE"
+ local dev=${1:-$TEST_DEV}
+ local testfile=$TEST_DIR/$$.seek
+ local testseek=`$here/src/seek_sanity_test -t $testfile 2>&1`
+
+ rm -f $testfile &>/dev/null
+ echo $testseek | grep -q "Kernel does not support" && \
+ _notrun "File system does not support llseek(2) SEEK_DATA/HOLE"
+ # Disable extent zeroing for ext4 as that change where holes are
+ # created
+ if [ "$FSTYP" = "ext4" ]; then
+ _ext4_disable_extent_zeroout $dev
+ fi
}
_require_runas()
_scratch_mkfs_xfs_supported -m richacl=1 >/dev/null 2>&1 \
|| _notrun "mkfs.xfs doesn't have richacl feature"
_scratch_mkfs_xfs -m richacl=1 >/dev/null 2>&1
- _scratch_mount >/dev/null 2>&1 \
+ _try_scratch_mount >/dev/null 2>&1 \
|| _notrun "kernel doesn't support richacl feature on $FSTYP"
_scratch_unmount
}
{
_scratch_mkfs -O richacl >/dev/null 2>&1 \
|| _notrun "can't mkfs $FSTYP with option -O richacl"
- _scratch_mount >/dev/null 2>&1 \
+ _try_scratch_mount >/dev/null 2>&1 \
|| _notrun "kernel doesn't support richacl feature on $FSTYP"
_scratch_unmount
}
esac
}
-# check that a FS on a device is mounted
-# if so, return mount point
-#
-_is_mounted()
+# check if the given device is mounted, if so, return mount point
+_is_dev_mounted()
{
- if [ $# -ne 1 ]
- then
- echo "Usage: _is_mounted device" 1>&2
- exit 1
- fi
+ local dev=$1
+ local fstype=${2:-$FSTYP}
- device=$1
+ if [ $# -lt 1 ]; then
+ echo "Usage: _is_dev_mounted <device> [fstype]" 1>&2
+ exit 1
+ fi
- if _mount | grep "$device " | $AWK_PROG -v pattern="type $FSTYP" '
- pattern { print $3 ; exit 0 }
- END { exit 1 }
- '
- then
- echo "_is_mounted: $device is not a mounted $FSTYP FS"
- exit 1
- fi
+ findmnt -rncv -S $dev -t $fstype -o TARGET | head -1
+}
+
+# check if the given dir is a mount point, if so, return mount point
+_is_dir_mountpoint()
+{
+ local dir=$1
+ local fstype=${2:-$FSTYP}
+
+ if [ $# -lt 1 ]; then
+ echo "Uasge: _is_dir_mountpoint <dir> [fstype]" 1>&2
+ exit 1
+ fi
+
+ findmnt -rncv -t $fstype -o TARGET $dir | head -1
}
# remount a FS to a new mode (ro or rw)
echo "Usage: _remount device ro/rw" 1>&2
exit 1
fi
- device=$1
- mode=$2
+ local device=$1
+ local mode=$2
if ! mount -o remount,$mode $device
then
exit 1
fi
- device=$1
- mountpoint=`_is_mounted $device`
+ local device=$1
+ local mountpoint=`_is_dev_mounted $device`
if [ $USE_REMOUNT -eq 0 ]; then
$UMOUNT_PROG $device
echo "Usage: _mount_or_remount_rw <opts> <dev> <mnt>" 1>&2
exit 1
fi
- mount_opts=$1
- device=$2
- mountpoint=$3
+ local mount_opts=$1
+ local device=$2
+ local mountpoint=$3
if [ $USE_REMOUNT -eq 0 ]; then
if [ "$FSTYP" != "overlay" ]; then
#
_check_generic_filesystem()
{
- device=$1
+ local device=$1
# If type is set, we're mounted
- type=`_fs_type $device`
- ok=1
+ local type=`_fs_type $device`
+ local ok=1
if [ "$type" = "$FSTYP" ]
then
# mounted ...
- mountpoint=`_umount_or_remount_ro $device`
+ local mountpoint=`_umount_or_remount_ro $device`
fi
fsck -t $FSTYP $FSCK_OPTIONS $device >$tmp.fsck 2>&1
return
fi
- device=$1
- if [ $# -eq 2 ];
- then
- LAST_BLOCK=`expr \( $2 - 1 \)`
- OPT_ARG="-lastvalidblock $LAST_BLOCK"
+ local device=$1
+ local opt_arg=""
+ if [ $# -eq 2 ]; then
+ opt_arg="-lastvalidblock $(( $2 - 1 ))"
fi
rm -f $seqres.checkfs
sleep 1 # Due to a problem with time stamps in udf_test
- $here/src/udf_test $OPT_ARG $device | tee $seqres.checkfs | egrep "Error|Warning" | \
+ $here/src/udf_test $opt_arg $device | tee $seqres.checkfs | egrep "Error|Warning" | \
_udf_test_known_error_filter | \
egrep -iv "Error count:.*[0-9]+.*total occurrences:.*[0-9]+|Warning count:.*[0-9]+.*total occurrences:.*[0-9]+" && \
echo "Warning UDF Verifier reported errors see $seqres.checkfs." && return 1
cifs)
# no way to check consistency for cifs
;;
+ 9p)
+ # no way to check consistency for 9p
+ ;;
ceph)
# no way to check consistency for CephFS
;;
# no way to check consistency for GlusterFS
;;
overlay)
- # no way to check consistency for overlay
+ _check_overlay_test_fs
;;
pvfs2)
;;
tmpfs)
# no way to check consistency for tmpfs
;;
+ ubifs)
+ # there is no fsck program for ubifs yet
+ ;;
*)
_check_generic_filesystem $TEST_DEV
;;
_check_scratch_fs()
{
- device=$SCRATCH_DEV
+ local device=$SCRATCH_DEV
[ $# -eq 1 ] && device=$1
case $FSTYP in
xfs)
- SCRATCH_LOG="none"
- SCRATCH_RT="none"
+ local scratch_log="none"
+ local scratch_rt="none"
[ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
- SCRATCH_LOG="$SCRATCH_LOGDEV"
+ scratch_log="$SCRATCH_LOGDEV"
[ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
- SCRATCH_RT="$SCRATCH_RTDEV"
+ scratch_rt="$SCRATCH_RTDEV"
- _check_xfs_filesystem $device $SCRATCH_LOG $SCRATCH_RT
+ _check_xfs_filesystem $device $scratch_log $scratch_rt
;;
udf)
_check_udf_filesystem $device $udf_fsize
cifs)
# Don't know how to check a CIFS filesystem, yet.
;;
+ 9p)
+ # no way to check consistency for 9p
+ ;;
ceph)
# no way to check consistency for CephFS
;;
# no way to check consistency for GlusterFS
;;
overlay)
- # no way to check consistency for overlay
+ _check_overlay_scratch_fs
;;
pvfs2)
;;
tmpfs)
# no way to check consistency for tmpfs
;;
+ ubifs)
+ # there is no fsck program for ubifs yet
+ ;;
*)
_check_generic_filesystem $device
;;
_full_platform_details()
{
- os=`uname -s`
- host=`hostname -s`
- kernel=`uname -r`
- platform=`uname -m`
+ local os=`uname -s`
+ local host=`hostname -s`
+ local kernel=`uname -r`
+ local platform=`uname -m`
echo "$os/$platform $host $kernel"
}
_get_os_name()
{
- if [ "`uname`" == "IRIX64" ] || [ "`uname`" == "IRIX" ]; then
- echo 'irix'
- elif [ "`uname`" == "Linux" ]; then
+ if [ "`uname`" == "Linux" ]; then
echo 'linux'
else
echo Unknown operating system: `uname`
_link_out_file_named()
{
- export FEATURES=$2
- SUFFIX=$(perl -e '
+ local features=$2
+ local suffix=$(FEATURES="$features" perl -e '
my %feathash;
my $feature, $result, $suffix, $opts;
print $result
' <$seqfull.cfg)
rm -f $1
- SRC=$(basename $1)
- ln -fs $SRC.$SUFFIX $1
+ ln -fs $(basename $1).$suffix $1
}
_link_out_file()
{
+ local features
+
if [ $# -eq 0 ]; then
- FEATURES="$(_get_os_name)"
+ features="$(_get_os_name)"
if [ -n "$MOUNT_OPTIONS" ]; then
- FEATURES=$FEATURES,${MOUNT_OPTIONS##"-o "}
+ features=$features,${MOUNT_OPTIONS##"-o "}
fi
else
- FEATURES=$1
+ features=$1
fi
- _link_out_file_named $seqfull.out "$FEATURES"
+ _link_out_file_named $seqfull.out "$features"
}
_die()
#takes files, randomdata
_nfiles()
{
- f=0
+ local f=0
while [ $f -lt $1 ]
do
- file=f$f
+ local file=f$f
echo > $file
if [ $size -gt 0 ]; then
if [ "$2" == "false" ]; then
# takes dirname, depth, randomdata
_descend()
{
- dirname=$1; depth=$2; randomdata=$3
+ local dirname=$1 depth=$2 randomdata=$3
mkdir $dirname || die "mkdir $dirname failed"
cd $dirname
_nfiles $files $randomdata # files for this dir and data type
[ $depth -eq 0 ] && return
- let deep=$depth-1 # go 1 down
+ local deep=$(( depth - 1 )) # go 1 down
[ $verbose = true ] && echo "descending, depth from leaves = $deep"
- d=0
+ local d=0
while [ $d -lt $dirs ]
do
_descend d$d $deep &
#
_populate_fs()
{
- here=`pwd`
- dirs=5 # ndirs in each subdir till leaves
- size=0 # sizeof files in K
- files=100 # num files in _each_ subdir
- depth=2 # depth of tree from root to leaves
- verbose=false
- root=root # path of initial root of directory tree
- randomdata=false # -x data type urandom, zero or compressible
+ local here=`pwd`
+ local dirs=5 # ndirs in each subdir till leaves
+ local size=0 # sizeof files in K
+ local files=100 # num files in _each_ subdir
+ local depth=2 # depth of tree from root to leaves
+ local verbose=false
+ local root=root # path of initial root of directory tree
+ local randomdata=false # -x data type urandom, zero or compressible
+ local c
OPTIND=1
while getopts "d:f:n:r:s:v:x:c" c
#
_test_inode_flag()
{
- flag=$1
- file=$2
+ local flag=$1
+ local file=$2
if $XFS_IO_PROG -r -c 'lsattr -v' "$file" | grep -q "$flag" ; then
return 0
#
_test_inode_extsz()
{
- file=$1
- blocks=""
+ local file=$1
+ local blocks=""
blocks=`$XFS_IO_PROG -r -c 'stat' "$file" | \
awk '/^xattr.extsize =/ { print $3 }'`
# must be called after _require_scratch_dev_pool
_require_scratch_dev_pool_equal_size()
{
- local _size
- local _newsize
- local _dev
+ local size
+ local newsize
+ local dev
# SCRATCH_DEV has been set to the first device in SCRATCH_DEV_POOL
- _size=`_get_device_size $SCRATCH_DEV`
- for _dev in $SCRATCH_DEV_POOL; do
- _newsize=`_get_device_size $_dev`
- if [ $_size -ne $_newsize ]; then
+ size=`_get_device_size $SCRATCH_DEV`
+ for dev in $SCRATCH_DEV_POOL; do
+ newsize=`_get_device_size $dev`
+ if [ $size -ne $newsize ]; then
_notrun "This test requires devices in SCRATCH_DEV_POOL have the same size"
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()
{
- job=$1
+ local job=$1
_require_command "$FIO_PROG" fio
if [ -z "$1" ]; then
_require_freeze()
{
xfs_freeze -f "$TEST_DIR" >/dev/null 2>&1
- result=$?
+ local result=$?
xfs_freeze -u "$TEST_DIR" >/dev/null 2>&1
[ $result -eq 0 ] || _notrun "$FSTYP does not support freezing"
}
+# Does NFS export work on this fs?
+_require_exportfs()
+{
+ _require_test_program "open_by_handle"
+ mkdir -p "$TEST_DIR"/exportfs_test
+ $here/src/open_by_handle -c "$TEST_DIR"/exportfs_test 2>&1 \
+ || _notrun "$FSTYP does not support NFS export"
+}
+
+
# Does shutdown work on this fs?
_require_scratch_shutdown()
{
[ -x src/godown ] || _notrun "src/godown executable not found"
- _scratch_mkfs > /dev/null 2>&1
+ _scratch_mkfs > /dev/null 2>&1 || _notrun "_scratch_mkfs failed on $SCRATCH_DEV"
_scratch_mount
- src/godown -f $SCRATCH_MNT 2>&1 \
- || _notrun "$FSTYP does not support shutdown"
+
+ if [ $FSTYP = "overlay" ]; then
+ if [ -z $OVL_BASE_SCRATCH_DEV ]; then
+ # In lagacy overlay usage, it may specify directory as
+ # 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"
+ else
+ 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 \
+ || _notrun "$FSTYP does not support shutdown"
+ fi
+
_scratch_unmount
}
{
_require_scratch
_scratch_mkfs > /dev/null 2>&1
- _scratch_mount -o dax
+ _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" || \
# Does norecovery support by this fs?
_require_norecovery()
{
- _scratch_mount -o ro,norecovery || \
+ _try_scratch_mount -o ro,norecovery || \
_notrun "$FSTYP does not support norecovery"
_scratch_unmount
}
_require_metadata_journaling()
{
if [ -z $1 ]; then
- DEV=$TEST_DEV
+ local dev=$TEST_DEV
else
- DEV=$1
+ local dev=$1
fi
case "$FSTYP" in
- ext2|vfat|msdos)
+ ext2|vfat|msdos|udf)
_notrun "$FSTYP does not support metadata journaling"
;;
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 || \
+ _notrun "$FSTYP on $dev not configured with metadata journaling"
# ext4 might not load a journal
_exclude_scratch_mount_option "noload"
;;
+ 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
+ _overlay_config_restore
+ _require_metadata_journaling
+ _overlay_config_override
+ else
+ _notrun "No metadata journaling support for legacy overlay setup"
+ fi
+ ;;
*)
# by default we pass; if you need to, add your fs above!
;;
esac
}
-# Does fiemap support?
-_require_fiemap()
-{
- _require_xfs_io_command "fiemap"
-}
-
_count_extents()
{
$XFS_IO_PROG -c "fiemap" $1 | tail -n +2 | grep -v hole | wc -l
$XFS_IO_PROG -c "fiemap" $1 | tail -n +2 | grep hole | wc -l
}
+_count_attr_extents()
+{
+ $XFS_IO_PROG -c "fiemap -a" $1 | tail -n +2 | grep -v hole | wc -l
+}
+
# arg 1 is dev to remove and is output of the below eg.
# ls -l /sys/class/block/sdd | rev | cut -d "/" -f 3 | rev
_devmgt_remove()
echo ${tdl} > /sys/class/scsi_host/host${h}/scan || _fail "Add disk failed"
# ensure the device comes online
- dev_back_oneline=0
+ local dev_back_oneline=0
+ local i
for i in `seq 1 10`; do
if [ -d /sys/class/scsi_device/${1}/device/block ]; then
- dev=`ls /sys/class/scsi_device/${1}/device/block`
+ local dev=`ls /sys/class/scsi_device/${1}/device/block`
+ local j
for j in `seq 1 10`;
do
stat /dev/$dev > /dev/null 2>&1
_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()
{
_scratch_mkfs > /dev/null 2>&1
- _scratch_mount -o relatime || \
+ _try_scratch_mount -o relatime || \
_notrun "relatime not supported by the current kernel"
_scratch_unmount
}
_create_loop_device()
{
- file=$1
+ local file=$1 dev
dev=`losetup -f --show $file` || _fail "Cannot assign $file to a loop device"
echo $dev
}
_destroy_loop_device()
{
- dev=$1
+ local dev=$1
losetup -d $dev || _fail "Cannot destroy loop device $dev"
}
_scale_fsstress_args()
{
- args=""
+ local args=""
while [ $# -gt 0 ]; do
case "$1" in
-n) args="$args $1 $(($2 * $TIME_FACTOR))"; shift ;;
#
_min_dio_alignment()
{
- dev=$1
+ local dev=$1
if [ -b "$dev" ]; then
blockdev --getss $dev
_require_test_symlinks()
{
- # IRIX UDF does not support symlinks
- [ "$HOSTOS" = "IRIX" -a "$FSTYP" = 'udf' ] && \
- _notrun "Require symlinks support"
- target=`mktemp -p $TEST_DIR`
- link=`mktemp -p $TEST_DIR -u`
+ local target=`mktemp -p $TEST_DIR`
+ local link=`mktemp -p $TEST_DIR -u`
ln -s `basename $target` $link
if [ "$?" -ne 0 ]; then
rm -f $target
_notrun "Require fcntl advisory locks support"
}
+_require_ofd_locks()
+{
+ # Give a test run by getlk wrlck on testfile.
+ # If the running kernel does not support OFD locks,
+ # 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
+ [ $? -eq 22 ] && _notrun "Require OFD locks support"
+}
+
_require_test_lsattr()
{
- testio=$(lsattr -d $TEST_DIR 2>&1)
+ local testio=$(lsattr -d $TEST_DIR 2>&1)
echo $testio | grep -q "Operation not supported" && \
_notrun "lsattr not supported by test filesystem type: $FSTYP"
echo $testio | grep -q "Inappropriate ioctl for device" && \
touch $TEST_DIR/syscalltest
chattr "+$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
- status=$?
+ local ret=$?
chattr "-$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
- if [ "$status" -ne 0 ]; then
+ if [ "$ret" -ne 0 ]; then
_notrun "file system doesn't support chattr +$attribute"
fi
cat $TEST_DIR/syscalltest.out >> $seqres.full
grep `_short_dev $1` /proc/partitions | awk '{print $3}'
}
+# Make sure we actually have dmesg checking set up.
+_require_check_dmesg()
+{
+ test -w /dev/kmsg || \
+ _notrun "Test requires writable /dev/kmsg."
+}
+
+# Return the dmesg log since the start of this test. Caller must ensure that
+# /dev/kmsg was writable when the test was started so that we can find the
+# beginning of this test's log messages; _require_check_dmesg does this.
+_dmesg_since_test_start()
+{
+ # search the dmesg log of last run of $seqnum for possible failures
+ # use sed \cregexpc address type, since $seqnum contains "/"
+ dmesg | tac | sed -ne "0,\#run fstests $seqnum at $date_time#p" | \
+ tac
+}
+
+# check dmesg log for a specific string, subject to the same requirements as
+# _dmesg_since_test_start.
+_check_dmesg_for()
+{
+ _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
- filter=${1:-cat}
+ local filter=${1:-_check_dmesg_filter}
- # search the dmesg log of last run of $seqnum for possible failures
- # use sed \cregexpc address type, since $seqnum contains "/"
- dmesg | tac | sed -ne "0,\#run fstests $seqnum at $date_time#p" | \
- tac | $filter >$seqres.dmesg
- grep -q -e "kernel BUG at" \
+ _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" \
- -e "INFO: suspicious RCU usage" \
+ -e "(INFO|ERR): suspicious RCU usage" \
-e "INFO: possible circular locking dependency detected" \
-e "general protection fault:" \
+ -e "BUG .* remaining" \
+ -e "UBSAN:" \
$seqres.dmesg
if [ $? -eq 0 ]; then
_dump_err "_check_dmesg: something found in dmesg (see $seqres.dmesg)"
fi
}
+# capture the kmemleak report
+_capture_kmemleak()
+{
+ local kern_knob="$DEBUGFS_MNT/kmemleak"
+ local leak_file="$1"
+
+ # Tell the kernel to scan for memory leaks. Apparently the write
+ # returns before the scan is complete, so do it twice in the hopes
+ # that twice is enough to capture all the leaks.
+ echo "scan" > "$kern_knob"
+ cat "$kern_knob" > /dev/null
+ echo "scan" > "$kern_knob"
+ cat "$kern_knob" > "$leak_file.tmp"
+ if [ -s "$leak_file.tmp" ]; then
+ cat > "$leak_file" << ENDL
+EXPERIMENTAL kmemleak reported some memory leaks! Due to the way kmemleak
+works, the leak might be from an earlier test, or something totally unrelated.
+ENDL
+ cat "$leak_file.tmp" >> "$leak_file"
+ fi
+ rm -rf "$leak_file.tmp"
+ echo "clear" > "$kern_knob"
+}
+
+# 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"
+ 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
+ fi
+
+ # Disable the automatic scan so that we can control it completely,
+ # then dump all the leaks recorded so far.
+ if echo "scan=off" > "$kern_knob" 2>/dev/null; then
+ _capture_kmemleak /dev/null
+ touch "$KMEMLEAK_CHECK_FILE"
+ fi
+}
+
+# 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"
+
+ 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
+
+ # Capture and report any leaks
+ _capture_kmemleak "$leak_file"
+ if [ -s "$leak_file" ]; then
+ _dump_err "_check_kmemleak: something found in kmemleak (see $leak_file)"
+ return 1
+ else
+ rm -f "$leak_file"
+ return 0
+ fi
+}
+
# don't check dmesg log after test
_disable_dmesg_check()
{
init_rc()
{
- if [ "$iam" == new ]
- then
- return
- fi
# make some further configuration checks here
if [ "$TEST_DEV" = "" ]
then
# get real device path name by following link
_real_dev()
{
- local _dev=$1
- if [ -b "$_dev" ] && [ -L "$_dev" ]; then
- _dev=`readlink -f "$_dev"`
+ local dev=$1
+ if [ -b "$dev" ] && [ -L "$dev" ]; then
+ dev=`readlink -f "$dev"`
fi
- echo $_dev
+ echo $dev
}
# basename of a device
_sysfs_dev()
{
- local _dev=`_real_dev $1`
- local _maj=$(stat -c%t $_dev | tr [:lower:] [:upper:])
- local _min=$(stat -c%T $_dev | tr [:lower:] [:upper:])
- _maj=$(echo "ibase=16; $_maj" | bc)
- _min=$(echo "ibase=16; $_min" | bc)
- echo /sys/dev/block/$_maj:$_min
+ local dev=`_real_dev $1`
+ local maj=$(stat -c%t $dev | tr [:lower:] [:upper:])
+ local min=$(stat -c%T $dev | tr [:lower:] [:upper:])
+ maj=$(echo "ibase=16; $maj" | bc)
+ min=$(echo "ibase=16; $min" | bc)
+ echo /sys/dev/block/$maj:$min
}
# Get the minimum block size of a file. Usually this is the
run_fsx()
{
echo fsx $@
- args=`echo $@ | sed -e "s/ BSIZE / $bsize /g" -e "s/ PSIZE / $psize /g"`
+ local args=`echo $@ | sed -e "s/ BSIZE / $bsize /g" -e "s/ PSIZE / $psize /g"`
set -- $here/ltp/fsx $args $FSX_AVOID $TEST_DIR/junk
echo "$@" >>$seqres.full
rm -f $TEST_DIR/junk
"$@" 2>&1 | tee -a $seqres.full >$tmp.fsx
if [ ${PIPESTATUS[0]} -ne 0 ]; then
cat $tmp.fsx
+ rm -f $tmp.fsx
exit 1
fi
+ rm -f $tmp.fsx
}
# Test for the existence of a sysfs entry at /sys/fs/$FSTYP/DEV/$ATTR
cat /sys/fs/${FSTYP}/${dname}/${attr}
}
+# Generic test for specific filesystem feature.
+# Currently only implemented to test overlayfs features.
+_require_scratch_feature()
+{
+ local feature=$1
+
+ case "$FSTYP" in
+ overlay)
+ _require_scratch_overlay_features ${feature}
+ ;;
+ *)
+ _fail "Test for feature '${feature}' of ${FSTYP} is not implemented"
+ ;;
+ 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")
+ echo $(( ($(getconf PAGE_SIZE) << ($(getconf LONG_BIT) - 1) ) - 1))
+ ;;
+ "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
+ ;;
+ *)
+ _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_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
+
+ 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
+}
init_rc
projects / xfstests-dev.git / blobdiff