fi
}
-_btrfs_get_subvolid()
-{
- mnt=$1
- name=$2
-
- $BTRFS_UTIL_PROG sub list $mnt | grep $name | awk '{ print $2 }'
-}
-
# Prints the md5 checksum of a given file
_md5_checksum()
{
fi
fi
-# check for correct setup
+_dump_err()
+{
+ err_msg="$*"
+ echo "$err_msg"
+}
+
+_dump_err2()
+{
+ err_msg="$*"
+ >2& echo "$err_msg"
+}
+
+_log_err()
+{
+ err_msg="$*"
+ echo "$err_msg" | tee -a $seqres.full
+ echo "(see $seqres.full for details)"
+}
+
+# make sure we have a standard umask
+umask 022
+
+# check for correct setup and source the $FSTYP specific functions now
case "$FSTYP" in
xfs)
[ "$XFS_LOGPRINT_PROG" = "" ] && _fatal "xfs_logprint not found"
[ "$XFS_REPAIR_PROG" = "" ] && _fatal "xfs_repair not found"
[ "$XFS_DB_PROG" = "" ] && _fatal "xfs_db not found"
[ "$MKFS_XFS_PROG" = "" ] && _fatal "mkfs_xfs not found"
+
+ . ./common/xfs
;;
udf)
[ "$MKFS_UDF_PROG" = "" ] && _fatal "mkfs_udf/mkudffs not found"
;;
btrfs)
[ "$MKFS_BTRFS_PROG" = "" ] && _fatal "mkfs.btrfs not found"
+
+ . ./common/btrfs
;;
ext4)
[ "$MKFS_EXT4_PROG" = "" ] && _fatal "mkfs.ext4 not found"
[ "$MKFS_F2FS_PROG" = "" ] && _fatal "mkfs.f2fs not found"
;;
nfs)
+ . ./common/nfs
;;
cifs)
;;
+ ceph)
+ ;;
+ glusterfs)
+ ;;
overlay)
+ . ./common/overlay
;;
reiser4)
[ "$MKFS_REISER4_PROG" = "" ] && _fatal "mkfs.reiser4 not found"
;;
+ pvfs2)
+ ;;
+ ubifs)
+ [ "$UBIUPDATEVOL_PROG" = "" ] && _fatal "ubiupdatevol not found"
+ ;;
esac
-# make sure we have a standard umask
-umask 022
+if [ ! -z "$REPORT_LIST" ]; then
+ . ./common/report
+ _assert_report_list
+fi
_mount()
{
$MOUNT_PROG `_mount_ops_filter $*`
}
+# Call _mount to do mount operation but also save mountpoint to
+# MOUNTED_POINT_STACK. Note that the mount point must be the last parameter
+_get_mount()
+{
+ local mnt_point=${!#}
+
+ _mount $*
+ if [ $? -eq 0 ]; then
+ MOUNTED_POINT_STACK="$mnt_point $MOUNTED_POINT_STACK"
+ else
+ return 1
+ fi
+}
+
+# Unmount the last mounted mountpoint in MOUNTED_POINT_STACK
+# and return it to caller
+_put_mount()
+{
+ local last_mnt=`echo $MOUNTED_POINT_STACK | awk '{print $1}'`
+
+ if [ -n "$last_mnt" ]; then
+ $UMOUNT_PROG $last_mnt
+ fi
+ MOUNTED_POINT_STACK=`echo $MOUNTED_POINT_STACK | cut -d\ -f2-`
+}
+
+# Unmount all mountpoints in MOUNTED_POINT_STACK and clear the stack
+_clear_mount_stack()
+{
+ if [ -n "$MOUNTED_POINT_STACK" ]; then
+ $UMOUNT_PROG $MOUNTED_POINT_STACK
+ fi
+ MOUNTED_POINT_STACK=""
+}
+
_scratch_options()
{
type=$1
case $type in
mkfs)
- [ "$HOSTOS" != "IRIX" ] && SCRATCH_OPTIONS="$SCRATCH_OPTIONS -f"
+ SCRATCH_OPTIONS="$SCRATCH_OPTIONS -f"
rt_opt="-r"
log_opt="-l"
;;
[ $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/' \
+ 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/$OVERLAY_LOWER_DIR,upperdir=$1/$OVERLAY_UPPER_DIR,workdir=$1/$OVERLAY_WORK_DIR"
-}
-
-_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 $SCRATCH_DEV`
- return 0
- fi
echo `_common_dev_mount_options $*` $SCRATCH_OPTIONS \
$SCRATCH_DEV $SCRATCH_MNT
}
-# 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 $*
-}
-
-# Given a dir, set up 3 subdirectories 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()
+_supports_filetype()
{
local dir=$1
- local mnt=$2
- shift 2
- local upper_fst=$(df --output=fstype $dir | tail -1)
- case "$upper_fst" in
+ local fstyp=`$DF_PROG $dir | tail -1 | $AWK_PROG '{print $2}'`
+ case "$fstyp" in
xfs)
- if ! xfs_info $dir | grep -q "ftype=1" ; then
- _notrun "upper fs needs to support d_type"
- fi
+ xfs_info $dir | grep -q "ftype=1"
;;
ext2|ext3|ext4)
- if ! tune2fs -l $(df --output=source $dir | tail -1) | \
- grep -q filetype ; then
- _notrun "upper fs needs to support d_type"
- fi
+ local dev=`$DF_PROG $dir | tail -1 | $AWK_PROG '{print $1}'`
+ tune2fs -l $dev | grep -q filetype
+ ;;
+ *)
+ local testfile=$dir/$$.ftype
+ touch $testfile
+ # look for DT_UNKNOWN files
+ local unknowns=$(src/t_dir_type $dir u | wc -l)
+ rm $testfile
+ # 0 unknowns is success
+ return $unknowns
;;
esac
-
- mkdir -p $dir/$OVERLAY_UPPER_DIR
- mkdir -p $dir/$OVERLAY_LOWER_DIR
- mkdir -p $dir/$OVERLAY_WORK_DIR
-
- _overlay_mount_dirs $dir/$OVERLAY_LOWER_DIR $dir/$OVERLAY_UPPER_DIR \
- $dir/$OVERLAY_WORK_DIR $OVERLAY_MOUNT_OPTIONS \
- $SELINUX_MOUNT_OPTIONS $* $dir $mnt
-}
-
-_overlay_test_mount()
-{
- _overlay_mount $TEST_DEV $TEST_DIR $*
-}
-
-_overlay_scratch_mount()
-{
- _overlay_mount $SCRATCH_DEV $SCRATCH_MNT $*
-}
-
-_overlay_test_unmount()
-{
- $UMOUNT_PROG $TEST_DIR
-}
-
-_overlay_scratch_unmount()
-{
- $UMOUNT_PROG $SCRATCH_MNT
}
_scratch_mount()
echo $SCRATCH_OPTIONS $MKFS_OPTIONS $* $SCRATCH_DEV
}
-_scratch_metadump()
-{
- dumpfile=$1
- options=
-
- [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
- options="-l $SCRATCH_LOGDEV"
-
- xfs_metadump $options $SCRATCH_DEV $dumpfile
-}
-
-_setup_large_xfs_fs()
-{
- fs_size=$1
- local tmp_dir=/tmp/
-
- [ "$LARGE_SCRATCH_DEV" != yes ] && return 0
- [ -z "$SCRATCH_DEV_EMPTY_SPACE" ] && SCRATCH_DEV_EMPTY_SPACE=0
- [ $SCRATCH_DEV_EMPTY_SPACE -ge $fs_size ] && return 0
-
- # calculate the size of the file we need to allocate.
- # Default free space in the FS is 50GB, but you can specify more via
- # SCRATCH_DEV_EMPTY_SPACE
- file_size=$(($fs_size - 50*1024*1024*1024))
- file_size=$(($file_size - $SCRATCH_DEV_EMPTY_SPACE))
-
- # mount the filesystem, create the file, unmount it
- _scratch_mount 2>&1 >$tmp_dir/mnt.err
- local status=$?
- if [ $status -ne 0 ]; then
- echo "mount failed"
- cat $tmp_dir/mnt.err >&2
- rm -f $tmp_dir/mnt.err
- return $status
- fi
- rm -f $tmp_dir/mnt.err
-
- xfs_io -F -f \
- -c "truncate $file_size" \
- -c "falloc -k 0 $file_size" \
- -c "chattr +d" \
- $SCRATCH_MNT/.use_space 2>&1 > /dev/null
- export NUM_SPACE_FILES=1
- status=$?
- _scratch_unmount
- if [ $status -ne 0 ]; then
- echo "large file prealloc failed"
- cat $tmp_dir/mnt.err >&2
- return $status
- fi
- return 0
-}
-
-_scratch_mkfs_xfs_opts()
-{
- mkfs_opts=$*
-
- # remove metadata related mkfs options if mkfs.xfs doesn't them
- if [ -n "$XFS_MKFS_HAS_NO_META_SUPPORT" ]; then
- mkfs_opts=`echo $mkfs_opts | sed "s/-m\s\+\S\+//g"`
- fi
-
- _scratch_options mkfs
-
- $MKFS_XFS_PROG $SCRATCH_OPTIONS $mkfs_opts $SCRATCH_DEV
-}
-
-
-_scratch_mkfs_xfs_supported()
-{
- local mkfs_opts=$*
-
- _scratch_options mkfs
-
- $MKFS_XFS_PROG -N $MKFS_OPTIONS $SCRATCH_OPTIONS $mkfs_opts $SCRATCH_DEV
- local mkfs_status=$?
-
- # a mkfs failure may be caused by conflicts between $MKFS_OPTIONS and
- # $mkfs_opts, try again without $MKFS_OPTIONS
- if [ $mkfs_status -ne 0 -a -n "$mkfs_opts" ]; then
- $MKFS_XFS_PROG -N $SCRATCH_OPTIONS $mkfs_opts $SCRATCH_DEV
- mkfs_status=$?
- fi
- return $mkfs_status
-}
-
-_scratch_mkfs_xfs()
+# Do the actual mkfs work on SCRATCH_DEV. Firstly mkfs with both MKFS_OPTIONS
+# and user specified mkfs options, if that fails (due to conflicts between mkfs
+# options), do a second mkfs with only user provided mkfs options.
+#
+# First param is the mkfs command without any mkfs options and device.
+# Second param is the filter to remove unnecessary messages from mkfs stderr.
+# Other extra mkfs options are followed.
+_scratch_do_mkfs()
{
- # extra mkfs options can be added by tests
+ local mkfs_cmd=$1
+ local mkfs_filter=$2
+ shift 2
local extra_mkfs_options=$*
-
- local tmp_dir=/tmp/
+ local mkfs_status
+ 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
- _scratch_mkfs_xfs_opts $MKFS_OPTIONS $extra_mkfs_options \
- 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
- local mkfs_status=$?
-
+ eval "$mkfs_cmd $MKFS_OPTIONS $extra_mkfs_options $SCRATCH_DEV" \
+ 2>$tmp.mkfserr 1>$tmp.mkfsstd
+ mkfs_status=$?
- # a mkfs failure may be caused by conflicts between
- # $MKFS_OPTIONS and $extra_mkfs_options
- if [ $mkfs_status -ne 0 -a ! -z "$extra_mkfs_options" ]; then
+ # a mkfs failure may be caused by conflicts between $MKFS_OPTIONS and
+ # $extra_mkfs_options
+ if [ $mkfs_status -ne 0 -a -n "$extra_mkfs_options" ]; then
(
echo -n "** mkfs failed with extra mkfs options "
echo "added to \"$MKFS_OPTIONS\" by test $seq **"
) >> $seqres.full
# running mkfs again. overwrite previous mkfs output files
- _scratch_mkfs_xfs_opts $extra_mkfs_options \
- 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
- local mkfs_status=$?
- fi
-
- if [ $mkfs_status -eq 0 -a "$LARGE_SCRATCH_DEV" = yes ]; then
- # manually parse the mkfs output to get the fs size in bytes
- local fs_size
- fs_size=`cat $tmp_dir.mkfsstd | perl -ne '
- if (/^data\s+=\s+bsize=(\d+)\s+blocks=(\d+)/) {
- my $size = $1 * $2;
- print STDOUT "$size\n";
- }'`
- _setup_large_xfs_fs $fs_size
+ eval "$mkfs_cmd $extra_mkfs_options $SCRATCH_DEV" \
+ 2>$tmp.mkfserr 1>$tmp.mkfsstd
mkfs_status=$?
fi
- # output stored mkfs output, filtering unnecessary warnings from stderr
- cat $tmp_dir.mkfsstd
- cat $tmp_dir.mkfserr | sed \
- -e '/less than device physical sector/d' \
- -e '/switching to logical sector/d' \
- >&2
- rm -f $tmp_dir.mkfserr $tmp_dir.mkfsstd
+ # output stored mkfs output, filtering unnecessary output from stderr
+ cat $tmp.mkfsstd
+ eval "cat $tmp.mkfserr | $mkfs_filter" >&2
+ rm -f $tmp.mkfserr $tmp.mkfsstd
return $mkfs_status
}
-# xfs_check script is planned to be deprecated. But, we want to
-# be able to invoke "xfs_check" behavior in xfstests in order to
-# maintain the current verification levels.
-_xfs_check()
+_scratch_metadump()
{
- OPTS=" "
- DBOPTS=" "
- USAGE="Usage: xfs_check [-fsvV] [-l logdev] [-i ino]... [-b bno]... special"
+ dumpfile=$1
+ shift
+ options=
- while getopts "b:fi:l:stvV" c
- do
- case $c in
- s) OPTS=$OPTS"-s ";;
- t) OPTS=$OPTS"-t ";;
- v) OPTS=$OPTS"-v ";;
- i) OPTS=$OPTS"-i "$OPTARG" ";;
- b) OPTS=$OPTS"-b "$OPTARG" ";;
- f) DBOPTS=$DBOPTS" -f";;
- l) DBOPTS=$DBOPTS" -l "$OPTARG" ";;
- V) $XFS_DB_PROG -p xfs_check -V
- return $?
- ;;
- esac
- done
- set -- extra $@
- shift $OPTIND
- case $# in
- 1) ${XFS_DB_PROG}${DBOPTS} -F -i -p xfs_check -c "check$OPTS" $1
- status=$?
- ;;
- 2) echo $USAGE 1>&1
- status=2
- ;;
- esac
- return $status
+ [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
+ options="-l $SCRATCH_LOGDEV"
+
+ xfs_metadump $options "$@" $SCRATCH_DEV $dumpfile
}
_setup_large_ext4_fs()
_scratch_mkfs_ext4()
{
- # extra mkfs options can be added by tests
- local extra_mkfs_options=$*
-
- local tmp_dir=/tmp/
-
- $MKFS_EXT4_PROG -F $MKFS_OPTIONS $extra_mkfs_options $SCRATCH_DEV \
- 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
- local mkfs_status=$?
+ local mkfs_cmd="$MKFS_EXT4_PROG -F"
+ local mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
+ local tmp=`mktemp -u`
+ local mkfs_status
- # a mkfs failure may be caused by conflicts between
- # $MKFS_OPTIONS and $extra_mkfs_options
- if [ $mkfs_status -ne 0 -a ! -z "$extra_mkfs_options" ]; then
- (
- echo -n "** mkfs failed with extra mkfs options "
- echo "added to \"$MKFS_OPTIONS\" by test $seq **"
- echo -n "** attempting to mkfs using only test $seq "
- echo "options: $extra_mkfs_options **"
- ) >> $seqres.full
+ [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
+ $mkfs_cmd -O journal_dev $MKFS_OPTIONS $SCRATCH_LOGDEV && \
+ mkfs_cmd="$mkfs_cmd -J device=$SCRATCH_LOGDEV"
- # running mkfs again. overwrite previous mkfs output files
- $MKFS_EXT4_PROG -F $extra_mkfs_options $SCRATCH_DEV \
- 2>$tmp_dir.mkfserr 1>$tmp_dir.mkfsstd
- local mkfs_status=$?
- fi
+ _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_dir.mkfsstd | awk ' \
+ fs_size=`cat $tmp.mkfsstd | awk ' \
/^Block size/ { split($2, a, "="); bs = a[2] ; } \
/ inodes, / { blks = $3 } \
/reserved for the super user/ { resv = $1 } \
mkfs_status=$?
fi
- # output stored mkfs output
- grep -v -e ^Warning: -e "^mke2fs " $tmp_dir.mkfserr >&2
- cat $tmp_dir.mkfsstd
- rm -f $tmp_dir.mkfserr $tmp_dir.mkfsstd
+ # 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
;;
+ ceph)
+ # do nothing for ceph
+ ;;
+ glusterfs)
+ # do nothing for glusterfs
+ ;;
overlay)
# do nothing for overlay
;;
+ pvfs2)
+ # do nothing for pvfs2
+ ;;
udf)
$MKFS_UDF_PROG $MKFS_OPTIONS $* $TEST_DEV > /dev/null
;;
_mkfs_dev()
{
+ local tmp=`mktemp -u`
case $FSTYP in
nfs*)
# do nothing for nfs
overlay)
# do nothing for overlay
;;
+ pvfs2)
+ # 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
{
case $FSTYP in
overlay)
- # $SCRATCH_DEV is a valid directory in overlay case
- rm -rf $SCRATCH_DEV/*
+ # Avoid rm -rf /* if we messed up
+ [ -n "$OVL_BASE_SCRATCH_MNT" ] || return 1
+ _overlay_base_scratch_mount || return 1
+ rm -rf $OVL_BASE_SCRATCH_MNT/* || return 1
+ _overlay_mkdirs $OVL_BASE_SCRATCH_MNT
+ # leave base fs mouted so tests can setup lower/upper dir files
;;
*)
+ [ -n "$SCRATCH_MNT" ] || return 1
_scratch_mount
rm -rf $SCRATCH_MNT/*
_scratch_unmount
_scratch_mkfs()
{
- case $FSTYP in
- xfs)
- _scratch_mkfs_xfs $*
- ;;
- nfs*)
- # unable to re-create NFS, just remove all files in $SCRATCH_MNT to
- # avoid EEXIST caused by the leftover files created in previous runs
- _scratch_cleanup_files
- ;;
- cifs)
- # unable to re-create CIFS, just remove all files in $SCRATCH_MNT to
- # avoid EEXIST caused by the leftover files created in previous runs
- _scratch_cleanup_files
- ;;
- overlay)
- # unable to re-create overlay, remove all files in $SCRATCH_MNT to
- # avoid EEXIST caused by the leftover files created in previous runs
- _scratch_cleanup_files
- ;;
- udf)
- $MKFS_UDF_PROG $MKFS_OPTIONS $* $SCRATCH_DEV > /dev/null
- ;;
- btrfs)
- $MKFS_BTRFS_PROG $MKFS_OPTIONS $* $SCRATCH_DEV > /dev/null
- ;;
- ext2|ext3)
- $MKFS_PROG -t $FSTYP -- -F $MKFS_OPTIONS $* $SCRATCH_DEV
- ;;
- ext4)
- _scratch_mkfs_ext4 $*
- ;;
- tmpfs)
- # do nothing for tmpfs
- ;;
- f2fs)
- $MKFS_F2FS_PROG $MKFS_OPTIONS $* $SCRATCH_DEV > /dev/null
- ;;
- *)
- yes | $MKFS_PROG -t $FSTYP -- $MKFS_OPTIONS $* $SCRATCH_DEV
- ;;
- esac
+ local mkfs_cmd=""
+ local mkfs_filter=""
+ local mkfs_status
+
+ case $FSTYP in
+ nfs*|cifs|ceph|overlay|glusterfs|pvfs2)
+ # 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
+ _scratch_cleanup_files
+ return $?
+ ;;
+ tmpfs)
+ # 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 $?
+ ;;
+ xfs)
+ _scratch_mkfs_xfs $*
+ return $?
+ ;;
+ udf)
+ mkfs_cmd="$MKFS_UDF_PROG"
+ mkfs_filter="cat"
+ ;;
+ btrfs)
+ mkfs_cmd="$MKFS_BTRFS_PROG"
+ mkfs_filter="cat"
+ ;;
+ 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 \""
+ ;;
+ f2fs)
+ mkfs_cmd="$MKFS_F2FS_PROG"
+ mkfs_filter="cat"
+ ;;
+ ocfs2)
+ mkfs_cmd="yes | $MKFS_PROG -t $FSTYP --"
+ mkfs_filter="grep -v -e ^mkfs\.ocfs2"
+ ;;
+ *)
+ mkfs_cmd="yes | $MKFS_PROG -t $FSTYP --"
+ mkfs_filter="cat"
+ ;;
+ esac
+
+ _scratch_do_mkfs "$mkfs_cmd" "$mkfs_filter" $*
+ return $?
}
# Helper function to get a spare or replace-target device from
_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
xfs)
def_blksz=`echo $MKFS_OPTIONS|sed -rn 's/.*-b ?size= ?+([0-9]+).*/\1/p'`
;;
- ext2|ext3|ext4|ext4dev|udf|btrfs|reiser4)
+ 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
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.
+ MIN_JOURNAL_SIZE=8
+ DEFAULT_JOURNAL_SIZE=128
+ if (( fssize/8 / (1024*1024) < DEFAULT_JOURNAL_SIZE )); then
+ (( 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
;;
(( fssize <= 100 * 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 \
xfs)
_scratch_mkfs_xfs $MKFS_OPTIONS -b size=$blocksize
;;
- ext2|ext3|ext4|ocfs2)
+ 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
+ ;;
*)
_notrun "Filesystem $FSTYP not supported in _scratch_mkfs_blocksized"
;;
esac
}
-_scratch_xfs_db_options()
-{
- SCRATCH_OPTIONS=""
- [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
- SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
- echo $SCRATCH_OPTIONS $* $SCRATCH_DEV
-}
-
-_scratch_xfs_db()
-{
- $XFS_DB_PROG "$@" $(_scratch_xfs_db_options)
-}
-
-_scratch_xfs_logprint()
-{
- SCRATCH_OPTIONS=""
- [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
- SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
- $XFS_LOGPRINT_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
-}
-
-_test_xfs_logprint()
-{
- TEST_OPTIONS=""
- [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
- TEST_OPTIONS="-l$TEST_LOGDEV"
- $XFS_LOGPRINT_PROG $TEST_OPTIONS $* $TEST_DEV
-}
-_scratch_xfs_check()
-{
- SCRATCH_OPTIONS=""
- [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
- SCRATCH_OPTIONS="-l $SCRATCH_LOGDEV"
- [ "$LARGE_SCRATCH_DEV" = yes ] && \
- SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -t"
- _xfs_check $SCRATCH_OPTIONS $* $SCRATCH_DEV
-}
-
-_scratch_xfs_repair()
-{
- SCRATCH_OPTIONS=""
- [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
- SCRATCH_OPTIONS="-l$SCRATCH_LOGDEV"
- [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
- SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -r$SCRATCH_RTDEV"
- [ "$LARGE_SCRATCH_DEV" = yes ] && SCRATCH_OPTIONS=$SCRATCH_OPTIONS" -t"
- $XFS_REPAIR_PROG $SCRATCH_OPTIONS $* $SCRATCH_DEV
-}
-
-# Repair scratch filesystem. Returns 0 if the FS is good to go (either no
-# errors found or errors were fixed) and nonzero otherwise; also spits out
-# a complaint on stderr if fsck didn't tell us that the FS is good to go.
-_repair_scratch_fs()
+# Repair scratch filesystem. Returns 0 if the FS is good to go (either no
+# errors found or errors were fixed) and nonzero otherwise; also spits out
+# a complaint on stderr if fsck didn't tell us that the FS is good to go.
+_repair_scratch_fs()
{
case $FSTYP in
xfs)
_scratch_xfs_repair "$@" 2>&1
res=$?
fi
- test $res -ne 0 && >&2 echo "xfs_repair failed, err=$res"
+ if [ $res -ne 0 ]; then
+ _dump_err2 "xfs_repair failed, err=$res"
+ fi
return $res
;;
*)
res=0
;;
*)
- >&2 echo "fsck.$FSTYP failed, err=$res"
+ _dump_err2 "fsck.$FSTYP failed, err=$res"
;;
esac
return $res
# Fix the filesystem type up here so that the callers don't
# have to bother with this quirk.
#
- _df_device $1 | $AWK_PROG '{ print $2 }' | sed -e 's/nfs4/nfs/'
+ _df_device $1 | $AWK_PROG '{ print $2 }' | \
+ sed -e 's/nfs4/nfs/' -e 's/fuse.glusterfs/glusterfs/'
}
# return the FS mount options of a mounted device
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
+
+ _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
(eval "echo '---' \"$_cmd\"") >>$seqres.full
(eval "$_cmd") >$tmp._out 2>&1; ret=$?
cat $tmp._out | _fix_malloc >>$seqres.full
+ rm -f $tmp._out
if [ $# -eq 2 ]; then
if [ $ret -eq 0 ]; then
echo "done"
{
echo "$*" > $seqres.notrun
echo "$seq not run: $*"
- rm -f ${RESULT_DIR}/require_test
- rm -f ${RESULT_DIR}/require_scratch
+ rm -f ${RESULT_DIR}/require_test*
+ rm -f ${RESULT_DIR}/require_scratch*
+
status=0
exit
}
_notrun "not suitable for this OS: $HOSTOS"
}
-_require_btrfs_loadable()
+# 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
+# mounted with correct fs type
+#
+_check_mounted_on()
{
- modprobe -r btrfs || _notrun "btrfs unloadable"
- modprobe btrfs || _notrun "Can't load btrfs"
-}
+ local devname=$1
+ local dev=$2
+ local mntname=$3
+ local mnt=$4
+ local type=$5
-_reload_btrfs_ko()
-{
- modprobe -r btrfs || _fail "btrfs unload failed"
- modprobe btrfs || _fail "btrfs load failed"
+ # find $dev as the source, and print result in "$dev $mnt" format
+ local mount_rec=`findmnt -rncv -S $dev -o SOURCE,TARGET`
+ [ -n "$mount_rec" ] || return 1 # 1 = not mounted
+
+ # if it's mounted, make sure its on $mnt
+ if [ "$mount_rec" != "$dev $mnt" ]; then
+ echo "$devname=$dev is mounted but not on $mntname=$mnt - aborting"
+ echo "Already mounted result:"
+ echo $mount_rec
+ return 2 # 2 = mounted on wrong mnt
+ fi
+
+ if [ -n "$type" -a "`_fs_type $dev`" != "$type" ]; then
+ echo "$devname=$dev is mounted but not a type $type filesystem"
+ # raw $DF_PROG cannot handle NFS/CIFS/overlay correctly
+ _df_device $dev
+ return 3 # 3 = mounted as wrong type
+ fi
+ return 0 # 0 = mounted as expected
}
# this test needs a scratch partition - check we're ok & unmount it
_require_scratch_nocheck()
{
case "$FSTYP" in
- nfs*)
+ glusterfs)
+ echo $SCRATCH_DEV | egrep -q ":/?" > /dev/null 2>&1
+ if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; 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_DEV"
_notrun "this test requires a valid \$SCRATCH_MNT"
fi
;;
+ pvfs2)
+ echo $SCRATCH_DEV | grep -q "://" > /dev/null 2>&1
+ if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; then
+ _notrun "this test requires a valid \$SCRATCH_DEV"
+ fi
+ if [ ! -d "$SCRATCH_MNT" ]; then
+ _notrun "this test requires a valid \$SCRATCH_MNT"
+ fi
+ ;;
cifs)
echo $SCRATCH_DEV | grep -q "//" > /dev/null 2>&1
if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; then
fi
;;
overlay)
- if [ -z "$SCRATCH_DEV" -o ! -d "$SCRATCH_DEV" ]; then
- _notrun "this test requires a valid \$SCRATCH_DEV as ovl base dir"
+ if [ -z "$OVL_BASE_SCRATCH_MNT" -o ! -d "$OVL_BASE_SCRATCH_MNT" ]; then
+ _notrun "this test requires a valid \$OVL_BASE_SCRATCH_MNT as ovl base dir"
fi
- if [ ! -d "$SCRATCH_MNT" ]; then
+ # if $SCRATCH_MNT is derived from $OVL_BASE_SCRATCH_MNT then
+ # don't check $SCRATCH_MNT dir here because base fs may not be mounted
+ # and we will create the mount point anyway on _overlay_mount
+ if [ "$SCRATCH_MNT" != "$OVL_BASE_SCRATCH_MNT/$OVL_MNT" -a ! -d "$SCRATCH_MNT" ]; then
_notrun "this test requires a valid \$SCRATCH_MNT"
fi
;;
_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
;;
esac
- # mounted?
- # Note that we use -F here so grep doesn't try to interpret an NFS over
- # IPv6 server as a regular expression.
- mount_rec=`_mount | grep -F $SCRATCH_DEV`
- if [ "$mount_rec" ]
+ _check_mounted_on SCRATCH_DEV $SCRATCH_DEV SCRATCH_MNT $SCRATCH_MNT
+ local err=$?
+ [ $err -le 1 ] || exit 1
+ if [ $err -eq 0 ]
then
- # if it's mounted, make sure its on $SCRATCH_MNT
- if ! echo $mount_rec | grep -q $SCRATCH_MNT
- then
- echo "\$SCRATCH_DEV=$SCRATCH_DEV is mounted but not on \$SCRATCH_MNT=$SCRATCH_MNT - aborting"
- echo "Already mounted result:"
- echo $mount_rec
- exit 1
- fi
- # and then unmount it
+ # if it's mounted, unmount it
if ! _scratch_unmount
then
echo "failed to unmount $SCRATCH_DEV"
_require_test()
{
case "$FSTYP" in
- nfs*)
- echo $TEST_DEV | grep -q ":/" > /dev/null 2>&1
+ glusterfs)
+ echo $TEST_DEV | egrep -q ":/?" > /dev/null 2>&1
if [ -z "$TEST_DEV" -o "$?" != "0" ]; 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_DEV"
+ fi
if [ ! -d "$TEST_DIR" ]; then
_notrun "this test requires a valid \$TEST_DIR"
fi
_notrun "this test requires a valid \$TEST_DIR"
fi
;;
+ pvfs2)
+ echo $TEST_DEV | grep -q "://" > /dev/null 2>&1
+ if [ -z "$TEST_DEV" -o "$?" != "0" ]; then
+ _notrun "this test requires a valid \$TEST_DIR"
+ fi
+ if [ ! -d "$TEST_DIR" ]; then
+ _notrun "this test requires a valid \$TEST_DIR"
+ fi
+ ;;
overlay)
- if [ -z "$TEST_DEV" -o ! -d "$TEST_DEV" ]; then
- _notrun "this test requires a valid \$TEST_DEV as ovl base dir"
+ if [ -z "$OVL_BASE_TEST_DIR" -o ! -d "$OVL_BASE_TEST_DIR" ]; then
+ _notrun "this test requires a valid \$TEST_DIR as ovl base dir"
fi
if [ ! -d "$TEST_DIR" ]; then
_notrun "this test requires a valid \$TEST_DIR"
_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
;;
esac
- # mounted?
- # Note that we use -F here so grep doesn't try to interpret an NFS over
- # IPv6 server as a regular expression.
- mount_rec=`_mount | grep -F $TEST_DEV`
- if [ "$mount_rec" ]
+ _check_mounted_on TEST_DEV $TEST_DEV TEST_DIR $TEST_DIR
+ local err=$?
+ [ $err -le 1 ] || exit 1
+ if [ $err -ne 0 ]
then
- # if it's mounted, make sure its on $TEST_DIR
- if ! echo $mount_rec | grep -q $TEST_DIR
- then
- echo "\$TEST_DEV=$TEST_DEV is mounted but not on \$TEST_DIR=$TEST_DIR - aborting"
- echo "Already mounted result:"
- echo $mount_rec
- exit 1
- fi
- else
- out=`_mount_or_remount_rw "$MOUNT_OPTIONS" $TEST_DEV $TEST_DIR`
- if [ $? -ne 1 ]; then
- echo $out
+ if ! _test_mount
+ then
+ echo "!!! failed to mount $TEST_DEV on $TEST_DIR"
exit 1
fi
fi
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()
fi
}
+# this test requires tmpfs filesystem support
+#
+_require_tmpfs()
+{
+ modprobe tmpfs >/dev/null 2>&1
+ grep -q tmpfs /proc/filesystems ||
+ _notrun "this test requires tmpfs support"
+}
+
# this test requires that (large) loopback device files are not in use
#
_require_no_large_scratch_dev()
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.
fi
}
-# this test requires the projid32bit feature to be available in mkfs.xfs.
-#
-_require_projid32bit()
-{
- _scratch_mkfs_xfs_supported -i projid32bit=1 >/dev/null 2>&1 \
- || _notrun "mkfs.xfs doesn't have projid32bit feature"
-}
-
-_require_projid16bit()
-{
- _scratch_mkfs_xfs_supported -i projid32bit=0 >/dev/null 2>&1 \
- || _notrun "16 bit project IDs not supported on $SCRATCH_DEV"
-}
-
-# this test requires the crc feature to be available in mkfs.xfs
-#
-_require_xfs_mkfs_crc()
-{
- _scratch_mkfs_xfs_supported -m crc=1 >/dev/null 2>&1 \
- || _notrun "mkfs.xfs doesn't have crc feature"
-}
-
-# this test requires the xfs kernel support crc feature
-#
-_require_xfs_crc()
-{
- _scratch_mkfs_xfs -m crc=1 >/dev/null 2>&1
- _scratch_mount >/dev/null 2>&1 \
- || _notrun "Kernel doesn't support crc feature"
- _scratch_unmount
-}
-
# this test requires the ext4 kernel support crc feature on scratch device
#
_require_scratch_ext4_crc()
_scratch_unmount
}
-# this test requires the xfs kernel support crc feature on scratch device
-#
-_require_scratch_xfs_crc()
+# Check the specified feature whether it is available in mkfs.ext4 or not.
+_require_ext4_mkfs_feature()
{
- _scratch_mkfs_xfs >/dev/null 2>&1
- _scratch_mount >/dev/null 2>&1 \
- || _notrun "Kernel doesn't support crc feature"
- xfs_info $SCRATCH_MNT | grep -q 'crc=1' || _notrun "crc feature not supported by this filesystem"
- _scratch_unmount
-}
+ local feature=$1
+ local testfile=/tmp/$$.ext4_mkfs
-# this test requires the bigalloc feature to be available in mkfs.ext4
-#
-_require_ext4_mkfs_bigalloc()
-{
- $MKFS_EXT4_PROG -F -O bigalloc -n $SCRATCH_DEV 512m >/dev/null 2>&1 \
- || _notrun "mkfs.ext4 doesn't have bigalloc feature"
+ 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
_scratch_unmount
}
-# this test requires the finobt feature to be available in mkfs.xfs
-#
-_require_xfs_mkfs_finobt()
-{
- _scratch_mkfs_xfs_supported -m crc=1,finobt=1 >/dev/null 2>&1 \
- || _notrun "mkfs.xfs doesn't have finobt feature"
-}
-
-# this test requires the xfs kernel support finobt feature
-#
-_require_xfs_finobt()
-{
- _scratch_mkfs_xfs -m crc=1,finobt=1 >/dev/null 2>&1
- _scratch_mount >/dev/null 2>&1 \
- || _notrun "Kernel doesn't support finobt feature"
- _scratch_unmount
-}
-
-# this test requires xfs sysfs attribute support
-#
-_require_xfs_sysfs()
-{
- attr=$1
- sysfsdir=/sys/fs/xfs
-
- if [ ! -e $sysfsdir ]; then
- _notrun "no kernel support for XFS sysfs attributes"
- fi
-
- if [ ! -z $1 ] && [ ! -e $sysfsdir/$attr ]; then
- _notrun "sysfs attribute '$attr' is not supported"
- fi
-}
-
-# this test requires the xfs sparse inode feature
-#
-_require_xfs_sparse_inodes()
-{
- _scratch_mkfs_xfs_supported -m crc=1 -i sparse > /dev/null 2>&1 \
- || _notrun "mkfs.xfs does not support sparse inodes"
- _scratch_mkfs_xfs -m crc=1 -i sparse > /dev/null 2>&1
- _scratch_mount >/dev/null 2>&1 \
- || _notrun "kernel does not support sparse inodes"
- _scratch_unmount
-}
-
# this test requires that external log/realtime devices are not in use
#
_require_nonexternal()
_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
}
return $status
}
+# this test requires y2038 sysfs switch and filesystem
+# timestamp ranges support.
+_require_y2038()
+{
+ 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
+}
+
+_filesystem_timestamp_range()
+{
+ device=${1:-$TEST_DEV}
+ case $FSTYP in
+ ext4)
+ if [ $(dumpe2fs -h $device 2>/dev/null | grep "Inode size:" | cut -d: -f2) -gt 128 ]; then
+ echo "-2147483648 15032385535"
+ else
+ echo "-2147483648 2147483647"
+ fi
+ ;;
+
+ xfs)
+ echo "-2147483648 2147483647"
+ ;;
+ jfs)
+ echo "0 4294967295"
+ ;;
+ f2fs)
+ echo "-2147483648 2147483647"
+ ;;
+ *)
+ echo "-1 -1"
+ ;;
+ esac
+}
+
# indicate whether YP/NIS is active or not
#
_yp_active()
{
local dn
dn=$(domainname 2>/dev/null)
- test -n "${dn}" -a "${dn}" != "(none)"
+ test -n "${dn}" -a "${dn}" != "(none)" -a "${dn}" != "localdomain"
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 $qa_user 2>&1 | _filter_user_do
- fi
+ echo $1 | su -s /bin/bash $qa_user 2>&1 | _filter_user_do
}
_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
testfile=$TEST_DIR/$$.xfs_io
case $command in
"chproj")
testio=`$XFS_IO_PROG -F -f -c "chproj 0" $testfile 2>&1`
;;
+ "copy_range")
+ 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 0 1m" $testfile 2>&1`
+ 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" \
;;
"fiemap")
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" )
testio=`$XFS_IO_PROG -T -F -c "flink $testfile" \
;;
"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"
+ ;;
+ "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 | grep -q "invalid option" && \
_notrun "xfs_io $command support is missing"
;;
+ "scrub"|"repair")
+ testio=`$XFS_IO_PROG -x -c "$command probe 0" $TEST_DIR 2>&1`
+ echo $testio | grep -q "Inappropriate ioctl" && \
+ _notrun "xfs_io $command support is missing"
+ ;;
+ "utimes" )
+ testio=`$XFS_IO_PROG -f -c "utimes" 0 0 0 0 $testfile 2>&1`
+ ;;
*)
- testio=`$XFS_IO_PROG -c "$command help" 2>&1`
+ testio=`$XFS_IO_PROG -c "help $command" 2>&1`
esac
rm -f $testfile 2>&1 > /dev/null
_notrun "xfs_io $command support is missing"
echo $testio | grep -q "Operation not supported" && \
_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
-# check that xfs_db supports a specific command
-_require_xfs_db_command()
-{
- if [ $# -ne 1 ]
- then
- echo "Usage: _require_xfs_db_command command" 1>&2
- exit 1
+ if [ $param_checked -eq 0 ]; then
+ $XFS_IO_PROG -c "help $command" | grep -q "^ $param --" || \
+ _notrun "xfs_io $command doesn't support $param"
+ else
+ echo $testio | grep -q "invalid option" && \
+ _notrun "xfs_io $command doesn't support $param"
fi
- command=$1
-
- _scratch_xfs_db -x -c "help" | grep $command > /dev/null || \
- _notrun "xfs_db $command support is missing"
}
# check that kernel and filesystem support direct I/O
rm -f $testfile 2>&1 > /dev/null
}
+# Check that the filesystem supports swapfiles
+_require_scratch_swapfile()
+{
+ _require_scratch
+
+ _scratch_mkfs >/dev/null
+ _scratch_mount
+
+ # Minimum size for mkswap is 10 pages
+ local size=$(($(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"
+ fi
+
+ swapoff "$SCRATCH_MNT/swap" >/dev/null 2>&1
+ _scratch_unmount
+}
+
# Check that a fs has enough free space (in 1024b blocks)
#
_require_fs_space()
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
+}
+
# 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()
_overlay_mount $device $mountpoint
fi
if [ $? -ne 0 ]; then
- echo "!!! failed to remount $device on $mountpoint"
+ _dump_err "!!! failed to remount $device on $mountpoint"
return 0 # ok=0
fi
else
# and that it will still return an errno for corruption in this mode.
#
# Filesystems which don't support this will need to define their
-# own check routine.
-#
-_check_generic_filesystem()
-{
- device=$1
-
- # If type is set, we're mounted
- type=`_fs_type $device`
- ok=1
-
- if [ "$type" = "$FSTYP" ]
- then
- # mounted ...
- mountpoint=`_umount_or_remount_ro $device`
- fi
-
- fsck -t $FSTYP $FSCK_OPTIONS $device >$tmp.fsck 2>&1
- if [ $? -ne 0 ]
- then
- echo "_check_generic_filesystem: filesystem on $device is inconsistent (see $seqres.full)"
-
- echo "_check_generic filesystem: filesystem on $device is inconsistent" >>$seqres.full
- echo "*** fsck.$FSTYP output ***" >>$seqres.full
- cat $tmp.fsck >>$seqres.full
- echo "*** end fsck.$FSTYP output" >>$seqres.full
-
- ok=0
- fi
- rm -f $tmp.fsck
-
- if [ $ok -eq 0 ]
- then
- echo "*** mount output ***" >>$seqres.full
- _mount >>$seqres.full
- echo "*** end mount output" >>$seqres.full
- elif [ "$type" = "$FSTYP" ]
- then
- # was mounted ...
- _mount_or_remount_rw "$MOUNT_OPTIONS" $device $mountpoint
- ok=$?
- fi
-
- if [ $ok -eq 0 ]; then
- status=1
- if [ "$iam" != "check" ]; then
- exit 1
- fi
- return 1
- fi
-
- return 0
-}
-
-# run xfs_check and friends on a FS.
-
-_check_xfs_filesystem()
-{
- if [ $# -ne 3 ]
- then
- echo "Usage: _check_xfs_filesystem device <logdev>|none <rtdev>|none" 1>&2
- exit 1
- fi
-
- extra_mount_options=""
- extra_log_options=""
- extra_options=""
- device=$1
- if [ -f $device ];then
- extra_options="-f"
- fi
-
- if [ "$2" != "none" ]; then
- extra_log_options="-l$2"
- extra_mount_options="-ologdev=$2"
- fi
-
- if [ "$3" != "none" ]; then
- extra_rt_options="-r$3"
- extra_mount_options=$extra_mount_options" -ortdev=$3"
- fi
- extra_mount_options=$extra_mount_options" $MOUNT_OPTIONS"
-
- [ "$FSTYP" != xfs ] && return 0
-
- type=`_fs_type $device`
- ok=1
-
- if [ "$type" = "xfs" ]
- then
- if [ -n "$TEST_XFS_SCRUB" ] && [ -x "$XFS_SCRUB_PROG" ]; then
- "$XFS_SCRUB_PROG" $scrubflag -vd $device >>$seqres.full
- if [ $? -ne 0 ]; then
- echo "filesystem on $device failed scrub (see $seqres.full)"
- ok=0
- fi
- fi
- # mounted ...
- mountpoint=`_umount_or_remount_ro $device`
- fi
-
- $XFS_LOGPRINT_PROG -t $extra_log_options $device 2>&1 \
- | tee $tmp.logprint | grep -q "<CLEAN>"
- if [ $? -ne 0 -a "$HOSTOS" = "Linux" ]
- then
- echo "_check_xfs_filesystem: filesystem on $device has dirty log (see $seqres.full)"
-
- echo "_check_xfs_filesystem: filesystem on $device has dirty log" >>$seqres.full
- echo "*** xfs_logprint -t output ***" >>$seqres.full
- cat $tmp.logprint >>$seqres.full
- echo "*** end xfs_logprint output" >>$seqres.full
-
- ok=0
- fi
-
- # xfs_check runs out of memory on large files, so even providing the test
- # option (-t) to avoid indexing the free space trees doesn't make it pass on
- # large filesystems. Avoid it.
- if [ "$LARGE_SCRATCH_DEV" != yes ]; then
- _xfs_check $extra_log_options $device 2>&1 |\
- _fix_malloc >$tmp.fs_check
- fi
- if [ -s $tmp.fs_check ]
- then
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent (c) (see $seqres.full)"
-
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$seqres.full
- echo "*** xfs_check output ***" >>$seqres.full
- cat $tmp.fs_check >>$seqres.full
- echo "*** end xfs_check output" >>$seqres.full
-
- ok=0
- fi
-
- $XFS_REPAIR_PROG -n $extra_options $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
- if [ $? -ne 0 ]
- then
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent (r) (see $seqres.full)"
-
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent" >>$seqres.full
- echo "*** xfs_repair -n output ***" >>$seqres.full
- cat $tmp.repair | _fix_malloc >>$seqres.full
- echo "*** end xfs_repair output" >>$seqres.full
-
- ok=0
- fi
- rm -f $tmp.fs_check $tmp.logprint $tmp.repair
-
- # Optionally test the index rebuilding behavior.
- if [ -n "$TEST_XFS_REPAIR_REBUILD" ]; then
- $XFS_REPAIR_PROG $extra_options $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
- if [ $? -ne 0 ]; then
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent (rebuild) (see $seqres.full)"
-
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent (rebuild)" >>$seqres.full
- echo "*** xfs_repair output ***" >>$seqres.full
- cat $tmp.repair | _fix_malloc >>$seqres.full
- echo "*** end xfs_repair output" >>$seqres.full
-
- ok=0
- fi
- rm -f $tmp.repair
-
- $XFS_REPAIR_PROG -n $extra_options $extra_log_options $extra_rt_options $device >$tmp.repair 2>&1
- if [ $? -ne 0 ]; then
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent (rebuild-reverify) (see $seqres.full)"
-
- echo "_check_xfs_filesystem: filesystem on $device is inconsistent (rebuild-reverify)" >>$seqres.full
- echo "*** xfs_repair -n output ***" >>$seqres.full
- cat $tmp.repair | _fix_malloc >>$seqres.full
- echo "*** end xfs_repair output" >>$seqres.full
-
- ok=0
- fi
- rm -f $tmp.repair
- fi
-
- if [ $ok -eq 0 ]
- then
- echo "*** mount output ***" >>$seqres.full
- _mount >>$seqres.full
- echo "*** end mount output" >>$seqres.full
- elif [ "$type" = "xfs" ]
- then
- _mount_or_remount_rw "$extra_mount_options" $device $mountpoint
- fi
-
- if [ $ok -eq 0 ]; then
- status=1
- if [ "$iam" != "check" ]; then
- exit 1
- fi
- return 1
- fi
-
- return 0
-}
-
-# Filter the knowen errors the UDF Verifier reports.
-_udf_test_known_error_filter()
-{
- egrep -v "PVD 60 Error: Interchange Level: 1, Maximum Interchange Level: 0|FSD 28 Error: Interchange Level: 1, Maximum Interchange Level: 1,|PVD 72 Warning: Volume Set Identifier: \"\*IRIX UDF\",|Warning: [0-9]+ unused blocks NOT marked as unallocated."
-
-}
-
-_check_udf_filesystem()
-{
- [ "$DISABLE_UDF_TEST" == "1" ] && return
-
- if [ $# -ne 1 -a $# -ne 2 ]
- then
- echo "Usage: _check_udf_filesystem device [last_block]" 1>&2
- exit 1
- fi
-
- if [ ! -x $here/src/udf_test ]
- then
- echo "udf_test not installed, please download and build the Philips"
- echo "UDF Verification Software from http://www.extra.research.philips.com/udf/."
- echo "Then copy the udf_test binary to $here/src/."
- echo "If you do not wish to run udf_test then set environment variable DISABLE_UDF_TEST"
- echo "to 1."
- return
- fi
-
- device=$1
- if [ $# -eq 2 ];
- then
- LAST_BLOCK=`expr \( $2 - 1 \)`
- OPT_ARG="-lastvalidblock $LAST_BLOCK"
- 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" | \
- _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
- return 0
-}
-
-_check_xfs_test_fs()
-{
- TEST_LOG="none"
- TEST_RT="none"
- [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
- TEST_LOG="$TEST_LOGDEV"
-
- [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
- TEST_RT="$TEST_RTDEV"
-
- _check_xfs_filesystem $TEST_DEV $TEST_LOG $TEST_RT
-
- # check for ipath consistency
- if $XFS_GROWFS_PROG -n $TEST_DIR | grep -q 'inode-paths=1'; then
- # errors go to stderr
- xfs_check_ipaths $TEST_DIR >/dev/null
- xfs_repair_ipaths -n $TEST_DIR >/dev/null
- fi
-}
-
-_check_btrfs_filesystem()
+# own check routine.
+#
+_check_generic_filesystem()
{
device=$1
mountpoint=`_umount_or_remount_ro $device`
fi
- btrfsck $device >$tmp.fsck 2>&1
+ fsck -t $FSTYP $FSCK_OPTIONS $device >$tmp.fsck 2>&1
if [ $? -ne 0 ]
then
- echo "_check_btrfs_filesystem: filesystem on $device is inconsistent (see $seqres.full)"
-
- echo "_check_btrfs_filesystem: filesystem on $device is inconsistent" >>$seqres.full
+ _log_err "_check_generic_filesystem: filesystem on $device is inconsistent"
echo "*** fsck.$FSTYP output ***" >>$seqres.full
cat $tmp.fsck >>$seqres.full
echo "*** end fsck.$FSTYP output" >>$seqres.full
return 0
}
+# Filter the knowen errors the UDF Verifier reports.
+_udf_test_known_error_filter()
+{
+ egrep -v "PVD 60 Error: Interchange Level: 1, Maximum Interchange Level: 0|FSD 28 Error: Interchange Level: 1, Maximum Interchange Level: 1,|PVD 72 Warning: Volume Set Identifier: \"\*IRIX UDF\",|Warning: [0-9]+ unused blocks NOT marked as unallocated."
+
+}
+
+_check_udf_filesystem()
+{
+ [ "$DISABLE_UDF_TEST" == "1" ] && return
+
+ if [ $# -ne 1 -a $# -ne 2 ]
+ then
+ echo "Usage: _check_udf_filesystem device [last_block]" 1>&2
+ exit 1
+ fi
+
+ if [ ! -x $here/src/udf_test ]
+ then
+ echo "udf_test not installed, please download and build the Philips"
+ echo "UDF Verification Software from http://www.extra.research.philips.com/udf/."
+ echo "Then copy the udf_test binary to $here/src/."
+ echo "If you do not wish to run udf_test then set environment variable DISABLE_UDF_TEST"
+ echo "to 1."
+ return
+ fi
+
+ device=$1
+ if [ $# -eq 2 ];
+ then
+ LAST_BLOCK=`expr \( $2 - 1 \)`
+ OPT_ARG="-lastvalidblock $LAST_BLOCK"
+ 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" | \
+ _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
+ return 0
+}
+
_check_test_fs()
{
case $FSTYP in
cifs)
# no way to check consistency for cifs
;;
+ ceph)
+ # no way to check consistency for CephFS
+ ;;
+ glusterfs)
+ # no way to check consistency for GlusterFS
+ ;;
overlay)
# no way to check consistency for overlay
;;
+ pvfs2)
+ ;;
udf)
# do nothing for now
;;
tmpfs)
# no way to check consistency for tmpfs
;;
+ ubifs)
+ # there is no fsck program for ubifs yet
+ ;;
*)
_check_generic_filesystem $TEST_DEV
;;
cifs)
# Don't know how to check a CIFS filesystem, yet.
;;
+ ceph)
+ # no way to check consistency for CephFS
+ ;;
+ glusterfs)
+ # no way to check consistency for GlusterFS
+ ;;
overlay)
# no way to check consistency for overlay
;;
+ pvfs2)
+ ;;
btrfs)
_check_btrfs_filesystem $device
;;
tmpfs)
# no way to check consistency for tmpfs
;;
+ ubifs)
+ # there is no fsck program for ubifs yet
+ ;;
*)
_check_generic_filesystem $device
;;
_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`
exit 1
}
+# convert urandom incompressible data to compressible text data
+_ddt()
+{
+ od /dev/urandom | dd iflag=fullblock ${*}
+}
+
#takes files, randomdata
_nfiles()
{
if [ $size -gt 0 ]; then
if [ "$2" == "false" ]; then
dd if=/dev/zero of=$file bs=1024 count=$size 2>&1 | _filter_dd
+ elif [ "$2" == "comp" ]; then
+ _ddt of=$file bs=1024 count=$size 2>&1 | _filter_dd
else
dd if=/dev/urandom of=$file bs=1024 count=$size 2>&1 | _filter_dd
fi
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 or zero
+ randomdata=false # -x data type urandom, zero or compressible
OPTIND=1
- while getopts "d:f:n:r:s:v:x" c
+ while getopts "d:f:n:r:s:v:x:c" c
do
case $c in
d) depth=$OPTARG;;
v) verbose=true;;
r) root=$OPTARG;;
x) randomdata=true;;
+ c) randomdata=comp;;
esac
done
#
_test_inode_flag()
{
- flag=$1
- file=$2
+ flag=$1
+ file=$2
- if which $XFS_IO_PROG >/dev/null; then
- if $XFS_IO_PROG -r -c 'lsattr -v' "$file" | grep -q "$flag" ; then
- return 0
- fi
- fi
- return 1
+ if $XFS_IO_PROG -r -c 'lsattr -v' "$file" | grep -q "$flag" ; then
+ return 0
+ fi
+ return 1
}
# query the given files extsize allocator hint in bytes (if any)
#
_test_inode_extsz()
{
- file=$1
- blocks=""
+ file=$1
+ blocks=""
- if which $XFS_IO_PROG >/dev/null; then
blocks=`$XFS_IO_PROG -r -c 'stat' "$file" | \
awk '/^xattr.extsize =/ { print $3 }'`
- fi
- [ -z "$blocks" ] && blocks="0"
- echo $blocks
+ [ -z "$blocks" ] && blocks="0"
+ echo $blocks
}
# scratch_dev_pool should contain the disks pool for the btrfs raid
done
}
-# We check for btrfs and (optionally) features of the btrfs command
-_require_btrfs()
-{
- cmd=$1
- _require_command "$BTRFS_UTIL_PROG" btrfs
- if [ -z "$1" ]; then
- return 1;
- fi
- $BTRFS_UTIL_PROG $cmd --help >/dev/null 2>&1
- [ $? -eq 0 ] || _notrun "$BTRFS_UTIL_PROG too old (must support $cmd)"
-}
-
# Check that fio is present, and it is able to execute given jobfile
_require_fio()
{
[ $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()
{
_scratch_unmount
}
+# Does dax mount option work on this dev/fs?
+_require_scratch_dax()
+{
+ _require_scratch
+ _scratch_mkfs > /dev/null 2>&1
+ _scratch_mount -o dax
+ # 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
+}
+
# Does norecovery support by this fs?
_require_norecovery()
{
fi
case "$FSTYP" in
- ext2|vfat|msdos)
+ ext2|vfat|msdos|udf)
_notrun "$FSTYP does not support metadata journaling"
;;
ext4)
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()
"$@" >> $seqres.full 2>&1 || _fail "failed: '$@'"
}
-_run_btrfs_util_prog()
-{
- run_check $BTRFS_UTIL_PROG $*
-}
-
-_require_btrfs_send_stream_version()
-{
- $BTRFS_UTIL_PROG send 2>&1 | \
- grep '^[ \t]*\-\-stream\-version <version>' > /dev/null 2>&1
- if [ $? -ne 0 ]; then
- _notrun "Missing btrfs-progs send --stream-version command line option, skipped this test"
- fi
-
- # test if btrfs kernel supports send stream version 2
- if [ ! -f /sys/fs/btrfs/send/stream_version ]; then
- _notrun "Missing btrfs kernel patch for send stream version 2, skipped this test"
- fi
-}
-
-_require_btrfs_mkfs_feature()
-{
- if [ -z $1 ]; then
- echo "Missing feature name argument for _require_btrfs_mkfs_feature"
- exit 1
- fi
- feat=$1
- $MKFS_BTRFS_PROG -O list-all 2>&1 | \
- grep '^[ \t]*'"$feat"'\b' > /dev/null 2>&1
- [ $? -eq 0 ] || \
- _notrun "Feature $feat not supported in the available version of mkfs.btrfs"
-}
-
-_require_btrfs_fs_feature()
-{
- if [ -z $1 ]; then
- echo "Missing feature name argument for _require_btrfs_fs_feature"
- exit 1
- fi
- feat=$1
- modprobe btrfs > /dev/null 2>&1
- [ -e /sys/fs/btrfs/features/$feat ] || \
- _notrun "Feature $feat not supported by the available btrfs version"
-}
-
_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`
ln -s `basename $target` $link
_notrun "Require fcntl advisory locks support"
}
-# XFS ability to change UUIDs on V5/CRC filesystems
-#
-_require_meta_uuid()
-{
- # This will create a crc fs on $SCRATCH_DEV
- _require_xfs_crc
-
- _scratch_xfs_db -x -c "uuid restore" 2>&1 \
- | grep -q "invalid UUID\|supported on V5 fs" \
- && _notrun "Userspace doesn't support meta_uuid feature"
-
- _scratch_xfs_db -x -c "uuid generate" >/dev/null 2>&1
-
- _scratch_mount >/dev/null 2>&1 \
- || _notrun "Kernel doesn't support meta_uuid feature"
- _scratch_unmount
-}
-
-_require_btrfs_dev_del_by_devid()
-{
- $BTRFS_UTIL_PROG device delete --help | egrep devid > /dev/null 2>&1
- [ $? -eq 0 ] || _notrun "$BTRFS_UTIL_PROG too old "\
- "(must support 'btrfs device delete <devid> /<mnt>')"
-}
-
_require_test_lsattr()
{
testio=$(lsattr -d $TEST_DIR 2>&1)
_notrun "lsattr not supported by test filesystem type: $FSTYP"
}
-_require_xfs_test_rmapbt()
+_require_chattr()
{
- _require_test
-
- if [ "$(xfs_info "$TEST_DIR" | grep -c "rmapbt=1")" -ne 1 ]; then
- _notrun "rmapbt not supported by test filesystem type: $FSTYP"
+ if [ -z "$1" ]; then
+ echo "Usage: _require_chattr <attr>"
+ exit 1
fi
-}
+ local attribute=$1
-_require_xfs_scratch_rmapbt()
-{
- _require_scratch
-
- _scratch_mkfs > /dev/null
- _scratch_mount
- if [ "$(xfs_info "$SCRATCH_MNT" | grep -c "rmapbt=1")" -ne 1 ]; then
- _scratch_unmount
- _notrun "rmapbt not supported by scratch filesystem type: $FSTYP"
+ touch $TEST_DIR/syscalltest
+ chattr "+$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
+ status=$?
+ chattr "-$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
+ if [ "$status" -ne 0 ]; then
+ _notrun "file system doesn't support chattr +$attribute"
fi
- _scratch_unmount
-}
-
-_xfs_bmapx_find() {
- case "$1" in
- "attr")
- param="a"
- ;;
- "cow")
- param="c"
- ;;
- *)
- param="e"
- ;;
- esac
- shift
- file="$1"
- shift
-
- $XFS_IO_PROG -c "bmap -${param}lpv" "$file" | grep -c "$@"
-}
-
-_require_chattr()
-{
- attribute=$1
-
- touch $TEST_DIR/syscalltest
- chattr "+$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
- status=$?
- chattr "-$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
- if [ "$status" -ne 0 ]; then
- _notrun "file system doesn't support chattr +$attribute"
- fi
- cat $TEST_DIR/syscalltest.out >> $seqres.full
-
- rm -f $TEST_DIR/syscalltest.out
+ cat $TEST_DIR/syscalltest.out >> $seqres.full
+ rm -f $TEST_DIR/syscalltest.out
}
_get_total_inode()
echo $((avail_kb * 1024))
}
-# get btrfs profile configs being tested
-#
-# A set of pre-set profile configs are exported via _btrfs_profile_configs
-# array. Default configs can be overridden by setting BTRFS_PROFILE_CONFIGS
-# var in the format "metadata_profile:data_profile", multiple configs can be
-# seperated by space, e.g.
-# export BTRFS_PROFILE_CONFIGS="raid0:raid0 raid1:raid1 dup:single"
-_btrfs_get_profile_configs()
-{
- if [ "$FSTYP" != "btrfs" ]; then
- return
- fi
-
- if [ -z "$BTRFS_PROFILE_CONFIGS" ]; then
- # Default configurations to test.
- local configs=(
- "single:single"
- "dup:single"
- "raid0:raid0"
- "raid1:raid0"
- "raid1:raid1"
- "raid10:raid10"
- "raid5:raid5"
- "raid6:raid6"
- )
- else
- # User-provided configurations.
- local configs=(${BTRFS_PROFILE_CONFIGS[@]})
- fi
-
- _btrfs_profile_configs=()
- for cfg in "${configs[@]}"; do
- local supported=true
- local profiles=(${cfg/:/ })
- if [ "$1" == "replace" ]; then
- # We can't do replace with these profiles because they
- # imply only one device ($SCRATCH_DEV), and we need to
- # keep $SCRATCH_DEV around for _scratch_mount
- # and _check_scratch_fs.
- local unsupported=(
- "dup"
- )
- elif [ "$1" == "replace-missing" ]; then
- # We can't replace missing devices with these profiles
- # because there isn't enough redundancy.
- local unsupported=(
- "single"
- "dup"
- "raid0"
- )
- else
- local unsupported=()
- fi
- for unsupp in "${unsupported[@]}"; do
- if [ "${profiles[0]}" == "$unsupp" -o "${profiles[1]}" == "$unsupp" ]; then
- if [ -z "$BTRFS_PROFILE_CONFIGS" ]; then
- # For the default config, just omit it.
- supported=false
- else
- # For user-provided config, don't run the test.
- _notrun "Profile $unsupp not supported for $1"
- fi
- fi
- done
- if "$supported"; then
- _btrfs_profile_configs+=("-m ${profiles[0]} -d ${profiles[1]}")
- fi
- done
- export _btrfs_profile_configs
-}
-
-# stress btrfs by running balance operation in a loop
-_btrfs_stress_balance()
-{
- local options=$@
- while true; do
- $BTRFS_UTIL_PROG balance start $options
- done
-}
-
-# stress btrfs by creating/mounting/umounting/deleting subvolume in a loop
-_btrfs_stress_subvolume()
-{
- local btrfs_dev=$1
- local btrfs_mnt=$2
- local subvol_name=$3
- local subvol_mnt=$4
- local stop_file=$5
-
- mkdir -p $subvol_mnt
- while [ ! -e $stop_file ]; do
- $BTRFS_UTIL_PROG subvolume create $btrfs_mnt/$subvol_name
- $MOUNT_PROG -o subvol=$subvol_name $btrfs_dev $subvol_mnt
- $UMOUNT_PROG $subvol_mnt
- $BTRFS_UTIL_PROG subvolume delete $btrfs_mnt/$subvol_name
- done
-}
-
-# stress btrfs by running scrub in a loop
-_btrfs_stress_scrub()
-{
- local btrfs_mnt=$1
- while true; do
- $BTRFS_UTIL_PROG scrub start -B $btrfs_mnt
- done
-}
-
-# stress btrfs by defragmenting every file/dir in a loop and compress file
-# contents while defragmenting if second argument is not "nocompress"
-_btrfs_stress_defrag()
-{
- local btrfs_mnt=$1
- local compress=$2
-
- while true; do
- if [ "$compress" == "nocompress" ]; then
- find $btrfs_mnt \( -type f -o -type d \) -exec \
- $BTRFS_UTIL_PROG filesystem defrag {} \;
- else
- find $btrfs_mnt \( -type f -o -type d \) -exec \
- $BTRFS_UTIL_PROG filesystem defrag -clzo {} \;
- find $btrfs_mnt \( -type f -o -type d \) -exec \
- $BTRFS_UTIL_PROG filesystem defrag -czlib {} \;
- fi
- done
-}
-
-# stress btrfs by remounting it with different compression algorithms in a loop
-# run this with fsstress running at background could exercise the compression
-# code path and ensure no race when switching compression algorithm with constant
-# I/O activity.
-_btrfs_stress_remount_compress()
-{
- local btrfs_mnt=$1
- while true; do
- for algo in no zlib lzo; do
- $MOUNT_PROG -o remount,compress=$algo $btrfs_mnt
- done
- done
-}
-
-# stress btrfs by replacing devices in a loop
-# Note that at least 3 devices are needed in SCRATCH_DEV_POOL and the last
-# device should be free(not used by btrfs)
-_btrfs_stress_replace()
-{
- local btrfs_mnt=$1
-
- # The device number in SCRATCH_DEV_POOL should be at least 3,
- # one is SCRATCH_DEV, one is to be replaced, one is free device
- # we won't replace SCRATCH_DEV, see below for reason
- if [ "`echo $SCRATCH_DEV_POOL | wc -w`" -lt 3 ]; then
- echo "_btrfs_stress_replace requires at least 3 devices in SCRATCH_DEV_POOL"
- return
- fi
-
- # take the last device as the first free_dev
- local free_dev="`echo $SCRATCH_DEV_POOL | $AWK_PROG '{print $NF}'`"
-
- # free_dev should be really free
- if $BTRFS_UTIL_PROG filesystem show $btrfs_mnt | grep -q "$free_dev"; then
- echo "_btrfs_stress_replace: $free_dev is used by btrfs"
- return
- fi
-
- # dev_pool is device list being currently used by btrfs (excluding SCRATCH_DEV)
- # and can be replaced. We don't replace SCRATCH_DEV because it will be used in
- # _scratch_mount and _check_scratch_fs etc.
- local dev_pool=`echo $SCRATCH_DEV_POOL | sed -e "s# *$SCRATCH_DEV *##" \
- -e "s# *$free_dev *##"`
-
- # set the first device in dev_pool as the first src_dev to be replaced
- local src_dev=`echo $dev_pool | $AWK_PROG '{print $1}'`
-
- echo "dev_pool=$dev_pool"
- echo "free_dev=$free_dev, src_dev=$src_dev"
- while true; do
- echo "Replacing $src_dev with $free_dev"
- $BTRFS_UTIL_PROG replace start -fB $src_dev $free_dev $btrfs_mnt
- if [ $? -ne 0 ]; then
- # don't update src_dev and free_dev if replace failed
- continue
- fi
- dev_pool="$dev_pool $free_dev"
- dev_pool=`echo $dev_pool | sed -e "s# *$src_dev *##"`
- free_dev=$src_dev
- src_dev=`echo $dev_pool | $AWK_PROG '{print $1}'`
- done
-}
-
-# find the right option to force output in bytes, older versions of btrfs-progs
-# print that by default, newer print human readable numbers with unit suffix
-_btrfs_qgroup_units()
-{
- $BTRFS_UTIL_PROG qgroup show --help 2>&1 | grep -q -- --raw && echo "--raw"
-}
-
# return device size in kb
_get_device_size()
{
# 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" \
+ egrep -q -e "kernel BUG at" \
-e "WARNING:" \
-e "BUG:" \
-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" \
$seqres.dmesg
if [ $? -eq 0 ]; then
- echo "_check_dmesg: something found in dmesg (see $seqres.dmesg)"
+ _dump_err "_check_dmesg: something found in dmesg (see $seqres.dmesg)"
return 1
else
rm -f $seqres.dmesg
fi
fi
- if [ "`_fs_type $TEST_DEV`" != "$FSTYP" ]
- then
- echo "common/rc: Error: \$TEST_DEV ($TEST_DEV) is not a MOUNTED $FSTYP filesystem"
- # raw $DF_PROG cannot handle NFS/CIFS/overlay correctly
- _df_device $TEST_DEV
- exit 1
+ # Sanity check that TEST partition is not mounted at another mount point
+ # or as another fs type
+ _check_mounted_on TEST_DEV $TEST_DEV TEST_DIR $TEST_DIR $FSTYP || exit 1
+ if [ -n "$SCRATCH_DEV" ]; then
+ # Sanity check that SCRATCH partition is not mounted at another
+ # mount point, because it is about to be unmounted and formatted.
+ # Another fs type for scratch is fine (bye bye old fs type).
+ _check_mounted_on SCRATCH_DEV $SCRATCH_DEV SCRATCH_MNT $SCRATCH_MNT
+ [ $? -le 1 ] || exit 1
fi
+
# Figure out if we need to add -F ("foreign", deprecated) option to xfs_io
$XFS_IO_PROG -c stat $TEST_DIR 2>&1 | grep -q "is not on an XFS filesystem" && \
export XFS_IO_PROG="$XFS_IO_PROG -F"
$XFS_IO_PROG -i -c quit 2>/dev/null && \
export XFS_IO_PROG="$XFS_IO_PROG -i"
- # xfs_copy doesn't work on v5 xfs yet without -d option
- if [ "$FSTYP" == "xfs" ] && [[ $MKFS_OPTIONS =~ crc=1 ]]; then
- export XFS_COPY_PROG="$XFS_COPY_PROG -d"
+ # xfs_copy on v5 filesystems do not require the "-d" option if xfs_db
+ # can change the UUID on v5 filesystems
+ if [ "$FSTYP" == "xfs" ]; then
+ touch /tmp/$$.img
+ $MKFS_XFS_PROG -d file,name=/tmp/$$.img,size=512m >/dev/null 2>&1
+ # xfs_db will return 0 even if it can't generate a new uuid, so
+ # check the output to make sure if it can change UUID of V5 xfs
+ $XFS_DB_PROG -x -c "uuid generate" /tmp/$$.img \
+ | grep -q "invalid UUID\|supported on V5 fs" \
+ && export XFS_COPY_PROG="$XFS_COPY_PROG -d"
+ rm -f /tmp/$$.img
fi
}
echo /sys/dev/block/$_maj:$_min
}
-get_block_size()
+# Get the minimum block size of a file. Usually this is the
+# minimum fs block size, but some filesystems (ocfs2) do block
+# mappings in larger units.
+_get_file_block_size()
+{
+ if [ -z $1 ] || [ ! -d $1 ]; then
+ echo "Missing mount point argument for _get_file_block_size"
+ exit 1
+ fi
+ if [ "$FSTYP" = "ocfs2" ]; then
+ stat -c '%o' $1
+ else
+ _get_block_size $1
+ fi
+}
+
+# Get the minimum block size of an fs.
+_get_block_size()
{
if [ -z $1 ] || [ ! -d $1 ]; then
- echo "Missing mount point argument for get_block_size"
+ echo "Missing mount point argument for _get_block_size"
exit 1
fi
- echo `stat -f -c %S $1`
+ stat -f -c %S $1
}
get_page_size()
"$@" 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
fi
}
+_require_statx()
+{
+ $here/src/stat_test --check-statx ||
+ _notrun "This test requires the statx system call"
+}
+
# Write "content" into /sys/fs/$FSTYP/$DEV/$ATTR
#
# All arguments are necessary, and in this order:
cat /sys/fs/${FSTYP}/${dname}/${attr}
}
-
-# Reset all xfs error handling attributes, set them to original
-# status.
-#
-# Only one argument, and it's mandatory:
-# - dev: device name, e.g. $SCRATCH_DEV
-#
-# Note: this function only works for XFS
-_reset_xfs_sysfs_error_handling()
-{
- local dev=$1
-
- if [ ! -b "$dev" -o "$FSTYP" != "xfs" ];then
- _fail "Usage: reset_xfs_sysfs_error_handling <device>"
- fi
-
- _set_fs_sysfs_attr $dev error/fail_at_unmount 1
- echo -n "error/fail_at_unmount="
- _get_fs_sysfs_attr $dev error/fail_at_unmount
-
- # Make sure all will be configured to retry forever by default, except
- # for ENODEV, which is an unrecoverable error, so it will be configured
- # to not retry on error by default.
- for e in default EIO ENOSPC; do
- _set_fs_sysfs_attr $dev \
- error/metadata/${e}/max_retries -1
- echo -n "error/metadata/${e}/max_retries="
- _get_fs_sysfs_attr $dev error/metadata/${e}/max_retries
-
- _set_fs_sysfs_attr $dev \
- error/metadata/${e}/retry_timeout_seconds 0
- echo -n "error/metadata/${e}/retry_timeout_seconds="
- _get_fs_sysfs_attr $dev \
- error/metadata/${e}/retry_timeout_seconds
- done
-}
-
-# Skip if we are running an older binary without the stricter input checks.
-# Make multiple checks to be sure that there is no regression on the one
-# selected feature check, which would skew the result.
-#
-# At first, make a common function that runs the tests and returns
-# number of failed cases.
-_xfs_mkfs_validation_check()
-{
- local tmpfile=`mktemp`
- local cmd="$MKFS_XFS_PROG -f -N -d file,name=$tmpfile,size=1g"
-
- $cmd -s size=2s >/dev/null 2>&1
- local sum=$?
-
- $cmd -l version=2,su=260k >/dev/null 2>&1
- sum=`expr $sum + $?`
-
- rm -f $tmpfile
- return $sum
-}
-
-# Skip the test if all calls passed - mkfs accepts invalid input
-_require_xfs_mkfs_validation()
+# Generic test for specific filesystem feature.
+# Currently only implemented to test overlayfs features.
+_require_scratch_feature()
{
- _xfs_mkfs_validation_check
- if [ "$?" -eq 0 ]; then
- _notrun "Requires newer mkfs with stricter input checks: the oldest supported version of xfsprogs is 4.7."
- fi
-}
+ local feature=$1
-# The oposite of _require_xfs_mkfs_validation.
-_require_xfs_mkfs_without_validation()
-{
- _xfs_mkfs_validation_check
- if [ "$?" -ne 0 ]; then
- _notrun "Requires older mkfs without strict input checks: the last supported version of xfsprogs is 4.5."
- fi
+ case "$FSTYP" in
+ overlay)
+ _require_scratch_overlay_feature ${feature}
+ ;;
+ *)
+ _fail "Test for feature '${feature}' of ${FSTYP} is not implemented"
+ ;;
+ esac
}
init_rc
projects / xfstests-dev.git / blobdiff