common/rc

   1 ##/bin/bash
   2 # SPDX-License-Identifier: GPL-2.0+
   3 # Copyright (c) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.
   4
   5 . common/config
   6
   7 BC=$(which bc 2> /dev/null) || BC=
   8
   9 # Some tests are not relevant or functional when testing XFS realtime
  10 # subvolumes along with the rtinherit=1 mkfs option.  In these cases,
  11 # this test will opt-out of the test.
  12 _require_no_rtinherit()
  13 {
  14         [ "$FSTYP" = "xfs" ] && echo "$MKFS_OPTIONS" |
  15                 egrep -q "rtinherit([^=]|=1|$)" && \
  16                 _notrun "rtinherit mkfs option is not supported by this test."
  17 }
  18
  19 _require_math()
  20 {
  21         if [ -z "$BC" ]; then
  22                 _notrun "this test requires 'bc' tool for doing math operations"
  23         fi
  24 }
  25
  26 _math()
  27 {
  28         [ $# -le 0 ] && return
  29         LANG=C echo "scale=0; $@" | "$BC" -q 2> /dev/null
  30 }
  31
  32 dd()
  33 {
  34    if [ "$HOSTOS" == "Linux" ]
  35    then
  36         command dd --help 2>&1 | grep noxfer >/dev/null
  37
  38         if [ "$?" -eq 0 ]
  39             then
  40                 command dd status=noxfer $@
  41             else
  42                 command dd $@
  43         fi
  44    else
  45         command dd $@
  46    fi
  47 }
  48
  49 # Prints the md5 checksum of a given file
  50 _md5_checksum()
  51 {
  52         md5sum $1 | cut -d ' ' -f1
  53 }
  54
  55 # Write a byte into a range of a file
  56 _pwrite_byte() {
  57         local pattern="$1"
  58         local offset="$2"
  59         local len="$3"
  60         local file="$4"
  61         local xfs_io_args="$5"
  62
  63         $XFS_IO_PROG $xfs_io_args -f -c "pwrite -S $pattern $offset $len" "$file"
  64 }
  65
  66 # mmap-write a byte into a range of a file
  67 _mwrite_byte() {
  68         local pattern="$1"
  69         local offset="$2"
  70         local len="$3"
  71         local mmap_len="$4"
  72         local file="$5"
  73
  74         $XFS_IO_PROG -f -c "mmap -rw 0 $mmap_len" -c "mwrite -S $pattern $offset $len" "$file"
  75 }
  76
  77 # ls -l w/ selinux sometimes puts a dot at the end:
  78 # -rwxrw-r--. id1 id2 file1
  79 # Also filter out lost+found directory on extN file system if present
  80
  81 _ls_l()
  82 {
  83         ls -l $* | sed "s/\(^[-rwxdlbcpsStT]*\)\. /\1 /" | grep -v 'lost+found'
  84 }
  85
  86 _dump_err()
  87 {
  88     _err_msg="$*"
  89     echo "$_err_msg"
  90 }
  91
  92 _dump_err_cont()
  93 {
  94     _err_msg="$*"
  95     echo -n "$_err_msg"
  96 }
  97
  98 _dump_err2()
  99 {
 100     _err_msg="$*"
 101     >&2 echo "$_err_msg"
 102 }
 103
 104 _log_err()
 105 {
 106     _err_msg="$*"
 107     echo "$_err_msg" | tee -a $seqres.full
 108     echo "(see $seqres.full for details)"
 109 }
 110
 111 # make sure we have a standard umask
 112 umask 022
 113
 114 # check for correct setup and source the $FSTYP specific functions now
 115 case "$FSTYP" in
 116     xfs)
 117          [ "$XFS_LOGPRINT_PROG" = "" ] && _fatal "xfs_logprint not found"
 118          [ "$XFS_REPAIR_PROG" = "" ] && _fatal "xfs_repair not found"
 119          [ "$XFS_DB_PROG" = "" ] && _fatal "xfs_db not found"
 120          [ "$MKFS_XFS_PROG" = "" ] && _fatal "mkfs_xfs not found"
 121          [ "$XFS_INFO_PROG" = "" ] && _fatal "xfs_info not found"
 122
 123          . ./common/xfs
 124          ;;
 125     udf)
 126          [ "$MKFS_UDF_PROG" = "" ] && _fatal "mkfs_udf/mkudffs not found"
 127          ;;
 128     btrfs)
 129          [ "$MKFS_BTRFS_PROG" = "" ] && _fatal "mkfs.btrfs not found"
 130
 131          . ./common/btrfs
 132          ;;
 133     ext4)
 134          [ "$MKFS_EXT4_PROG" = "" ] && _fatal "mkfs.ext4 not found"
 135          ;;
 136     f2fs)
 137          [ "$MKFS_F2FS_PROG" = "" ] && _fatal "mkfs.f2fs not found"
 138          ;;
 139     nfs)
 140          . ./common/nfs
 141          ;;
 142     cifs)
 143          ;;
 144     9p)
 145          ;;
 146     ceph)
 147          ;;
 148     glusterfs)
 149          ;;
 150     overlay)
 151          . ./common/overlay
 152          ;;
 153     reiser4)
 154          [ "$MKFS_REISER4_PROG" = "" ] && _fatal "mkfs.reiser4 not found"
 155          ;;
 156     pvfs2)
 157         ;;
 158     ubifs)
 159         [ "$UBIUPDATEVOL_PROG" = "" ] && _fatal "ubiupdatevol not found"
 160         ;;
 161 esac
 162
 163 if [ ! -z "$REPORT_LIST" ]; then
 164         . ./common/report
 165         _assert_report_list
 166 fi
 167
 168 _mount()
 169 {
 170     $MOUNT_PROG `_mount_ops_filter $*`
 171 }
 172
 173 # Call _mount to do mount operation but also save mountpoint to
 174 # MOUNTED_POINT_STACK. Note that the mount point must be the last parameter
 175 _get_mount()
 176 {
 177         local mnt_point=${!#}
 178         local mnt_dev=${@:(-2):1}
 179         local scratch_opts=""
 180         if [ "$mnt_dev" = "$SCRATCH_DEV" ]; then
 181                 _scratch_options mount
 182                 scratch_opts="$SCRATCH_OPTIONS"
 183         fi
 184
 185         _mount $scratch_opts $*
 186         if [ $? -eq 0 ]; then
 187                 MOUNTED_POINT_STACK="$mnt_point $MOUNTED_POINT_STACK"
 188         else
 189                 return 1
 190         fi
 191 }
 192
 193 # Unmount the last mounted mountpoint in MOUNTED_POINT_STACK
 194 # and return it to caller
 195 _put_mount()
 196 {
 197         local last_mnt=`echo $MOUNTED_POINT_STACK | awk '{print $1}'`
 198
 199         if [ -n "$last_mnt" ]; then
 200                 $UMOUNT_PROG $last_mnt
 201         fi
 202         MOUNTED_POINT_STACK=`echo $MOUNTED_POINT_STACK | cut -d\  -f2-`
 203 }
 204
 205 # Unmount all mountpoints in MOUNTED_POINT_STACK and clear the stack
 206 _clear_mount_stack()
 207 {
 208         if [ -n "$MOUNTED_POINT_STACK" ]; then
 209                 $UMOUNT_PROG $MOUNTED_POINT_STACK
 210         fi
 211         MOUNTED_POINT_STACK=""
 212 }
 213
 214 _scratch_options()
 215 {
 216     local type=$1
 217     local rt_opt=""
 218     local log_opt=""
 219     SCRATCH_OPTIONS=""
 220
 221     if [ "$FSTYP" != "xfs" ]; then
 222         return
 223     fi
 224
 225     case $type in
 226     mkfs)
 227         SCRATCH_OPTIONS="$SCRATCH_OPTIONS -f"
 228         rt_opt="-r"
 229         log_opt="-l"
 230         ;;
 231     mount)
 232         rt_opt="-o"
 233         log_opt="-o"
 234         ;;
 235     esac
 236     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
 237         SCRATCH_OPTIONS="$SCRATCH_OPTIONS ${rt_opt}rtdev=$SCRATCH_RTDEV"
 238     [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 239         SCRATCH_OPTIONS="$SCRATCH_OPTIONS ${log_opt}logdev=$SCRATCH_LOGDEV"
 240 }
 241
 242 _test_options()
 243 {
 244     local type=$1
 245     local rt_opt=""
 246     local log_opt=""
 247     TEST_OPTIONS=""
 248
 249     if [ "$FSTYP" != "xfs" ]; then
 250         return
 251     fi
 252
 253     case $type in
 254     mkfs)
 255         rt_opt="-r"
 256         log_opt="-l"
 257         ;;
 258     mount)
 259         rt_opt="-o"
 260         log_opt="-o"
 261         ;;
 262     esac
 263     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_RTDEV" ] && \
 264         TEST_OPTIONS="$TEST_OPTIONS ${rt_opt}rtdev=$TEST_RTDEV"
 265     [ "$USE_EXTERNAL" = yes -a ! -z "$TEST_LOGDEV" ] && \
 266         TEST_OPTIONS="$TEST_OPTIONS ${log_opt}logdev=$TEST_LOGDEV"
 267 }
 268
 269 _mount_ops_filter()
 270 {
 271     local params="$*"
 272     local last_index=$(( $# - 1 ))
 273
 274     #get mount point to handle dmapi mtpt option correctly
 275     [ $last_index -gt 0 ] && shift $last_index
 276     local fs_escaped=$1
 277
 278     echo $params | sed -e 's/dmapi/dmi/' \
 279         | $PERL_PROG -ne "s#mtpt=[^,|^\n|^\s]*#mtpt=$fs_escaped\1\2#; print;"
 280
 281 }
 282
 283 # Used for mounting non-scratch devices (e.g. loop, dm constructs)
 284 # with the safe set of scratch mount options (e.g. loop image may be
 285 # hosted on $SCRATCH_DEV, so can't use external scratch devices).
 286 _common_dev_mount_options()
 287 {
 288         echo $MOUNT_OPTIONS $SELINUX_MOUNT_OPTIONS $*
 289 }
 290
 291 _scratch_mount_options()
 292 {
 293         _scratch_options mount
 294
 295         echo `_common_dev_mount_options $*` $SCRATCH_OPTIONS \
 296                                         $SCRATCH_DEV $SCRATCH_MNT
 297 }
 298
 299 _supports_filetype()
 300 {
 301         local dir=$1
 302
 303         local fstyp=`$DF_PROG $dir | tail -1 | $AWK_PROG '{print $2}'`
 304         case "$fstyp" in
 305         xfs)
 306                 $XFS_INFO_PROG $dir | grep -q "ftype=1"
 307                 ;;
 308         ext2|ext3|ext4)
 309                 local dev=`$DF_PROG $dir | tail -1 | $AWK_PROG '{print $1}'`
 310                 tune2fs -l $dev | grep -q filetype
 311                 ;;
 312         *)
 313                 local testfile=$dir/$$.ftype
 314                 touch $testfile
 315                 # look for DT_UNKNOWN files
 316                 local unknowns=$($here/src/t_dir_type $dir u | wc -l)
 317                 rm $testfile
 318                 # 0 unknowns is success
 319                 return $unknowns
 320                 ;;
 321         esac
 322 }
 323
 324 # mount scratch device with given options but don't check mount status
 325 _try_scratch_mount()
 326 {
 327         if [ "$FSTYP" == "overlay" ]; then
 328                 _overlay_scratch_mount $*
 329                 return $?
 330         fi
 331         _mount -t $FSTYP `_scratch_mount_options $*`
 332 }
 333
 334 # mount scratch device with given options and _fail if mount fails
 335 _scratch_mount()
 336 {
 337         _try_scratch_mount $* || _fail "mount failed"
 338 }
 339
 340 _scratch_unmount()
 341 {
 342         case "$FSTYP" in
 343         overlay)
 344                 _overlay_scratch_unmount
 345                 ;;
 346         btrfs)
 347                 $UMOUNT_PROG $SCRATCH_MNT
 348                 ;;
 349         *)
 350                 $UMOUNT_PROG $SCRATCH_DEV
 351                 ;;
 352         esac
 353 }
 354
 355 _scratch_remount()
 356 {
 357     local opts="$1"
 358
 359     if test -n "$opts"; then
 360         _try_scratch_mount "-o remount,$opts"
 361     fi
 362 }
 363
 364 _scratch_cycle_mount()
 365 {
 366     local opts="$1"
 367
 368     if [ "$FSTYP" = tmpfs ]; then
 369         _scratch_remount "$opts"
 370         return
 371     fi
 372     if test -n "$opts"; then
 373         opts="-o $opts"
 374     fi
 375     _scratch_unmount
 376     _try_scratch_mount "$opts" || _fail "cycle mount failed"
 377 }
 378
 379 _scratch_shutdown()
 380 {
 381         if [ $FSTYP = "overlay" ]; then
 382                 # In lagacy overlay usage, it may specify directory as
 383                 # SCRATCH_DEV, in this case OVL_BASE_SCRATCH_DEV
 384                 # will be null, so check OVL_BASE_SCRATCH_DEV before
 385                 # running shutdown to avoid shutting down base fs accidently.
 386                 if [ -z $OVL_BASE_SCRATCH_DEV ]; then
 387                         _fail "_scratch_shutdown: call _require_scratch_shutdown first in test"
 388                 else
 389                         $here/src/godown $* $OVL_BASE_SCRATCH_MNT
 390                 fi
 391         else
 392                 $here/src/godown $* $SCRATCH_MNT
 393         fi
 394 }
 395
 396 # Return a file path that can be used to shut down the scratch filesystem.
 397 # Caller should _require_scratch_shutdown before using this.
 398 _scratch_shutdown_handle()
 399 {
 400         if [ $FSTYP = "overlay" ]; then
 401                 echo $OVL_BASE_SCRATCH_MNT
 402         else
 403                 echo $SCRATCH_MNT
 404         fi
 405 }
 406
 407 _test_mount()
 408 {
 409     if [ "$FSTYP" == "overlay" ]; then
 410         _overlay_test_mount $*
 411         return $?
 412     fi
 413     _test_options mount
 414     _mount -t $FSTYP $TEST_OPTIONS $TEST_FS_MOUNT_OPTS $SELINUX_MOUNT_OPTIONS $* $TEST_DEV $TEST_DIR
 415 }
 416
 417 _test_unmount()
 418 {
 419         if [ "$FSTYP" == "overlay" ]; then
 420                 _overlay_test_unmount
 421         else
 422                 $UMOUNT_PROG $TEST_DEV
 423         fi
 424 }
 425
 426 _test_cycle_mount()
 427 {
 428     if [ "$FSTYP" = tmpfs ]; then
 429         return
 430     fi
 431     _test_unmount
 432     _test_mount
 433 }
 434
 435 _scratch_mkfs_options()
 436 {
 437     _scratch_options mkfs
 438     echo $SCRATCH_OPTIONS $MKFS_OPTIONS $* $SCRATCH_DEV
 439 }
 440
 441 # Do the actual mkfs work on SCRATCH_DEV. Firstly mkfs with both MKFS_OPTIONS
 442 # and user specified mkfs options, if that fails (due to conflicts between mkfs
 443 # options), do a second mkfs with only user provided mkfs options.
 444 #
 445 # First param is the mkfs command without any mkfs options and device.
 446 # Second param is the filter to remove unnecessary messages from mkfs stderr.
 447 # Other extra mkfs options are followed.
 448 _scratch_do_mkfs()
 449 {
 450         local mkfs_cmd=$1
 451         local mkfs_filter=$2
 452         shift 2
 453         local extra_mkfs_options=$*
 454         local mkfs_status
 455         local tmp=`mktemp -u`
 456
 457         # save mkfs output in case conflict means we need to run again.
 458         # only the output for the mkfs that applies should be shown
 459         eval "$mkfs_cmd $MKFS_OPTIONS $extra_mkfs_options $SCRATCH_DEV" \
 460                 2>$tmp.mkfserr 1>$tmp.mkfsstd
 461         mkfs_status=$?
 462
 463         # a mkfs failure may be caused by conflicts between $MKFS_OPTIONS and
 464         # $extra_mkfs_options
 465         if [ $mkfs_status -ne 0 -a -n "$extra_mkfs_options" ]; then
 466                 (
 467                 echo -n "** mkfs failed with extra mkfs options "
 468                 echo "added to \"$MKFS_OPTIONS\" by test $seq **"
 469                 echo -n "** attempting to mkfs using only test $seq "
 470                 echo "options: $extra_mkfs_options **"
 471                 ) >> $seqres.full
 472
 473                 # running mkfs again. overwrite previous mkfs output files
 474                 eval "$mkfs_cmd $extra_mkfs_options $SCRATCH_DEV" \
 475                         2>$tmp.mkfserr 1>$tmp.mkfsstd
 476                 mkfs_status=$?
 477         fi
 478
 479         # output stored mkfs output, filtering unnecessary output from stderr
 480         cat $tmp.mkfsstd
 481         eval "cat $tmp.mkfserr | $mkfs_filter" >&2
 482
 483         rm -f $tmp.mkfserr $tmp.mkfsstd
 484         return $mkfs_status
 485 }
 486
 487 _scratch_metadump()
 488 {
 489         local dumpfile=$1
 490         shift
 491         local options=
 492
 493         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 494                 options="-l $SCRATCH_LOGDEV"
 495
 496         xfs_metadump $options "$@" $SCRATCH_DEV $dumpfile
 497 }
 498
 499 _setup_large_ext4_fs()
 500 {
 501         local fs_size=$1
 502         local tmp_dir=/tmp/
 503
 504         [ "$LARGE_SCRATCH_DEV" != yes ] && return 0
 505         [ -z "$SCRATCH_DEV_EMPTY_SPACE" ] && SCRATCH_DEV_EMPTY_SPACE=0
 506         [ $SCRATCH_DEV_EMPTY_SPACE -ge $fs_size ] && return 0
 507
 508         # Default free space in the FS is 50GB, but you can specify more via
 509         # SCRATCH_DEV_EMPTY_SPACE
 510         local space_to_consume=$(($fs_size - 50*1024*1024*1024 - $SCRATCH_DEV_EMPTY_SPACE))
 511
 512         # mount the filesystem and create 16TB - 4KB files until we consume
 513         # all the necessary space.
 514         _try_scratch_mount 2>&1 >$tmp_dir/mnt.err
 515         local status=$?
 516         if [ $status -ne 0 ]; then
 517                 echo "mount failed"
 518                 cat $tmp_dir/mnt.err >&2
 519                 rm -f $tmp_dir/mnt.err
 520                 return $status
 521         fi
 522         rm -f $tmp_dir/mnt.err
 523
 524         local file_size=$((16*1024*1024*1024*1024 - 4096))
 525         local nfiles=0
 526         while [ $space_to_consume -gt $file_size ]; do
 527
 528                 xfs_io -F -f \
 529                         -c "truncate $file_size" \
 530                         -c "falloc -k 0 $file_size" \
 531                         $SCRATCH_MNT/.use_space.$nfiles 2>&1
 532                 status=$?
 533                 if [ $status -ne 0 ]; then
 534                         break;
 535                 fi
 536
 537                 space_to_consume=$(( $space_to_consume - $file_size ))
 538                 nfiles=$(($nfiles + 1))
 539         done
 540
 541         # consume the remaining space.
 542         if [ $space_to_consume -gt 0 ]; then
 543                 xfs_io -F -f \
 544                         -c "truncate $space_to_consume" \
 545                         -c "falloc -k 0 $space_to_consume" \
 546                         $SCRATCH_MNT/.use_space.$nfiles 2>&1
 547                 status=$?
 548         fi
 549         export NUM_SPACE_FILES=$nfiles
 550
 551         _scratch_unmount
 552         if [ $status -ne 0 ]; then
 553                 echo "large file prealloc failed"
 554                 cat $tmp_dir/mnt.err >&2
 555                 return $status
 556         fi
 557         return 0
 558 }
 559
 560 _scratch_mkfs_ext4()
 561 {
 562         local mkfs_cmd="$MKFS_EXT4_PROG -F"
 563         local mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
 564         local tmp=`mktemp -u`
 565         local mkfs_status
 566
 567         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 568             $mkfs_cmd -O journal_dev $MKFS_OPTIONS $SCRATCH_LOGDEV && \
 569             mkfs_cmd="$mkfs_cmd -J device=$SCRATCH_LOGDEV"
 570
 571         _scratch_do_mkfs "$mkfs_cmd" "$mkfs_filter" $* 2>$tmp.mkfserr 1>$tmp.mkfsstd
 572         mkfs_status=$?
 573
 574         if [ $mkfs_status -eq 0 -a "$LARGE_SCRATCH_DEV" = yes ]; then
 575                 # manually parse the mkfs output to get the fs size in bytes
 576                 local fs_size=`cat $tmp.mkfsstd | awk ' \
 577                         /^Block size/ { split($2, a, "="); bs = a[2] ; } \
 578                         / inodes, / { blks = $3 } \
 579                         /reserved for the super user/ { resv = $1 } \
 580                         END { fssize = bs * blks - resv; print fssize }'`
 581
 582                 _setup_large_ext4_fs $fs_size
 583                 mkfs_status=$?
 584         fi
 585
 586         # output mkfs stdout and stderr
 587         cat $tmp.mkfsstd
 588         cat $tmp.mkfserr >&2
 589         rm -f $tmp.mkfserr $tmp.mkfsstd
 590
 591         return $mkfs_status
 592 }
 593
 594 _test_mkfs()
 595 {
 596     case $FSTYP in
 597     nfs*)
 598         # do nothing for nfs
 599         ;;
 600     cifs)
 601         # do nothing for cifs
 602         ;;
 603     9p)
 604         # do nothing for 9p
 605         ;;
 606     virtiofs)
 607         # do nothing for virtiofs
 608         ;;
 609     ceph)
 610         # do nothing for ceph
 611         ;;
 612     glusterfs)
 613         # do nothing for glusterfs
 614         ;;
 615     overlay)
 616         # do nothing for overlay
 617         ;;
 618     pvfs2)
 619         # do nothing for pvfs2
 620         ;;
 621     udf)
 622         $MKFS_UDF_PROG $MKFS_OPTIONS $* $TEST_DEV > /dev/null
 623         ;;
 624     btrfs)
 625         $MKFS_BTRFS_PROG $MKFS_OPTIONS $* $TEST_DEV > /dev/null
 626         ;;
 627     ext2|ext3|ext4)
 628         $MKFS_PROG -t $FSTYP -- -F $MKFS_OPTIONS $* $TEST_DEV
 629         ;;
 630     *)
 631         yes | $MKFS_PROG -t $FSTYP -- $MKFS_OPTIONS $* $TEST_DEV
 632         ;;
 633     esac
 634 }
 635
 636 _mkfs_dev()
 637 {
 638     local tmp=`mktemp -u`
 639     case $FSTYP in
 640     nfs*)
 641         # do nothing for nfs
 642         ;;
 643     9p)
 644         # do nothing for 9p
 645         ;;
 646     virtiofs)
 647         # do nothing for virtiofs
 648         ;;
 649     overlay)
 650         # do nothing for overlay
 651         ;;
 652     pvfs2)
 653         # do nothing for pvfs2
 654         ;;
 655     udf)
 656         $MKFS_UDF_PROG $MKFS_OPTIONS $* 2>$tmp.mkfserr 1>$tmp.mkfsstd
 657         ;;
 658     btrfs)
 659         $MKFS_BTRFS_PROG $MKFS_OPTIONS $* 2>$tmp.mkfserr 1>$tmp.mkfsstd
 660         ;;
 661     ext2|ext3|ext4)
 662         $MKFS_PROG -t $FSTYP -- -F $MKFS_OPTIONS $* \
 663                 2>$tmp.mkfserr 1>$tmp.mkfsstd
 664         ;;
 665     xfs)
 666         $MKFS_PROG -t $FSTYP -- -f $MKFS_OPTIONS $* \
 667                 2>$tmp.mkfserr 1>$tmp.mkfsstd
 668         ;;
 669     *)
 670         yes | $MKFS_PROG -t $FSTYP -- $MKFS_OPTIONS $* \
 671                 2>$tmp.mkfserr 1>$tmp.mkfsstd
 672         ;;
 673     esac
 674
 675     if [ $? -ne 0 ]; then
 676         # output stored mkfs output
 677         cat $tmp.mkfserr >&2
 678         cat $tmp.mkfsstd
 679         status=1
 680         exit 1
 681     fi
 682     rm -f $tmp.mkfserr $tmp.mkfsstd
 683 }
 684
 685 # remove all files in $SCRATCH_MNT, useful when testing on NFS/CIFS
 686 _scratch_cleanup_files()
 687 {
 688         case $FSTYP in
 689         overlay)
 690                 # Avoid rm -rf /* if we messed up
 691                 [ -n "$OVL_BASE_SCRATCH_MNT" ] || return 1
 692                 _overlay_base_scratch_mount || return 1
 693                 rm -rf $OVL_BASE_SCRATCH_MNT/* || return 1
 694                 _overlay_mkdirs $OVL_BASE_SCRATCH_MNT
 695                 # leave base fs mouted so tests can setup lower/upper dir files
 696                 ;;
 697         *)
 698                 [ -n "$SCRATCH_MNT" ] || return 1
 699                 _scratch_mount
 700                 rm -rf $SCRATCH_MNT/*
 701                 _scratch_unmount
 702                 ;;
 703         esac
 704 }
 705
 706 _scratch_mkfs()
 707 {
 708         local mkfs_cmd=""
 709         local mkfs_filter=""
 710         local mkfs_status
 711
 712         case $FSTYP in
 713         nfs*|cifs|ceph|overlay|glusterfs|pvfs2|9p|virtiofs)
 714                 # unable to re-create this fstyp, just remove all files in
 715                 # $SCRATCH_MNT to avoid EEXIST caused by the leftover files
 716                 # created in previous runs
 717                 _scratch_cleanup_files
 718                 return $?
 719                 ;;
 720         tmpfs)
 721                 # do nothing for tmpfs
 722                 return 0
 723                 ;;
 724         ubifs)
 725                 # erase the UBI volume; reformated automatically on next mount
 726                 $UBIUPDATEVOL_PROG ${SCRATCH_DEV} -t
 727                 return 0
 728                 ;;
 729         ext4)
 730                 _scratch_mkfs_ext4 $*
 731                 return $?
 732                 ;;
 733         xfs)
 734                 _scratch_mkfs_xfs $*
 735                 return $?
 736                 ;;
 737         udf)
 738                 mkfs_cmd="$MKFS_UDF_PROG"
 739                 mkfs_filter="cat"
 740                 ;;
 741         btrfs)
 742                 mkfs_cmd="$MKFS_BTRFS_PROG"
 743                 mkfs_filter="cat"
 744                 ;;
 745         ext3)
 746                 mkfs_cmd="$MKFS_PROG -t $FSTYP -- -F"
 747                 mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
 748
 749                 # put journal on separate device?
 750                 [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
 751                 $mkfs_cmd -O journal_dev $MKFS_OPTIONS $SCRATCH_LOGDEV && \
 752                 mkfs_cmd="$mkfs_cmd -J device=$SCRATCH_LOGDEV"
 753                 ;;
 754         ext2)
 755                 mkfs_cmd="$MKFS_PROG -t $FSTYP -- -F"
 756                 mkfs_filter="grep -v -e ^Warning: -e \"^mke2fs \""
 757                 ;;
 758         f2fs)
 759                 mkfs_cmd="$MKFS_F2FS_PROG"
 760                 mkfs_filter="cat"
 761                 ;;
 762         ocfs2)
 763                 mkfs_cmd="yes | $MKFS_PROG -t $FSTYP --"
 764                 mkfs_filter="grep -v -e ^mkfs\.ocfs2"
 765                 ;;
 766         *)
 767                 mkfs_cmd="yes | $MKFS_PROG -t $FSTYP --"
 768                 mkfs_filter="cat"
 769                 ;;
 770         esac
 771
 772         _scratch_do_mkfs "$mkfs_cmd" "$mkfs_filter" $*
 773         return $?
 774 }
 775
 776 # Helper function to get a spare or replace-target device from
 777 # configured SCRATCH_DEV_POLL, must call _scratch_dev_pool_get()
 778 # before _spare_dev_get(). Replace-target-device/Spare-device will
 779 # be assigned to SPARE_DEV.
 780 # As of now only one replace-target-device/spare-device can be
 781 # assigned.
 782 #
 783 # Usage:
 784 #  _scratch_dev_pool_get() <ndevs>
 785 #     _spare_dev_get()
 786 #     :: do stuff
 787 #     _spare_dev_put()
 788 #  _scratch_dev_pool_put()
 789 #
 790 _spare_dev_get()
 791 {
 792         typeset -p SCRATCH_DEV_POOL_SAVED >/dev/null 2>&1
 793         if [ $? -ne 0 ]; then
 794                 _fail "Bug: unset val, must call _scratch_dev_pool_get before _spare_dev_get"
 795         fi
 796
 797         if [ -z "$SCRATCH_DEV_POOL_SAVED" ]; then
 798                 _fail "Bug: str empty, must call _scratch_dev_pool_get before _spare_dev_get"
 799         fi
 800
 801         # Check if the spare is already assigned
 802         typeset -p SPARE_DEV >/dev/null 2>&1
 803         if [ $? -eq 0 ]; then
 804                 if [ ! -z "$SPARE_DEV" ]; then
 805                         _fail "Bug: SPARE_DEV = $SPARE_DEV already assigned"
 806                 fi
 807         fi
 808
 809         local ndevs=`echo $SCRATCH_DEV_POOL| wc -w`
 810         local config_ndevs=`echo $SCRATCH_DEV_POOL_SAVED| wc -w`
 811
 812         if [ $ndevs -eq $config_ndevs ]; then
 813                 _notrun "All devs used no spare"
 814         fi
 815         # Get a dev that is not used
 816         local -a devs="( $SCRATCH_DEV_POOL_SAVED )"
 817         SPARE_DEV=${devs[@]:$ndevs:1}
 818         export SPARE_DEV
 819 }
 820
 821 _spare_dev_put()
 822 {
 823         typeset -p SPARE_DEV >/dev/null 2>&1
 824         if [ $? -ne 0 ]; then
 825                 _fail "Bug: unset val, must call _spare_dev_get before its put"
 826         fi
 827
 828         if [ -z "$SPARE_DEV" ]; then
 829                 _fail "Bug: str empty, must call _spare_dev_get before its put"
 830         fi
 831
 832         export SPARE_DEV=""
 833 }
 834
 835 #
 836 # Generally test cases will have..
 837 #   _require_scratch_dev_pool X
 838 # to make sure it has the enough scratch devices including
 839 # replace-target and spare device. Now arg1 here is the
 840 # required number of scratch devices by a-test-case excluding
 841 # the replace-target and spare device. So this function will
 842 # set SCRATCH_DEV_POOL to the specified number of devices.
 843 #
 844 # Usage:
 845 #  _scratch_dev_pool_get() <ndevs>
 846 #     :: do stuff
 847 #
 848 #  _scratch_dev_pool_put()
 849 #
 850 _scratch_dev_pool_get()
 851 {
 852         if [ $# -ne 1 ]; then
 853                 _fail "Usage: _scratch_dev_pool_get ndevs"
 854         fi
 855
 856         local test_ndevs=$1
 857         local config_ndevs=`echo $SCRATCH_DEV_POOL| wc -w`
 858         local -a devs="( $SCRATCH_DEV_POOL )"
 859
 860         typeset -p config_ndevs >/dev/null 2>&1
 861         if [ $? -ne 0 ]; then
 862                 _fail "Bug: cant find SCRATCH_DEV_POOL ndevs"
 863         fi
 864
 865         if [ $config_ndevs -lt $test_ndevs ]; then
 866                 _notrun "Need at least test requested number of ndevs $test_ndevs"
 867         fi
 868
 869         SCRATCH_DEV_POOL_SAVED=${SCRATCH_DEV_POOL}
 870         export SCRATCH_DEV_POOL_SAVED
 871         SCRATCH_DEV_POOL=${devs[@]:0:$test_ndevs}
 872         export SCRATCH_DEV_POOL
 873 }
 874
 875 _scratch_dev_pool_put()
 876 {
 877         typeset -p SCRATCH_DEV_POOL_SAVED >/dev/null 2>&1
 878         if [ $? -ne 0 ]; then
 879                 _fail "Bug: unset val, must call _scratch_dev_pool_get before _scratch_dev_pool_put"
 880         fi
 881
 882         if [ -z "$SCRATCH_DEV_POOL_SAVED" ]; then
 883                 _fail "Bug: str empty, must call _scratch_dev_pool_get before _scratch_dev_pool_put"
 884         fi
 885
 886         export SCRATCH_DEV_POOL=$SCRATCH_DEV_POOL_SAVED
 887         export SCRATCH_DEV_POOL_SAVED=""
 888 }
 889
 890 _scratch_pool_mkfs()
 891 {
 892     case $FSTYP in
 893     btrfs)
 894         $MKFS_BTRFS_PROG $MKFS_OPTIONS $* $SCRATCH_DEV_POOL > /dev/null
 895         ;;
 896     *)
 897         echo "_scratch_pool_mkfs is not implemented for $FSTYP" 1>&2
 898         ;;
 899     esac
 900 }
 901
 902 # Return the amount of free memory available on the system
 903 _free_memory_bytes()
 904 {
 905     free -b | grep ^Mem | awk '{print $4}'
 906 }
 907
 908 # Create fs of certain size on scratch device
 909 # _scratch_mkfs_sized <size in bytes> [optional blocksize]
 910 _scratch_mkfs_sized()
 911 {
 912     local fssize=$1
 913     local blocksize=$2
 914     local def_blksz
 915
 916     case $FSTYP in
 917     xfs)
 918         def_blksz=`echo $MKFS_OPTIONS|sed -rn 's/.*-b ?size= ?+([0-9]+).*/\1/p'`
 919         ;;
 920     ext2|ext3|ext4|ext4dev|udf|btrfs|reiser4|ocfs2|reiserfs)
 921         def_blksz=`echo $MKFS_OPTIONS| sed -rn 's/.*-b ?+([0-9]+).*/\1/p'`
 922         ;;
 923     jfs)
 924         def_blksz=4096
 925         ;;
 926     esac
 927
 928     [ -n "$def_blksz" ] && blocksize=$def_blksz
 929     [ -z "$blocksize" ] && blocksize=4096
 930
 931
 932     local re='^[0-9]+$'
 933     if ! [[ $fssize =~ $re ]] ; then
 934         _notrun "error: _scratch_mkfs_sized: fs size \"$fssize\" not an integer."
 935     fi
 936     if ! [[ $blocksize =~ $re ]] ; then
 937         _notrun "error: _scratch_mkfs_sized: block size \"$blocksize\" not an integer."
 938     fi
 939
 940     local blocks=`expr $fssize / $blocksize`
 941
 942     if [ "$HOSTOS" == "Linux" -a -b "$SCRATCH_DEV" ]; then
 943         local devsize=`blockdev --getsize64 $SCRATCH_DEV`
 944         [ "$fssize" -gt "$devsize" ] && _notrun "Scratch device too small"
 945     fi
 946
 947     case $FSTYP in
 948     xfs)
 949         # don't override MKFS_OPTIONS that set a block size.
 950         echo $MKFS_OPTIONS |egrep -q "b?size="
 951         if [ $? -eq 0 ]; then
 952                 _scratch_mkfs_xfs -d size=$fssize
 953         else
 954                 _scratch_mkfs_xfs -d size=$fssize -b size=$blocksize
 955         fi
 956         ;;
 957     ext2|ext3|ext4|ext4dev)
 958         ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
 959         ;;
 960     gfs2)
 961         # mkfs.gfs2 doesn't automatically shrink journal files on small
 962         # filesystems, so the journal files may end up being bigger than the
 963         # filesystem, which will cause mkfs.gfs2 to fail.  Until that's fixed,
 964         # shrink the journal size to at most one eigth of the filesystem and at
 965         # least 8 MiB, the minimum size allowed.
 966         local min_journal_size=8
 967         local default_journal_size=128
 968         if (( fssize/8 / (1024*1024) < default_journal_size )); then
 969             local journal_size=$(( fssize/8 / (1024*1024) ))
 970             (( journal_size >= min_journal_size )) || journal_size=$min_journal_size
 971             MKFS_OPTIONS="-J $journal_size $MKFS_OPTIONS"
 972         fi
 973         ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -O -b $blocksize $SCRATCH_DEV $blocks
 974         ;;
 975     ocfs2)
 976         yes | ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
 977         ;;
 978     udf)
 979         $MKFS_UDF_PROG $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
 980         ;;
 981     btrfs)
 982         local mixed_opt=
 983         # minimum size that's needed without the mixed option.
 984         # Ref: btrfs-prog: btrfs_min_dev_size()
 985         # Non mixed mode is also the default option.
 986         (( fssize < $((256 * 1024 *1024)) )) && mixed_opt='--mixed'
 987         $MKFS_BTRFS_PROG $MKFS_OPTIONS $mixed_opt -b $fssize $SCRATCH_DEV
 988         ;;
 989     jfs)
 990         ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS $SCRATCH_DEV $blocks
 991         ;;
 992     reiserfs)
 993         ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV $blocks
 994         ;;
 995     reiser4)
 996         # mkfs.resier4 requires size in KB as input for creating filesystem
 997         $MKFS_REISER4_PROG $MKFS_OPTIONS -y -b $blocksize $SCRATCH_DEV \
 998                            `expr $fssize / 1024`
 999         ;;
1000     f2fs)
1001         # mkfs.f2fs requires # of sectors as an input for the size
1002         local sector_size=`blockdev --getss $SCRATCH_DEV`
1003         $MKFS_F2FS_PROG $MKFS_OPTIONS $SCRATCH_DEV `expr $fssize / $sector_size`
1004         ;;
1005     tmpfs)
1006         local free_mem=`_free_memory_bytes`
1007         if [ "$free_mem" -lt "$fssize" ] ; then
1008            _notrun "Not enough memory ($free_mem) for tmpfs with $fssize bytes"
1009         fi
1010         export MOUNT_OPTIONS="-o size=$fssize $TMPFS_MOUNT_OPTIONS"
1011         ;;
1012     *)
1013         _notrun "Filesystem $FSTYP not supported in _scratch_mkfs_sized"
1014         ;;
1015     esac
1016 }
1017
1018 # Emulate an N-data-disk stripe w/ various stripe units
1019 # _scratch_mkfs_geom <sunit bytes> <swidth multiplier> [optional blocksize]
1020 _scratch_mkfs_geom()
1021 {
1022     local sunit_bytes=$1
1023     local swidth_mult=$2
1024     local blocksize=$3
1025     [ -z "$blocksize" ] && blocksize=4096
1026
1027     local sunit_blocks=$(( sunit_bytes / blocksize ))
1028     local swidth_blocks=$(( sunit_blocks * swidth_mult ))
1029
1030     case $FSTYP in
1031     xfs)
1032         MKFS_OPTIONS+=" -b size=$blocksize, -d su=$sunit_bytes,sw=$swidth_mult"
1033         ;;
1034     ext4|ext4dev)
1035         MKFS_OPTIONS+=" -b $blocksize -E stride=$sunit_blocks,stripe_width=$swidth_blocks"
1036         ;;
1037     *)
1038         _notrun "can't mkfs $FSTYP with geometry"
1039         ;;
1040     esac
1041     _scratch_mkfs
1042 }
1043
1044 # Create fs of certain blocksize on scratch device
1045 # _scratch_mkfs_blocksized blocksize
1046 _scratch_mkfs_blocksized()
1047 {
1048     local blocksize=$1
1049
1050     local re='^[0-9]+$'
1051     if ! [[ $blocksize =~ $re ]] ; then
1052         _notrun "error: _scratch_mkfs_sized: block size \"$blocksize\" not an integer."
1053     fi
1054
1055     case $FSTYP in
1056     xfs)
1057         _scratch_mkfs_xfs $MKFS_OPTIONS -b size=$blocksize
1058         ;;
1059     ext2|ext3|ext4)
1060         ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize $SCRATCH_DEV
1061         ;;
1062     gfs2)
1063         ${MKFS_PROG}.$FSTYP $MKFS_OPTIONS -O -b $blocksize $SCRATCH_DEV
1064         ;;
1065     ocfs2)
1066         yes | ${MKFS_PROG}.$FSTYP -F $MKFS_OPTIONS -b $blocksize -C $blocksize $SCRATCH_DEV
1067         ;;
1068     *)
1069         _notrun "Filesystem $FSTYP not supported in _scratch_mkfs_blocksized"
1070         ;;
1071     esac
1072 }
1073
1074 _scratch_resvblks()
1075 {
1076         case $FSTYP in
1077         xfs)
1078                 xfs_io -x -c "resblks $1" $SCRATCH_MNT
1079                 ;;
1080         *)
1081                 ;;
1082         esac
1083 }
1084
1085
1086 # Repair scratch filesystem.  Returns 0 if the FS is good to go (either no
1087 # errors found or errors were fixed) and nonzero otherwise; also spits out
1088 # a complaint on stderr if fsck didn't tell us that the FS is good to go.
1089 _repair_scratch_fs()
1090 {
1091     case $FSTYP in
1092     xfs)
1093         _scratch_xfs_repair "$@" 2>&1
1094         local res=$?
1095         if [ "$res" -ne 0 ]; then
1096                 echo "xfs_repair returns $res; replay log?"
1097                 _try_scratch_mount
1098                 res=$?
1099                 if [ "$res" -gt 0 ]; then
1100                         echo "mount returns $res; zap log?"
1101                         _scratch_xfs_repair -L 2>&1
1102                         echo "log zap returns $?"
1103                 else
1104                         umount "$SCRATCH_MNT"
1105                 fi
1106                 _scratch_xfs_repair "$@" 2>&1
1107                 res=$?
1108         fi
1109         if [ $res -ne 0 ]; then
1110                 _dump_err2 "xfs_repair failed, err=$res"
1111         fi
1112         return $res
1113         ;;
1114     *)
1115         local dev=$SCRATCH_DEV
1116         local fstyp=$FSTYP
1117         if [ $FSTYP = "overlay" -a -n "$OVL_BASE_SCRATCH_DEV" ]; then
1118                 _repair_overlay_scratch_fs
1119                 # Fall through to repair base fs
1120                 dev=$OVL_BASE_SCRATCH_DEV
1121                 fstyp=$OVL_BASE_FSTYP
1122                 $UMOUNT_PROG $OVL_BASE_SCRATCH_MNT
1123         fi
1124         # Let's hope fsck -y suffices...
1125         fsck -t $fstyp -y $dev 2>&1
1126         local res=$?
1127         case $res in
1128         $FSCK_OK|$FSCK_NONDESTRUCT|$FSCK_REBOOT)
1129                 res=0
1130                 ;;
1131         *)
1132                 _dump_err2 "fsck.$FSTYP failed, err=$res"
1133                 ;;
1134         esac
1135         return $res
1136         ;;
1137     esac
1138 }
1139
1140 _get_pids_by_name()
1141 {
1142     if [ $# -ne 1 ]
1143     then
1144         echo "Usage: _get_pids_by_name process-name" 1>&2
1145         exit 1
1146     fi
1147
1148     # Algorithm ... all ps(1) variants have a time of the form MM:SS or
1149     # HH:MM:SS before the psargs field, use this as the search anchor.
1150     #
1151     # Matches with $1 (process-name) occur if the first psarg is $1
1152     # or ends in /$1 ... the matching uses sed's regular expressions,
1153     # so passing a regex into $1 will work.
1154
1155     ps $PS_ALL_FLAGS \
1156     | sed -n \
1157         -e 's/$/ /' \
1158         -e 's/[         ][      ]*/ /g' \
1159         -e 's/^ //' \
1160         -e 's/^[^ ]* //' \
1161         -e "/[0-9]:[0-9][0-9]  *[^ ]*\/$1 /s/ .*//p" \
1162         -e "/[0-9]:[0-9][0-9]  *$1 /s/ .*//p"
1163 }
1164
1165 #
1166 # _df_device : get an IRIX style df line for a given device
1167 #
1168 #       - returns "" if not mounted
1169 #       - returns fs type in field two (ala IRIX)
1170 #       - joins line together if split by fancy df formatting
1171 #       - strips header etc
1172 #
1173
1174 _df_device()
1175 {
1176     if [ $# -ne 1 ]
1177     then
1178         echo "Usage: _df_device device" 1>&2
1179         exit 1
1180     fi
1181
1182     # Note that we use "==" here so awk doesn't try to interpret an NFS over
1183     # IPv6 server as a regular expression.
1184     $DF_PROG 2>/dev/null | $AWK_PROG -v what=$1 '
1185         ($1==what) && (NF==1) {
1186             v=$1
1187             getline
1188             print v, $0
1189             exit
1190         }
1191         ($1==what) {
1192             print
1193             exit
1194         }
1195     '
1196 }
1197
1198 #
1199 # _df_dir : get an IRIX style df line for device where a directory resides
1200 #
1201 #       - returns fs type in field two (ala IRIX)
1202 #       - joins line together if split by fancy df formatting
1203 #       - strips header etc
1204 #
1205
1206 _df_dir()
1207 {
1208     if [ $# -ne 1 ]
1209     then
1210         echo "Usage: _df_dir device" 1>&2
1211         exit 1
1212     fi
1213
1214     $DF_PROG $1 2>/dev/null | $AWK_PROG -v what=$1 '
1215         NR == 2 && NF==1 {
1216             v=$1
1217             getline
1218             print v, $0;
1219             exit 0
1220         }
1221         NR == 2 {
1222             print;
1223             exit 0
1224         }
1225         {}
1226     '
1227     # otherwise, nada
1228 }
1229
1230 # return percentage used disk space for mounted device
1231
1232 _used()
1233 {
1234     if [ $# -ne 1 ]
1235     then
1236         echo "Usage: _used device" 1>&2
1237         exit 1
1238     fi
1239
1240     _df_device $1 | $AWK_PROG '{ sub("%", "") ; print $6 }'
1241 }
1242
1243 # return the FS type of a mounted device
1244 #
1245 _fs_type()
1246 {
1247     if [ $# -ne 1 ]
1248     then
1249         echo "Usage: _fs_type device" 1>&2
1250         exit 1
1251     fi
1252
1253     #
1254     # The Linux kernel shows NFSv4 filesystems in df output as
1255     # filesystem type nfs4, although we mounted it as nfs earlier.
1256     # Fix the filesystem type up here so that the callers don't
1257     # have to bother with this quirk.
1258     #
1259     _df_device $1 | $AWK_PROG '{ print $2 }' | \
1260         sed -e 's/nfs4/nfs/' -e 's/fuse.glusterfs/glusterfs/'
1261 }
1262
1263 # return the FS mount options of a mounted device
1264 #
1265 # should write a version which just parses the output of mount for IRIX
1266 # compatibility, but since this isn't used at all, at the moment I'll leave
1267 # this for now
1268 #
1269 _fs_options()
1270 {
1271     if [ $# -ne 1 ]
1272     then
1273         echo "Usage: _fs_options device" 1>&2
1274         exit 1
1275     fi
1276
1277     $AWK_PROG -v dev=$1 '
1278         match($1,dev) { print $4 }
1279     ' </proc/mounts
1280 }
1281
1282 # returns device number if a file is a block device
1283 #
1284 _is_block_dev()
1285 {
1286     if [ $# -ne 1 ]
1287     then
1288         echo "Usage: _is_block_dev dev" 1>&2
1289         exit 1
1290     fi
1291
1292     local dev=$1
1293     if [ -L "$dev" ]; then
1294         dev=`readlink -f "$dev"`
1295     fi
1296
1297     if [ -b "$dev" ]; then
1298         $here/src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
1299     fi
1300 }
1301
1302 # returns device number if a file is a character device
1303 #
1304 _is_char_dev()
1305 {
1306         if [ $# -ne 1 ]; then
1307                 echo "Usage: _is_char_dev dev" 1>&2
1308                 exit 1
1309         fi
1310
1311         local dev=$1
1312         if [ -L "$dev" ]; then
1313                 dev=`readlink -f "$dev"`
1314         fi
1315
1316         if [ -c "$dev" ]; then
1317                 $here/src/lstat64 "$dev" | $AWK_PROG '/Device type:/ { print $9 }'
1318         fi
1319 }
1320
1321 # Do a command, log it to $seqres.full, optionally test return status
1322 # and die if command fails. If called with one argument _do executes the
1323 # command, logs it, and returns its exit status. With two arguments _do
1324 # first prints the message passed in the first argument, and then "done"
1325 # or "fail" depending on the return status of the command passed in the
1326 # second argument. If the command fails and the variable _do_die_on_error
1327 # is set to "always" or the two argument form is used and _do_die_on_error
1328 # is set to "message_only" _do will print an error message to
1329 # $seqres.out and exit.
1330
1331 _do()
1332 {
1333     if [ $# -eq 1 ]; then
1334         local cmd=$1
1335     elif [ $# -eq 2 ]; then
1336         local note=$1
1337         local cmd=$2
1338         echo -n "$note... "
1339     else
1340         echo "Usage: _do [note] cmd" 1>&2
1341         status=1; exit
1342     fi
1343
1344     (eval "echo '---' \"$cmd\"") >>$seqres.full
1345     (eval "$cmd") >$tmp._out 2>&1
1346     local ret=$?
1347     cat $tmp._out >>$seqres.full
1348     rm -f $tmp._out
1349     if [ $# -eq 2 ]; then
1350         if [ $ret -eq 0 ]; then
1351             echo "done"
1352         else
1353             echo "fail"
1354         fi
1355     fi
1356     if [ $ret -ne 0  ] \
1357         && [ "$_do_die_on_error" = "always" \
1358             -o \( $# -eq 2 -a "$_do_die_on_error" = "message_only" \) ]
1359     then
1360         [ $# -ne 2 ] && echo
1361         eval "echo \"$cmd\" failed \(returned $ret\): see $seqres.full"
1362         status=1; exit
1363     fi
1364
1365     return $ret
1366 }
1367
1368 # bail out, setting up .notrun file. Need to kill the filesystem check files
1369 # here, otherwise they are set incorrectly for the next test.
1370 #
1371 _notrun()
1372 {
1373     echo "$*" > $seqres.notrun
1374     echo "$seq not run: $*"
1375     rm -f ${RESULT_DIR}/require_test*
1376     rm -f ${RESULT_DIR}/require_scratch*
1377
1378     status=0
1379     exit
1380 }
1381
1382 # just plain bail out
1383 #
1384 _fail()
1385 {
1386     echo "$*" | tee -a $seqres.full
1387     echo "(see $seqres.full for details)"
1388     status=1
1389     exit 1
1390 }
1391
1392 # tests whether $FSTYP is one of the supported filesystems for a test
1393 #
1394 _supported_fs()
1395 {
1396     local f
1397
1398     for f
1399     do
1400         if [ "$f" = "$FSTYP" -o "$f" = "generic" ]
1401         then
1402             return
1403         fi
1404     done
1405
1406     _notrun "not suitable for this filesystem type: $FSTYP"
1407 }
1408
1409
1410 # tests whether $FSTYP is one of the supported OSes for a test
1411 #
1412 _supported_os()
1413 {
1414     local h
1415
1416     for h
1417     do
1418         if [ "$h" = "$HOSTOS" ]
1419         then
1420             return
1421         fi
1422     done
1423
1424     _notrun "not suitable for this OS: $HOSTOS"
1425 }
1426
1427 # check if a FS on a device is mounted
1428 # if so, verify that it is mounted on mount point
1429 # if fstype is given as argument, verify that it is also
1430 # mounted with correct fs type
1431 #
1432 _check_mounted_on()
1433 {
1434         local devname=$1
1435         local dev=$2
1436         local mntname=$3
1437         local mnt=$4
1438         local type=$5
1439
1440         # find $dev as the source, and print result in "$dev $mnt" format
1441         local mount_rec=`findmnt -rncv -S $dev -o SOURCE,TARGET`
1442         [ -n "$mount_rec" ] || return 1 # 1 = not mounted
1443
1444         # if it's mounted, make sure its on $mnt
1445         if [ "$mount_rec" != "$dev $mnt" ]; then
1446                 echo "$devname=$dev is mounted but not on $mntname=$mnt - aborting"
1447                 echo "Already mounted result:"
1448                 echo $mount_rec
1449                 return 2 # 2 = mounted on wrong mnt
1450         fi
1451
1452         if [ -n "$type" -a "`_fs_type $dev`" != "$type" ]; then
1453                 echo "$devname=$dev is mounted but not a type $type filesystem"
1454                 # raw $DF_PROG cannot handle NFS/CIFS/overlay correctly
1455                 _df_device $dev
1456                 return 3 # 3 = mounted as wrong type
1457         fi
1458         return 0 # 0 = mounted as expected
1459 }
1460
1461 # this test needs a scratch partition - check we're ok & unmount it
1462 # No post-test check of the device is required. e.g. the test intentionally
1463 # finishes the test with the filesystem in a corrupt state
1464 _require_scratch_nocheck()
1465 {
1466     case "$FSTYP" in
1467         glusterfs)
1468                 echo $SCRATCH_DEV | egrep -q ":/?" > /dev/null 2>&1
1469                 if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; then
1470                         _notrun "this test requires a valid \$SCRATCH_DEV"
1471                 fi
1472                 if [ ! -d "$SCRATCH_MNT" ]; then
1473                         _notrun "this test requires a valid \$SCRATCH_MNT"
1474                 fi
1475                 ;;
1476         9p|virtiofs)
1477                 if [ -z "$SCRATCH_DEV" ]; then
1478                         _notrun "this test requires a valid \$SCRATCH_DEV"
1479                 fi
1480                 if [ ! -d "$SCRATCH_MNT" ]; then
1481                         _notrun "this test requires a valid \$SCRATCH_MNT"
1482                 fi
1483                 ;;
1484         nfs*|ceph)
1485                 echo $SCRATCH_DEV | grep -q ":/" > /dev/null 2>&1
1486                 if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; then
1487                         _notrun "this test requires a valid \$SCRATCH_DEV"
1488                 fi
1489                 if [ ! -d "$SCRATCH_MNT" ]; then
1490                         _notrun "this test requires a valid \$SCRATCH_MNT"
1491                 fi
1492                 ;;
1493         pvfs2)
1494                 echo $SCRATCH_DEV | grep -q "://" > /dev/null 2>&1
1495                 if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; then
1496                         _notrun "this test requires a valid \$SCRATCH_DEV"
1497                 fi
1498                 if [ ! -d "$SCRATCH_MNT" ]; then
1499                         _notrun "this test requires a valid \$SCRATCH_MNT"
1500                 fi
1501                 ;;
1502         cifs)
1503                 echo $SCRATCH_DEV | grep -q "//" > /dev/null 2>&1
1504                 if [ -z "$SCRATCH_DEV" -o "$?" != "0" ]; then
1505                         _notrun "this test requires a valid \$SCRATCH_DEV"
1506                 fi
1507                 if [ ! -d "$SCRATCH_MNT" ]; then
1508                      _notrun "this test requires a valid \$SCRATCH_MNT"
1509                 fi
1510                 ;;
1511         overlay)
1512                 if [ -z "$OVL_BASE_SCRATCH_MNT" -o ! -d "$OVL_BASE_SCRATCH_MNT" ]; then
1513                         _notrun "this test requires a valid \$OVL_BASE_SCRATCH_MNT as ovl base dir"
1514                 fi
1515                 # if $SCRATCH_MNT is derived from $OVL_BASE_SCRATCH_MNT then
1516                 # don't check $SCRATCH_MNT dir here because base fs may not be mounted
1517                 # and we will create the mount point anyway on _overlay_mount
1518                 if [ "$SCRATCH_MNT" != "$OVL_BASE_SCRATCH_MNT/$OVL_MNT" -a ! -d "$SCRATCH_MNT" ]; then
1519                         _notrun "this test requires a valid \$SCRATCH_MNT"
1520                 fi
1521                 ;;
1522         tmpfs)
1523                 if [ -z "$SCRATCH_DEV" -o ! -d "$SCRATCH_MNT" ];
1524                 then
1525                     _notrun "this test requires a valid \$SCRATCH_MNT and unique $SCRATCH_DEV"
1526                 fi
1527                 ;;
1528         ubifs)
1529                 # ubifs needs an UBI volume. This will be a char device, not a block device.
1530                 if [ ! -c "$SCRATCH_DEV" ]; then
1531                         _notrun "this test requires a valid UBI volume for \$SCRATCH_DEV"
1532                 fi
1533                 if [ ! -d "$SCRATCH_MNT" ]; then
1534                         _notrun "this test requires a valid \$SCRATCH_MNT"
1535                 fi
1536                 ;;
1537         *)
1538                  if [ -z "$SCRATCH_DEV" -o "`_is_block_dev "$SCRATCH_DEV"`" = "" ]
1539                  then
1540                      _notrun "this test requires a valid \$SCRATCH_DEV"
1541                  fi
1542                  if [ "`_is_block_dev "$SCRATCH_DEV"`" = "`_is_block_dev "$TEST_DEV"`" ]
1543                  then
1544                      _notrun "this test requires a valid \$SCRATCH_DEV"
1545                  fi
1546                 if [ ! -d "$SCRATCH_MNT" ]
1547                 then
1548                      _notrun "this test requires a valid \$SCRATCH_MNT"
1549                 fi
1550                  ;;
1551     esac
1552
1553     _check_mounted_on SCRATCH_DEV $SCRATCH_DEV SCRATCH_MNT $SCRATCH_MNT
1554     local err=$?
1555     [ $err -le 1 ] || exit 1
1556     if [ $err -eq 0 ]
1557     then
1558         # if it's mounted, unmount it
1559         if ! _scratch_unmount
1560         then
1561             echo "failed to unmount $SCRATCH_DEV"
1562             exit 1
1563         fi
1564     fi
1565     rm -f ${RESULT_DIR}/require_scratch
1566 }
1567
1568 # we need the scratch device and it should be checked post test.
1569 _require_scratch()
1570 {
1571         _require_scratch_nocheck
1572         touch ${RESULT_DIR}/require_scratch
1573 }
1574
1575 # require a scratch dev of a minimum size (in kb)
1576 _require_scratch_size()
1577 {
1578         [ $# -eq 1 ] || _fail "_require_scratch_size: expected size param"
1579
1580         _require_scratch
1581         local devsize=`_get_device_size $SCRATCH_DEV`
1582         [ $devsize -lt $1 ] && _notrun "scratch dev too small"
1583 }
1584
1585
1586 # this test needs a test partition - check we're ok & mount it
1587 #
1588 _require_test()
1589 {
1590     case "$FSTYP" in
1591         glusterfs)
1592                 echo $TEST_DEV | egrep -q ":/?" > /dev/null 2>&1
1593                 if [ -z "$TEST_DEV" -o "$?" != "0" ]; then
1594                         _notrun "this test requires a valid \$TEST_DEV"
1595                 fi
1596                 if [ ! -d "$TEST_DIR" ]; then
1597                         _notrun "this test requires a valid \$TEST_DIR"
1598                 fi
1599                 ;;
1600         9p|virtiofs)
1601                 if [ -z "$TEST_DEV" ]; then
1602                         _notrun "this test requires a valid \$TEST_DEV"
1603                 fi
1604                 if [ ! -d "$TEST_DIR" ]; then
1605                         _notrun "this test requires a valid \$TEST_DIR"
1606                 fi
1607                 ;;
1608         nfs*|ceph)
1609                 echo $TEST_DEV | grep -q ":/" > /dev/null 2>&1
1610                 if [ -z "$TEST_DEV" -o "$?" != "0" ]; then
1611                         _notrun "this test requires a valid \$TEST_DEV"
1612                 fi
1613                 if [ ! -d "$TEST_DIR" ]; then
1614                         _notrun "this test requires a valid \$TEST_DIR"
1615                 fi
1616                 ;;
1617         cifs)
1618                 echo $TEST_DEV | grep -q "//" > /dev/null 2>&1
1619                 if [ -z "$TEST_DEV" -o "$?" != "0" ]; then
1620                         _notrun "this test requires a valid \$TEST_DEV"
1621                 fi
1622                 if [ ! -d "$TEST_DIR" ]; then
1623                      _notrun "this test requires a valid \$TEST_DIR"
1624                 fi
1625                 ;;
1626         pvfs2)
1627                 echo $TEST_DEV | grep -q "://" > /dev/null 2>&1
1628                 if [ -z "$TEST_DEV" -o "$?" != "0" ]; then
1629                         _notrun "this test requires a valid \$TEST_DIR"
1630                 fi
1631                 if [ ! -d "$TEST_DIR" ]; then
1632                         _notrun "this test requires a valid \$TEST_DIR"
1633                 fi
1634                 ;;
1635         overlay)
1636                 if [ -z "$OVL_BASE_TEST_DIR" -o ! -d "$OVL_BASE_TEST_DIR" ]; then
1637                         _notrun "this test requires a valid \$TEST_DIR as ovl base dir"
1638                 fi
1639                 if [ ! -d "$TEST_DIR" ]; then
1640                         _notrun "this test requires a valid \$TEST_DIR"
1641                 fi
1642                 ;;
1643         tmpfs)
1644                 if [ -z "$TEST_DEV" -o ! -d "$TEST_DIR" ];
1645                 then
1646                     _notrun "this test requires a valid \$TEST_DIR and unique $TEST_DEV"
1647                 fi
1648                 ;;
1649         ubifs)
1650                 # ubifs needs an UBI volume. This will be a char device, not a block device.
1651                 if [ ! -c "$TEST_DEV" ]; then
1652                         _notrun "this test requires a valid UBI volume for \$TEST_DEV"
1653                 fi
1654                 if [ ! -d "$TEST_DIR" ]; then
1655                         _notrun "this test requires a valid \$TEST_DIR"
1656                 fi
1657                 ;;
1658         *)
1659                  if [ -z "$TEST_DEV" ] || [ "`_is_block_dev "$TEST_DEV"`" = "" ]
1660                  then
1661                      _notrun "this test requires a valid \$TEST_DEV"
1662                  fi
1663                  if [ "`_is_block_dev "$SCRATCH_DEV"`" = "`_is_block_dev "$TEST_DEV"`" ]
1664                  then
1665                      _notrun "this test requires a valid \$TEST_DEV"
1666                  fi
1667                 if [ ! -d "$TEST_DIR" ]
1668                 then
1669                      _notrun "this test requires a valid \$TEST_DIR"
1670                 fi
1671                  ;;
1672     esac
1673
1674     _check_mounted_on TEST_DEV $TEST_DEV TEST_DIR $TEST_DIR
1675     local err=$?
1676     [ $err -le 1 ] || exit 1
1677     if [ $err -ne 0 ]
1678     then
1679         if ! _test_mount
1680         then
1681                 echo "!!! failed to mount $TEST_DEV on $TEST_DIR"
1682                 exit 1
1683         fi
1684     fi
1685     touch ${RESULT_DIR}/require_test
1686 }
1687
1688 _has_logdev()
1689 {
1690         local ret=0
1691         [ -z "$SCRATCH_LOGDEV" -o ! -b "$SCRATCH_LOGDEV" ] && ret=1
1692         [ "$USE_EXTERNAL" != yes ] && ret=1
1693
1694         return $ret
1695 }
1696
1697 # this test needs a logdev
1698 #
1699 _require_logdev()
1700 {
1701     [ -z "$SCRATCH_LOGDEV" -o ! -b "$SCRATCH_LOGDEV" ] && \
1702         _notrun "This test requires a valid \$SCRATCH_LOGDEV"
1703     [ "$USE_EXTERNAL" != yes ] && \
1704         _notrun "This test requires USE_EXTERNAL to be enabled"
1705
1706     # ensure its not mounted
1707     $UMOUNT_PROG $SCRATCH_LOGDEV 2>/dev/null
1708 }
1709
1710 # this test requires loopback device support
1711 #
1712 _require_loop()
1713 {
1714     if [ "$HOSTOS" != "Linux" ]
1715     then
1716         _notrun "This test requires linux for loopback device support"
1717     fi
1718
1719     modprobe loop >/dev/null 2>&1
1720     if grep loop /proc/devices >/dev/null 2>&1
1721     then
1722         :
1723     else
1724         _notrun "This test requires loopback device support"
1725     fi
1726 }
1727
1728 # this test requires ext2 filesystem support
1729 #
1730 _require_ext2()
1731 {
1732     if [ "$HOSTOS" != "Linux" ]
1733     then
1734         _notrun "This test requires linux for ext2 filesystem support"
1735     fi
1736
1737     modprobe ext2 >/dev/null 2>&1
1738     if grep ext2 /proc/filesystems >/dev/null 2>&1
1739     then
1740         :
1741     else
1742         _notrun "This test requires ext2 filesystem support"
1743     fi
1744 }
1745
1746 # this test requires tmpfs filesystem support
1747 #
1748 _require_tmpfs()
1749 {
1750         modprobe tmpfs >/dev/null 2>&1
1751         grep -q tmpfs /proc/filesystems ||
1752                 _notrun "this test requires tmpfs support"
1753 }
1754
1755 # this test requires that (large) loopback device files are not in use
1756 #
1757 _require_no_large_scratch_dev()
1758 {
1759     [ "$LARGE_SCRATCH_DEV" = yes ] && \
1760         _notrun "Large filesystem testing in progress, skipped this test"
1761 }
1762
1763 # this test requires that a realtime subvolume is in use, and
1764 # that the kernel supports realtime as well.
1765 #
1766 _require_realtime()
1767 {
1768     [ "$USE_EXTERNAL" = yes ] || \
1769         _notrun "External volumes not in use, skipped this test"
1770     [ "$SCRATCH_RTDEV" = "" ] && \
1771         _notrun "Realtime device required, skipped this test"
1772 }
1773
1774 # This test requires that a realtime subvolume is not in use
1775 #
1776 _require_no_realtime()
1777 {
1778         [ "$USE_EXTERNAL" = "yes" ] && [ -n "$SCRATCH_RTDEV" ] && \
1779                 _notrun "Test not compatible with realtime subvolumes, skipped this test"
1780 }
1781
1782 # this test requires that a specified command (executable) exists
1783 # $1 - command, $2 - name for error message
1784 #
1785 # Note: the command string might have parameters, so strip them before checking
1786 # whether it is executable.
1787 _require_command()
1788 {
1789         if [ $# -eq 2 ]; then
1790                 local name="$2"
1791         elif [ $# -eq 1 ]; then
1792                 local name="$1"
1793         else
1794                 _fail "usage: _require_command <command> [<name>]"
1795         fi
1796
1797         local command=`echo "$1" | awk '{ print $1 }'`
1798         if [ ! -x "$command" ]; then
1799                 _notrun "$name utility required, skipped this test"
1800         fi
1801 }
1802
1803 # this test requires the device to be valid block device
1804 # $1 - device
1805 _require_block_device()
1806 {
1807         if [ -z "$1" ]; then
1808                 echo "Usage: _require_block_device <dev>" 1>&2
1809                 exit 1
1810         fi
1811         if [ "`_is_block_dev "$1"`" == "" ]; then
1812                 _notrun "require $1 to be valid block disk"
1813         fi
1814 }
1815
1816 # this test requires a path to refere to a local block or character device
1817 # $1 - device
1818 _require_local_device()
1819 {
1820         if [ -z "$1" ]; then
1821                 echo "Usage: _require_local_device <dev>" 1>&2
1822                 exit 1
1823         fi
1824         if [ "`_is_block_dev "$1"`" != "" ]; then
1825                 return 0
1826         fi
1827         if [ "`_is_char_dev "$1"`" != "" ]; then
1828                 return 0
1829         fi
1830         _notrun "require $1 to be local device"
1831 }
1832
1833 # brd based ram disks erase the device when they receive a flush command when no
1834 # active references are present. This causes problems for DM devices sitting on
1835 # top of brd devices as DM doesn't hold active references to the brd device.
1836 _require_sane_bdev_flush()
1837 {
1838         echo $1 | grep -q "^/dev/ram[0-9]\+$"
1839         if [ $? -eq 0 ]; then
1840                 _notrun "This test requires a sane block device flush"
1841         fi
1842 }
1843
1844 # this test requires a specific device mapper target
1845 _require_dm_target()
1846 {
1847         local target=$1
1848
1849         # require SCRATCH_DEV to be a valid block device with sane BLKFLSBUF
1850         # behaviour
1851         _require_block_device $SCRATCH_DEV
1852         _require_sane_bdev_flush $SCRATCH_DEV
1853         _require_command "$DMSETUP_PROG" dmsetup
1854
1855         modprobe dm-$target >/dev/null 2>&1
1856
1857         $DMSETUP_PROG targets 2>&1 | grep -q ^$target
1858         if [ $? -ne 0 ]; then
1859                 _notrun "This test requires dm $target support"
1860         fi
1861 }
1862
1863 # this test requires the ext4 kernel support crc feature on scratch device
1864 #
1865 _require_scratch_ext4_crc()
1866 {
1867         _scratch_mkfs_ext4 >/dev/null 2>&1
1868         dumpe2fs -h $SCRATCH_DEV 2> /dev/null | grep -q metadata_csum || _notrun "metadata_csum not supported by this filesystem"
1869         _try_scratch_mount >/dev/null 2>&1 \
1870            || _notrun "Kernel doesn't support metadata_csum feature"
1871         _scratch_unmount
1872 }
1873
1874 # Check whether the specified feature whether it is supported by
1875 # mkfs.ext4 and the kernel.
1876 _require_scratch_ext4_feature()
1877 {
1878     if [ -z "$1" ]; then
1879         echo "Usage: _require_scratch_ext4_feature feature"
1880         exit 1
1881     fi
1882     $MKFS_EXT4_PROG -F $MKFS_OPTIONS -O "$1" \
1883                     $SCRATCH_DEV 512m >/dev/null 2>&1 \
1884         || _notrun "mkfs.ext4 doesn't support $1 feature"
1885     _try_scratch_mount >/dev/null 2>&1 \
1886         || _notrun "Kernel doesn't support the ext4 feature(s): $1"
1887     _scratch_unmount
1888 }
1889
1890 # this test requires that external log/realtime devices are not in use
1891 #
1892 _require_nonexternal()
1893 {
1894     [ "$USE_EXTERNAL" = yes ] && \
1895         _notrun "External device testing in progress, skipped this test"
1896 }
1897
1898 # this test requires that the kernel supports asynchronous I/O
1899 _require_aio()
1900 {
1901         $here/src/feature -A
1902         case $? in
1903         0)
1904                 ;;
1905         1)
1906                 _notrun "kernel does not support asynchronous I/O"
1907                 ;;
1908         *)
1909                 _fail "unexpected error testing for asynchronous I/O support"
1910                 ;;
1911         esac
1912 }
1913
1914 # this test requires that a (specified) aio-dio executable exists
1915 # and that the kernel supports asynchronous I/O.
1916 # $1 - command (optional)
1917 #
1918 _require_aiodio()
1919 {
1920     if [ -z "$1" ]
1921     then
1922         AIO_TEST=$here/src/aio-dio-regress/aiodio_sparse2
1923         [ -x $AIO_TEST ] || _notrun "aio-dio utilities required"
1924     else
1925         AIO_TEST=$here/src/aio-dio-regress/$1
1926         [ -x $AIO_TEST ] || _notrun "$AIO_TEST not built"
1927     fi
1928     _require_aio
1929     _require_odirect
1930 }
1931
1932 # this test requires that a test program exists under src/
1933 # $1 - command (require)
1934 #
1935 _require_test_program()
1936 {
1937     local prog=$here/src/$1
1938     [ -x $prog ] || _notrun "$prog not built"
1939 }
1940
1941 # run an aio-dio program
1942 # $1 - command
1943 _run_aiodio()
1944 {
1945     if [ -z "$1" ]
1946     then
1947         echo "usage: _run_aiodio command_name" 2>&1
1948         status=1; exit 1
1949     fi
1950
1951     _require_aiodio $1
1952
1953     local testtemp=$TEST_DIR/aio-testfile
1954     rm -f $testtemp
1955     $AIO_TEST $testtemp 2>&1
1956     status=$?
1957     rm -f $testtemp
1958
1959     return $status
1960 }
1961
1962 _require_timestamp_range()
1963 {
1964         local device=${1:-$TEST_DEV}
1965
1966         local tsmin tsmax
1967         read tsmin tsmax <<<$(_filesystem_timestamp_range $device)
1968         if [ $tsmin -eq -1 -a $tsmax -eq -1 ]; then
1969                 _notrun "filesystem $FSTYP timestamp bounds are unknown"
1970         fi
1971 }
1972
1973 _filesystem_timestamp_range()
1974 {
1975         local device=${1:-$TEST_DEV}
1976         u32max=$(((1<<32)-1))
1977         s32min=-$((1<<31))
1978         s32max=$(((1<<31)-1))
1979         s64max=$(((1<<63)-1))
1980         s64min=$((1<<63))
1981
1982         case $FSTYP in
1983         ext2)
1984                 echo "$s32min $s32max"
1985                 ;;
1986         ext3|ext4)
1987                 if [ $(dumpe2fs -h $device 2>/dev/null | grep "Inode size:" | cut -d: -f2) -gt 128 ]; then
1988                         printf "%d %d\n" $s32min 0x37fffffff
1989                 else
1990                         echo "$s32min $s32max"
1991                 fi
1992                 ;;
1993
1994         jfs)
1995                 echo "0 $u32max"
1996                 ;;
1997         xfs)
1998                 echo "$s32min $s32max"
1999                 ;;
2000         btrfs)
2001                 echo "$s64min $s64max"
2002                 ;;
2003         *)
2004                 echo "-1 -1"
2005                 ;;
2006         esac
2007 }
2008
2009 # indicate whether YP/NIS is active or not
2010 #
2011 _yp_active()
2012 {
2013         local dn
2014         dn=$(domainname 2>/dev/null)
2015         local ypcat=$(type -P ypcat)
2016         local rpcinfo=$(type -P rpcinfo)
2017         test -n "${dn}" -a "${dn}" != "(none)" -a "${dn}" != "localdomain" -a -n "${ypcat}" -a -n "${rpcinfo}" && \
2018                 "${rpcinfo}" -p localhost 2>/dev/null | grep -q ypbind
2019         echo $?
2020 }
2021
2022 # cat the password file
2023 #
2024 _cat_passwd()
2025 {
2026         [ $(_yp_active) -eq 0 ] && ypcat passwd
2027         cat /etc/passwd
2028 }
2029
2030 # cat the group file
2031 #
2032 _cat_group()
2033 {
2034         [ $(_yp_active) -eq 0 ] && ypcat group
2035         cat /etc/group
2036 }
2037
2038 # check for a user on the machine, fsgqa as default
2039 #
2040 _require_user()
2041 {
2042     qa_user=fsgqa
2043     if [ -n "$1" ];then
2044         qa_user=$1
2045     fi
2046     _cat_passwd | grep -q $qa_user
2047     [ "$?" == "0" ] || _notrun "$qa_user user not defined."
2048     echo /bin/true | su $qa_user
2049     [ "$?" == "0" ] || _notrun "$qa_user cannot execute commands."
2050 }
2051
2052 # check for a group on the machine, fsgqa as default
2053 #
2054 _require_group()
2055 {
2056     qa_group=fsgqa
2057     if [ -n "$1" ];then
2058         qa_group=$1
2059     fi
2060     _cat_group | grep -q $qa_group
2061     [ "$?" == "0" ] || _notrun "$qa_group group not defined."
2062 }
2063
2064 _filter_user_do()
2065 {
2066         perl -ne "
2067 s,.*Permission\sdenied.*,Permission denied,;
2068 s,.*no\saccess\sto\stty.*,,;
2069 s,.*no\sjob\scontrol\sin\sthis\sshell.*,,;
2070 s,^\s*$,,;
2071         print;"
2072 }
2073
2074 _user_do()
2075 {
2076         echo $1 | su -s /bin/bash $qa_user 2>&1 | _filter_user_do
2077 }
2078
2079 _require_xfs_io_command()
2080 {
2081         if [ -z "$1" ]
2082         then
2083                 echo "Usage: _require_xfs_io_command command [switch]" 1>&2
2084                 exit 1
2085         fi
2086         local command=$1
2087         shift
2088         local param="$*"
2089         local param_checked=""
2090         local opts=""
2091
2092         local testfile=$TEST_DIR/$$.xfs_io
2093         local testio
2094         case $command in
2095         "chattr")
2096                 if [ -z "$param" ]; then
2097                         param=s
2098                 fi
2099                 # Test xfs_io chattr support AND
2100                 # filesystem FS_IOC_FSSETXATTR support
2101                 testio=`$XFS_IO_PROG -F -f -c "chattr +$param" $testfile 2>&1`
2102                 $XFS_IO_PROG -F -f -r -c "chattr -$param" $testfile 2>&1
2103                 param_checked="+$param"
2104                 ;;
2105         "chproj")
2106                 testio=`$XFS_IO_PROG -F -f -c "chproj 0" $testfile 2>&1`
2107                 ;;
2108         "copy_range")
2109                 local testcopy=$TEST_DIR/$$.copy.xfs_io
2110                 local copy_opts=$testfile
2111                 if [ "$param" == "-f" ]; then
2112                         # source file is the open destination file
2113                         testcopy=$testfile
2114                         copy_opts="0 -d 4k -l 4k"
2115                 fi
2116                 $XFS_IO_PROG -F -f -c "pwrite 0 4k" $testfile > /dev/null 2>&1
2117                 testio=`$XFS_IO_PROG -F -f -c "copy_range $param $copy_opts" $testcopy 2>&1`
2118                 rm -f $testcopy > /dev/null 2>&1
2119                 param_checked="$param"
2120                 ;;
2121         "falloc" )
2122                 testio=`$XFS_IO_PROG -F -f -c "falloc $param 0 1m" $testfile 2>&1`
2123                 param_checked="$param"
2124                 ;;
2125         "fpunch" | "fcollapse" | "zero" | "fzero" | "finsert" | "funshare")
2126                 local blocksize=$(_get_block_size $TEST_DIR)
2127                 testio=`$XFS_IO_PROG -F -f -c "pwrite 0 $((5 * $blocksize))" \
2128                         -c "fsync" -c "$command $blocksize $((2 * $blocksize))" \
2129                         $testfile 2>&1`
2130                 ;;
2131         "fiemap")
2132                 # If 'ranged' is passed as argument then we check to see if fiemap supports
2133                 # ranged query params
2134                 if echo "$param" | grep -q "ranged"; then
2135                         param=$(echo "$param" | sed "s/ranged//")
2136                         $XFS_IO_PROG -c "help fiemap" | grep -q "\[offset \[len\]\]"
2137                         [ $? -eq 0 ] || _notrun "xfs_io $command ranged support is missing"
2138                 fi
2139                 testio=`$XFS_IO_PROG -F -f -c "pwrite 0 20k" -c "fsync" \
2140                         -c "fiemap -v $param" $testfile 2>&1`
2141                 param_checked="$param"
2142                 ;;
2143         "flink")
2144                 local testlink=$TEST_DIR/$$.link.xfs_io
2145                 testio=`$XFS_IO_PROG -F -f -c "flink $testlink" $testfile 2>&1`
2146                 rm -f $testlink > /dev/null 2>&1
2147                 ;;
2148         "-T")
2149                 # Check O_TMPFILE support in xfs_io, kernel and fs
2150                 testio=`$XFS_IO_PROG -T -c quit $TEST_DIR 2>&1`
2151                 echo $testio | egrep -q "invalid option|Is a directory" && \
2152                         _notrun "xfs_io $command support is missing"
2153                 echo $testio | grep -q "Operation not supported" && \
2154                         _notrun "O_TMPFILE is not supported"
2155                 ;;
2156         "fsmap")
2157                 testio=`$XFS_IO_PROG -f -c "fsmap" $testfile 2>&1`
2158                 echo $testio | grep -q "Inappropriate ioctl" && \
2159                         _notrun "xfs_io $command support is missing"
2160                 ;;
2161         "label")
2162                 testio=`$XFS_IO_PROG -c "label" $TEST_DIR 2>&1`
2163                 ;;
2164         "open")
2165                 # -c "open $f" is broken in xfs_io <= 4.8. Along with the fix,
2166                 # a new -C flag was introduced to execute one shot commands.
2167                 # Check for -C flag support as an indication for the bug fix.
2168                 testio=`$XFS_IO_PROG -F -f -C "open $testfile" $testfile 2>&1`
2169                 echo $testio | grep -q "invalid option" && \
2170                         _notrun "xfs_io $command support is missing"
2171                 ;;
2172         "pwrite")
2173                 # -N (RWF_NOWAIT) only works with direct vectored I/O writes
2174                 local pwrite_opts=" "
2175                 if [ "$param" == "-N" ]; then
2176                         opts+=" -d"
2177                         pwrite_opts+="-V 1 -b 4k"
2178                 fi
2179                 testio=`$XFS_IO_PROG -f $opts -c \
2180                         "pwrite $pwrite_opts $param 0 4k" $testfile 2>&1`
2181                 param_checked="$pwrite_opts $param"
2182                 ;;
2183         "scrub"|"repair")
2184                 testio=`$XFS_IO_PROG -x -c "$command probe" $TEST_DIR 2>&1`
2185                 echo $testio | grep -q "Inappropriate ioctl" && \
2186                         _notrun "xfs_io $command support is missing"
2187                 ;;
2188         "utimes" )
2189                 testio=`$XFS_IO_PROG -f -c "utimes" 0 0 0 0 $testfile 2>&1`
2190                 ;;
2191         "syncfs")
2192                 touch $testfile
2193                 testio=`$XFS_IO_PROG -c "syncfs" $testfile 2>&1`
2194                 ;;
2195         *)
2196                 testio=`$XFS_IO_PROG -c "help $command" 2>&1`
2197         esac
2198
2199         rm -f $testfile 2>&1 > /dev/null
2200         echo $testio | grep -q "not found" && \
2201                 _notrun "xfs_io $command $param_checked support is missing"
2202         echo $testio | grep -q "Operation not supported\|Inappropriate ioctl" && \
2203                 _notrun "xfs_io $command $param_checked failed (old kernel/wrong fs?)"
2204         echo $testio | grep -q "Invalid" && \
2205                 _notrun "xfs_io $command $param_checked failed (old kernel/wrong fs/bad args?)"
2206         echo $testio | grep -q "foreign file active" && \
2207                 _notrun "xfs_io $command $param_checked not supported on $FSTYP"
2208         echo $testio | grep -q "Function not implemented" && \
2209                 _notrun "xfs_io $command $param_checked support is missing (missing syscall?)"
2210
2211         [ -n "$param" ] || return
2212
2213         if [ -z "$param_checked" ]; then
2214                 $XFS_IO_PROG -c "help $command" | grep -q "^ $param --" || \
2215                         _notrun "xfs_io $command doesn't support $param"
2216         else
2217                 # xfs_io could result in "command %c not supported" if it was
2218                 # built on kernels not supporting pwritev2() calls
2219                 echo $testio | grep -q "\(invalid option\|not supported\)" && \
2220                         _notrun "xfs_io $command doesn't support $param"
2221         fi
2222 }
2223
2224 # check that kernel and filesystem support direct I/O
2225 _require_odirect()
2226 {
2227         if [ $FSTYP = "ext4" ] ; then
2228                 if echo "$MOUNT_OPTIONS" | grep -q "test_dummy_encryption"; then
2229                         _notrun "ext4 encryption doesn't support O_DIRECT"
2230                 elif echo "$MOUNT_OPTIONS" | grep -q "data=journal"; then
2231                         _notrun "ext4 data journaling doesn't support O_DIRECT"
2232                 fi
2233         fi
2234         local testfile=$TEST_DIR/$$.direct
2235         $XFS_IO_PROG -F -f -d -c "pwrite 0 20k" $testfile > /dev/null 2>&1
2236         if [ $? -ne 0 ]; then
2237                 _notrun "O_DIRECT is not supported"
2238         fi
2239         rm -f $testfile 2>&1 > /dev/null
2240 }
2241
2242 _format_swapfile() {
2243         local fname="$1"
2244         local sz="$2"
2245
2246         rm -f "$fname"
2247         touch "$fname"
2248         chmod 0600 "$fname"
2249         # Swap files must be nocow on Btrfs.
2250         $CHATTR_PROG +C "$fname" > /dev/null 2>&1
2251         _pwrite_byte 0x61 0 "$sz" "$fname" >> $seqres.full
2252         $MKSWAP_PROG "$fname" >> $seqres.full
2253 }
2254
2255 # Check that the filesystem supports swapfiles
2256 _require_scratch_swapfile()
2257 {
2258         _require_scratch
2259         _require_command "$MKSWAP_PROG" "mkswap"
2260
2261         _scratch_mkfs >/dev/null
2262
2263         # With mounting SELinux context(e.g. system_u:object_r:root_t:s0),
2264         # standard mkswap tried to reset the type of default context to
2265         # swapfile_t if it's not swapfile_t, and then it failed and returned
2266         # ENOTSUP expectedly as we don't want to create any SELinux attr on
2267         # purpose.  standard mkswap ignored this relabel error by commit
2268         # d97dc0e of util-linux, but it still reported the error before
2269         # commit d97dc0e.  We mount swapfile context directly to skip the
2270         # reset step.
2271         [ -n "$SELINUX_MOUNT_OPTIONS" ] && export \
2272                 SELINUX_MOUNT_OPTIONS="-o context=system_u:object_r:swapfile_t:s0"
2273
2274         _scratch_mount
2275
2276         # Minimum size for mkswap is 10 pages
2277         _format_swapfile "$SCRATCH_MNT/swap" $(($(get_page_size) * 10))
2278
2279         if ! swapon "$SCRATCH_MNT/swap" >/dev/null 2>&1; then
2280                 _scratch_unmount
2281                 _notrun "swapfiles are not supported"
2282         fi
2283
2284         swapoff "$SCRATCH_MNT/swap" >/dev/null 2>&1
2285         _scratch_unmount
2286 }
2287
2288 # Check that a fs has enough free space (in 1024b blocks)
2289 #
2290 _require_fs_space()
2291 {
2292         local mnt=$1
2293         local blocks=$2 # in units of 1024
2294         local gb=$(( blocks / 1024 / 1024 ))
2295
2296         local free_blocks=`df -kP $mnt | grep -v Filesystem | awk '{print $4}'`
2297         [ $free_blocks -lt $blocks ] && \
2298                 _notrun "This test requires at least ${gb}GB free on $mnt to run"
2299 }
2300
2301 #
2302 # Check if the filesystem supports sparse files.
2303 #
2304 # Unfortunately there is no better way to do this than a manual black list.
2305 #
2306 _require_sparse_files()
2307 {
2308     case $FSTYP in
2309     hfsplus)
2310         _notrun "Sparse files not supported by this filesystem type: $FSTYP"
2311         ;;
2312     *)
2313         ;;
2314     esac
2315 }
2316
2317 _require_debugfs()
2318 {
2319     #boot_params always present in debugfs
2320     [ -d "$DEBUGFS_MNT/boot_params" ] || _notrun "Debugfs not mounted"
2321 }
2322
2323 _require_fail_make_request()
2324 {
2325     [ -f "$DEBUGFS_MNT/fail_make_request/probability" ] \
2326         || _notrun "$DEBUGFS_MNT/fail_make_request \
2327  not found. Seems that CONFIG_FAIL_MAKE_REQUEST kernel config option not enabled"
2328 }
2329
2330 # Disable extent zeroing for ext4 on the given device
2331 _ext4_disable_extent_zeroout()
2332 {
2333         local dev=${1:-$TEST_DEV}
2334         local sdev=`_short_dev $dev`
2335
2336         [ -f /sys/fs/ext4/$sdev/extent_max_zeroout_kb ] && \
2337                 echo 0 >/sys/fs/ext4/$sdev/extent_max_zeroout_kb
2338 }
2339
2340 # The default behavior of SEEK_HOLE is to always return EOF.
2341 # Filesystems that implement non-default behavior return the offset
2342 # of holes with SEEK_HOLE. There is no way to query the filesystem
2343 # of which behavior it is implementing.
2344 # We use this whitelist FSTYP, to set expectation and avoid silent
2345 # regression of filesystem seek hole behavior.
2346 #
2347 # Return 0 for true
2348 _fstyp_has_non_default_seek_data_hole()
2349 {
2350         if [ -z $1 ]; then
2351                 local fstyp=$FSTYP
2352         else
2353                 local fstyp=$1
2354         fi
2355
2356         case "$fstyp" in
2357         btrfs|ext4|xfs|cifs|f2fs|gfs2|ocfs2|tmpfs)
2358                 return 0
2359                 ;;
2360         nfs*)
2361                 # NFSv2 and NFSv3 only support default behavior of SEEK_HOLE,
2362                 # while NFSv4 supports non-default behavior
2363                 local nfsvers=`_df_device $TEST_DEV | $AWK_PROG '{ print $2 }'`
2364                 [ "$nfsvers" = "nfs4" ]
2365                 return $?
2366                 ;;
2367         overlay)
2368                 if [ ! -z $OVL_BASE_FSTYP -a $OVL_BASE_FSTYP != "overlay" ]; then
2369                         _fstyp_has_non_default_seek_data_hole $OVL_BASE_FSTYP
2370                         return $?
2371                 else
2372                         # Assume that base fs has default behavior
2373                         return 1
2374                 fi
2375                 ;;
2376         *)
2377                 # by default fstyp has default SEEK_HOLE behavior;
2378                 # if your fs has non-default behavior, add it to whitelist above!
2379                 return 1
2380                 ;;
2381         esac
2382 }
2383
2384 # Run seek sanity test with predefined expectation for SEEK_DATA/HOLE behavior
2385 _run_seek_sanity_test()
2386 {
2387         local testseekargs
2388         if _fstyp_has_non_default_seek_data_hole; then
2389                 testseekargs+="-f"
2390         fi
2391         $here/src/seek_sanity_test $testseekargs $*
2392 }
2393
2394 # Check if the file system supports seek_data/hole
2395 _require_seek_data_hole()
2396 {
2397         local dev=${1:-$TEST_DEV}
2398         local testfile=$TEST_DIR/$$.seek
2399         local testseek=`$here/src/seek_sanity_test -t $testfile 2>&1`
2400
2401         rm -f $testfile &>/dev/null
2402         echo $testseek | grep -q "Kernel does not support" && \
2403                 _notrun "File system does not support llseek(2) SEEK_DATA/HOLE"
2404         # Disable extent zeroing for ext4 as that change where holes are
2405         # created
2406         if [ "$FSTYP" = "ext4" ]; then
2407                 _ext4_disable_extent_zeroout $dev
2408         fi
2409 }
2410
2411 _require_runas()
2412 {
2413         _require_test_program "runas"
2414 }
2415
2416 _runas()
2417 {
2418         "$here/src/runas" "$@"
2419 }
2420
2421 _require_richacl_prog()
2422 {
2423         _require_command "$GETRICHACL_PROG" getrichacl
2424         _require_command "$SETRICHACL_PROG" setrichacl
2425 }
2426
2427 _require_scratch_richacl_xfs()
2428 {
2429         _scratch_mkfs_xfs_supported -m richacl=1 >/dev/null 2>&1 \
2430                 || _notrun "mkfs.xfs doesn't have richacl feature"
2431         _scratch_mkfs_xfs -m richacl=1 >/dev/null 2>&1
2432         _try_scratch_mount >/dev/null 2>&1 \
2433                 || _notrun "kernel doesn't support richacl feature on $FSTYP"
2434         _scratch_unmount
2435 }
2436
2437 _require_scratch_richacl_ext4()
2438 {
2439         _scratch_mkfs -O richacl >/dev/null 2>&1 \
2440                 || _notrun "can't mkfs $FSTYP with option -O richacl"
2441         _try_scratch_mount >/dev/null 2>&1 \
2442                 || _notrun "kernel doesn't support richacl feature on $FSTYP"
2443         _scratch_unmount
2444 }
2445
2446 _require_scratch_richacl_support()
2447 {
2448         _scratch_mount
2449         $GETFATTR_PROG -n system.richacl >/dev/null 2>&1 \
2450                 || _notrun "this test requires richacl support on \$SCRATCH_DEV"
2451         _scratch_unmount
2452 }
2453
2454 _require_scratch_richacl()
2455 {
2456         case "$FSTYP" in
2457         xfs)    _require_scratch_richacl_xfs
2458                 ;;
2459         ext4)   _require_scratch_richacl_ext4
2460                 ;;
2461         nfs*|cifs|overlay)
2462                 _require_scratch_richacl_support
2463                 ;;
2464         *)      _notrun "this test requires richacl support on \$SCRATCH_DEV"
2465                 ;;
2466         esac
2467 }
2468
2469 _scratch_mkfs_richacl()
2470 {
2471         case "$FSTYP" in
2472         xfs)    _scratch_mkfs_xfs -m richacl=1
2473                 ;;
2474         ext4)   _scratch_mkfs -O richacl
2475                 ;;
2476         nfs*|cifs|overlay)
2477                 _scratch_mkfs
2478                 ;;
2479         esac
2480 }
2481
2482 # check if the given device is mounted, if so, return mount point
2483 _is_dev_mounted()
2484 {
2485         local dev=$1
2486         local fstype=${2:-$FSTYP}
2487
2488         if [ $# -lt 1 ]; then
2489                 echo "Usage: _is_dev_mounted <device> [fstype]" 1>&2
2490                 exit 1
2491         fi
2492
2493         findmnt -rncv -S $dev -t $fstype -o TARGET | head -1
2494 }
2495
2496 # check if the given dir is a mount point, if so, return mount point
2497 _is_dir_mountpoint()
2498 {
2499         local dir=$1
2500         local fstype=${2:-$FSTYP}
2501
2502         if [ $# -lt 1 ]; then
2503                 echo "Uasge: _is_dir_mountpoint <dir> [fstype]" 1>&2
2504                 exit 1
2505         fi
2506
2507         findmnt -rncv -t $fstype -o TARGET $dir | head -1
2508 }
2509
2510 # remount a FS to a new mode (ro or rw)
2511 #
2512 _remount()
2513 {
2514     if [ $# -ne 2 ]
2515     then
2516         echo "Usage: _remount device ro/rw" 1>&2
2517         exit 1
2518     fi
2519     local device=$1
2520     local mode=$2
2521
2522     if ! mount -o remount,$mode $device
2523     then
2524         echo "_remount: failed to remount filesystem on $device as $mode"
2525         exit 1
2526     fi
2527 }
2528
2529 # Run the appropriate repair/check on a filesystem
2530 #
2531 # if the filesystem is mounted, it's either remounted ro before being
2532 # checked or it's unmounted and then remounted
2533 #
2534
2535 # If set, we remount ro instead of unmounting for fsck
2536 USE_REMOUNT=0
2537
2538 _umount_or_remount_ro()
2539 {
2540     if [ $# -ne 1 ]
2541     then
2542         echo "Usage: _umount_or_remount_ro <device>" 1>&2
2543         exit 1
2544     fi
2545
2546     local device=$1
2547     local mountpoint=`_is_dev_mounted $device`
2548
2549     if [ $USE_REMOUNT -eq 0 ]; then
2550         $UMOUNT_PROG $device
2551     else
2552         _remount $device ro
2553     fi
2554     echo "$mountpoint"
2555 }
2556
2557 _mount_or_remount_rw()
2558 {
2559         if [ $# -ne 3 ]; then
2560                 echo "Usage: _mount_or_remount_rw <opts> <dev> <mnt>" 1>&2
2561                 exit 1
2562         fi
2563         local mount_opts=$1
2564         local device=$2
2565         local mountpoint=$3
2566
2567         if [ $USE_REMOUNT -eq 0 ]; then
2568                 if [ "$FSTYP" != "overlay" ]; then
2569                         _mount -t $FSTYP $mount_opts $device $mountpoint
2570                 else
2571                         _overlay_mount $device $mountpoint
2572                 fi
2573                 if [ $? -ne 0 ]; then
2574                         _dump_err "!!! failed to remount $device on $mountpoint"
2575                         return 0 # ok=0
2576                 fi
2577         else
2578                 _remount $device rw
2579         fi
2580
2581         return 1 # ok=1
2582 }
2583
2584 # Check a generic filesystem in no-op mode; this assumes that the
2585 # underlying fsck program accepts "-n" for a no-op (check-only) run,
2586 # and that it will still return an errno for corruption in this mode.
2587 #
2588 # Filesystems which don't support this will need to define their
2589 # own check routine.
2590 #
2591 _check_generic_filesystem()
2592 {
2593     local device=$1
2594
2595     # If type is set, we're mounted
2596     local type=`_fs_type $device`
2597     local ok=1
2598
2599     if [ "$type" = "$FSTYP" ]
2600     then
2601         # mounted ...
2602         local mountpoint=`_umount_or_remount_ro $device`
2603     fi
2604
2605     fsck -t $FSTYP $FSCK_OPTIONS $device >$tmp.fsck 2>&1
2606     if [ $? -ne 0 ]
2607     then
2608         _log_err "_check_generic_filesystem: filesystem on $device is inconsistent"
2609         echo "*** fsck.$FSTYP output ***"       >>$seqres.full
2610         cat $tmp.fsck                           >>$seqres.full
2611         echo "*** end fsck.$FSTYP output"       >>$seqres.full
2612
2613         ok=0
2614     fi
2615     rm -f $tmp.fsck
2616
2617     if [ $ok -eq 0 ]
2618     then
2619         echo "*** mount output ***"             >>$seqres.full
2620         _mount                                  >>$seqres.full
2621         echo "*** end mount output"             >>$seqres.full
2622     elif [ "$type" = "$FSTYP" ]
2623     then
2624         # was mounted ...
2625         _mount_or_remount_rw "$MOUNT_OPTIONS" $device $mountpoint
2626         ok=$?
2627     fi
2628
2629     if [ $ok -eq 0 ]; then
2630         status=1
2631         if [ "$iam" != "check" ]; then
2632                 exit 1
2633         fi
2634         return 1
2635     fi
2636
2637     return 0
2638 }
2639
2640 # Filter the knowen errors the UDF Verifier reports.
2641 _udf_test_known_error_filter()
2642 {
2643         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."
2644
2645 }
2646
2647 _check_udf_filesystem()
2648 {
2649     [ "$DISABLE_UDF_TEST" == "1" ] && return
2650
2651     if [ $# -ne 1 -a $# -ne 2 ]
2652     then
2653         echo "Usage: _check_udf_filesystem device [last_block]" 1>&2
2654         exit 1
2655     fi
2656
2657     if [ ! -x $here/src/udf_test ]
2658     then
2659         echo "udf_test not installed, please download and build the Philips"
2660         echo "UDF Verification Software from http://www.extra.research.philips.com/udf/."
2661         echo "Then copy the udf_test binary to $here/src/."
2662         echo "If you do not wish to run udf_test then set environment variable DISABLE_UDF_TEST"
2663         echo "to 1."
2664         return
2665     fi
2666
2667     local device=$1
2668     local opt_arg=""
2669     if [ $# -eq 2 ]; then
2670         opt_arg="-lastvalidblock $(( $2 - 1 ))"
2671     fi
2672
2673     rm -f $seqres.checkfs
2674     sleep 1 # Due to a problem with time stamps in udf_test
2675     $here/src/udf_test $opt_arg $device | tee $seqres.checkfs | egrep "Error|Warning" | \
2676         _udf_test_known_error_filter | \
2677         egrep -iv "Error count:.*[0-9]+.*total occurrences:.*[0-9]+|Warning count:.*[0-9]+.*total occurrences:.*[0-9]+" && \
2678         echo "Warning UDF Verifier reported errors see $seqres.checkfs." && return 1
2679     return 0
2680 }
2681
2682 _check_test_fs()
2683 {
2684     case $FSTYP in
2685     xfs)
2686         _check_xfs_test_fs
2687         ;;
2688     nfs)
2689         # no way to check consistency for nfs
2690         ;;
2691     cifs)
2692         # no way to check consistency for cifs
2693         ;;
2694     9p)
2695         # no way to check consistency for 9p
2696         ;;
2697     virtiofs)
2698         # no way to check consistency for virtiofs
2699         ;;
2700     ceph)
2701         # no way to check consistency for CephFS
2702         ;;
2703     glusterfs)
2704         # no way to check consistency for GlusterFS
2705         ;;
2706     overlay)
2707         _check_overlay_test_fs
2708         ;;
2709     pvfs2)
2710         ;;
2711     udf)
2712         # do nothing for now
2713         ;;
2714     btrfs)
2715         _check_btrfs_filesystem $TEST_DEV
2716         ;;
2717     tmpfs)
2718         # no way to check consistency for tmpfs
2719         ;;
2720     ubifs)
2721         # there is no fsck program for ubifs yet
2722         ;;
2723     *)
2724         _check_generic_filesystem $TEST_DEV
2725         ;;
2726     esac
2727 }
2728
2729 _check_scratch_fs()
2730 {
2731     local device=$SCRATCH_DEV
2732     [ $# -eq 1 ] && device=$1
2733
2734     case $FSTYP in
2735     xfs)
2736         local scratch_log="none"
2737         local scratch_rt="none"
2738         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_LOGDEV" ] && \
2739             scratch_log="$SCRATCH_LOGDEV"
2740
2741         [ "$USE_EXTERNAL" = yes -a ! -z "$SCRATCH_RTDEV" ] && \
2742             scratch_rt="$SCRATCH_RTDEV"
2743
2744         _check_xfs_filesystem $device $scratch_log $scratch_rt
2745         ;;
2746     udf)
2747         _check_udf_filesystem $device $udf_fsize
2748         ;;
2749     nfs*)
2750         # Don't know how to check an NFS filesystem, yet.
2751         ;;
2752     cifs)
2753         # Don't know how to check a CIFS filesystem, yet.
2754         ;;
2755     9p)
2756         # no way to check consistency for 9p
2757         ;;
2758     virtiofs)
2759         # no way to check consistency for virtiofs
2760         ;;
2761     ceph)
2762         # no way to check consistency for CephFS
2763         ;;
2764     glusterfs)
2765         # no way to check consistency for GlusterFS
2766         ;;
2767     overlay)
2768         _check_overlay_scratch_fs
2769         ;;
2770     pvfs2)
2771         ;;
2772     btrfs)
2773         _check_btrfs_filesystem $device
2774         ;;
2775     tmpfs)
2776         # no way to check consistency for tmpfs
2777         ;;
2778     ubifs)
2779         # there is no fsck program for ubifs yet
2780         ;;
2781     *)
2782         _check_generic_filesystem $device
2783         ;;
2784     esac
2785 }
2786
2787 _full_fstyp_details()
2788 {
2789      [ -z "$FSTYP" ] && FSTYP=xfs
2790      if [ $FSTYP = xfs ]; then
2791         if [ -d /proc/fs/xfs ]; then
2792             if grep -q 'debug 0' /proc/fs/xfs/stat; then
2793                 FSTYP="$FSTYP (non-debug)"
2794             elif grep -q 'debug 1' /proc/fs/xfs/stat; then
2795                 FSTYP="$FSTYP (debug)"
2796             fi
2797         else
2798             if uname -a | grep -qi 'debug'; then
2799                 FSTYP="$FSTYP (debug)"
2800             else
2801                 FSTYP="$FSTYP (non-debug)"
2802             fi
2803         fi
2804      fi
2805      echo $FSTYP
2806 }
2807
2808 _full_platform_details()
2809 {
2810      local os=`uname -s`
2811      local host=`hostname -s`
2812      local kernel=`uname -rv`
2813      local platform=`uname -m`
2814      echo "$os/$platform $host $kernel"
2815 }
2816
2817 _get_os_name()
2818 {
2819         if [ "`uname`" == "Linux" ]; then
2820                 echo 'linux'
2821         else
2822                 echo Unknown operating system: `uname`
2823                 exit
2824         fi
2825 }
2826
2827 _link_out_file_named()
2828 {
2829         local features=$2
2830         local suffix=$(FEATURES="$features" perl -e '
2831                 my %feathash;
2832                 my $feature, $result, $suffix, $opts;
2833
2834                 foreach $feature (split(/,/, $ENV{"FEATURES"})) {
2835                         $feathash{$feature} = 1;
2836                 }
2837                 $result = "default";
2838                 while (<>) {
2839                         my $found = 1;
2840
2841                         chomp;
2842                         ($opts, $suffix) = split(/ *: */);
2843                         foreach my $opt (split(/,/, $opts)) {
2844                                 if (!exists($feathash{$opt})) {
2845                                         $found = 0;
2846                                         last;
2847                                 }
2848                         }
2849                         if ($found == 1) {
2850                                 $result = $suffix;
2851                                 last;
2852                         }
2853                 }
2854                 print $result
2855                 ' <$seqfull.cfg)
2856         rm -f $1
2857         ln -fs $(basename $1).$suffix $1
2858 }
2859
2860 _link_out_file()
2861 {
2862         local features
2863
2864         if [ $# -eq 0 ]; then
2865                 features="$(_get_os_name),$FSTYP"
2866                 if [ -n "$MOUNT_OPTIONS" ]; then
2867                         features=$features,${MOUNT_OPTIONS##"-o "}
2868                 fi
2869         else
2870                 features=$1
2871         fi
2872
2873         _link_out_file_named $seqfull.out "$features"
2874 }
2875
2876 _die()
2877 {
2878         echo $@
2879         exit 1
2880 }
2881
2882 # convert urandom incompressible data to compressible text data
2883 _ddt()
2884 {
2885         od /dev/urandom | dd iflag=fullblock ${*}
2886 }
2887
2888 #takes files, randomdata
2889 _nfiles()
2890 {
2891         local f=0
2892         while [ $f -lt $1 ]
2893         do
2894                 local file=f$f
2895                 echo > $file
2896                 if [ $size -gt 0 ]; then
2897                     if [ "$2" == "false" ]; then
2898                         dd if=/dev/zero of=$file bs=1024 count=$size 2>&1 | _filter_dd
2899                     elif [ "$2" == "comp" ]; then
2900                         _ddt of=$file bs=1024 count=$size 2>&1 | _filter_dd
2901                     else
2902                         dd if=/dev/urandom of=$file bs=1024 count=$size 2>&1 | _filter_dd
2903                     fi
2904                 fi
2905                 let f=$f+1
2906         done
2907 }
2908
2909 # takes dirname, depth, randomdata
2910 _descend()
2911 {
2912         local dirname=$1 depth=$2 randomdata=$3
2913         mkdir $dirname  || die "mkdir $dirname failed"
2914         cd $dirname
2915
2916         _nfiles $files $randomdata          # files for this dir and data type
2917
2918         [ $depth -eq 0 ] && return
2919         local deep=$(( depth - 1 )) # go 1 down
2920
2921         [ $verbose = true ] && echo "descending, depth from leaves = $deep"
2922
2923         local d=0
2924         while [ $d -lt $dirs ]
2925         do
2926                 _descend d$d $deep &
2927                 let d=$d+1
2928                 wait
2929         done
2930 }
2931
2932 # Populate a filesystem with inodes for performance experiments
2933 #
2934 # usage: populate [-v] [-n ndirs] [-f nfiles] [-d depth] [-r root] [-s size] [-x]
2935 #
2936 _populate_fs()
2937 {
2938     local here=`pwd`
2939     local dirs=5          # ndirs in each subdir till leaves
2940     local size=0          # sizeof files in K
2941     local files=100       # num files in _each_ subdir
2942     local depth=2         # depth of tree from root to leaves
2943     local verbose=false
2944     local root=root       # path of initial root of directory tree
2945     local randomdata=false # -x data type urandom, zero or compressible
2946     local c
2947
2948     OPTIND=1
2949     while getopts "d:f:n:r:s:v:x:c" c
2950     do
2951         case $c in
2952         d)      depth=$OPTARG;;
2953         n)      dirs=$OPTARG;;
2954         f)      files=$OPTARG;;
2955         s)      size=$OPTARG;;
2956         v)      verbose=true;;
2957         r)      root=$OPTARG;;
2958         x)      randomdata=true;;
2959         c)      randomdata=comp;;
2960         esac
2961     done
2962
2963     _descend $root $depth $randomdata
2964     wait
2965
2966     cd $here
2967
2968     [ $verbose = true ] && echo done
2969 }
2970
2971 # query whether the given file has the given inode flag set
2972 #
2973 _test_inode_flag()
2974 {
2975         local flag=$1
2976         local file=$2
2977
2978         if $XFS_IO_PROG -r -c 'lsattr -v' "$file" | grep -q "$flag" ; then
2979                 return 0
2980         fi
2981         return 1
2982 }
2983
2984 # query the given files extsize allocator hint in bytes (if any)
2985 #
2986 _test_inode_extsz()
2987 {
2988         local file=$1
2989         local blocks=""
2990
2991         blocks=`$XFS_IO_PROG -r -c 'stat' "$file" | \
2992                 awk '/^xattr.extsize =/ { print $3 }'`
2993         [ -z "$blocks" ] && blocks="0"
2994         echo $blocks
2995 }
2996
2997 # scratch_dev_pool should contain the disks pool for the btrfs raid
2998 _require_scratch_dev_pool()
2999 {
3000         local i
3001         local ndevs
3002
3003         if [ -z "$SCRATCH_DEV_POOL" ]; then
3004                 _notrun "this test requires a valid \$SCRATCH_DEV_POOL"
3005         fi
3006
3007         if [ -z "$1" ]; then
3008                 ndevs=2
3009         else
3010                 ndevs=$1
3011         fi
3012
3013         # btrfs test case needs ndevs or more scratch_dev_pool; other FS not sure
3014         # so fail it
3015         case $FSTYP in
3016         btrfs)
3017                 if [ "`echo $SCRATCH_DEV_POOL|wc -w`" -lt $ndevs ]; then
3018                         _notrun "btrfs and this test needs $ndevs or more disks in SCRATCH_DEV_POOL"
3019                 fi
3020         ;;
3021         *)
3022                 _notrun "dev_pool is not supported by fstype \"$FSTYP\""
3023         ;;
3024         esac
3025
3026         for i in $SCRATCH_DEV_POOL; do
3027                 if [ "`_is_block_dev "$i"`" = "" ]; then
3028                         _notrun "this test requires valid block disk $i"
3029                 fi
3030                 if [ "`_is_block_dev "$i"`" = "`_is_block_dev "$TEST_DEV"`" ]; then
3031                         _notrun "$i is part of TEST_DEV, this test requires unique disks"
3032                 fi
3033                 if _mount | grep -q $i; then
3034                         if ! $UMOUNT_PROG $i; then
3035                             echo "failed to unmount $i - aborting"
3036                             exit 1
3037                         fi
3038                 fi
3039                 # to help better debug when something fails, we remove
3040                 # traces of previous btrfs FS on the dev.
3041                 dd if=/dev/zero of=$i bs=4096 count=100 > /dev/null 2>&1
3042         done
3043 }
3044
3045 # ensure devices in SCRATCH_DEV_POOL are of the same size
3046 # must be called after _require_scratch_dev_pool
3047 _require_scratch_dev_pool_equal_size()
3048 {
3049         local size
3050         local newsize
3051         local dev
3052
3053         # SCRATCH_DEV has been set to the first device in SCRATCH_DEV_POOL
3054         size=`_get_device_size $SCRATCH_DEV`
3055         for dev in $SCRATCH_DEV_POOL; do
3056                 newsize=`_get_device_size $dev`
3057                 if [ $size -ne $newsize ]; then
3058                         _notrun "This test requires devices in SCRATCH_DEV_POOL have the same size"
3059                 fi
3060         done
3061 }
3062
3063
3064 # Check that fio is present, and it is able to execute given jobfile
3065 _require_fio()
3066 {
3067         local job=$1
3068
3069         _require_command "$FIO_PROG" fio
3070         if [ -z "$1" ]; then
3071                 return 1;
3072         fi
3073
3074         $FIO_PROG --warnings-fatal --showcmd $job >> $seqres.full 2>&1
3075         [ $? -eq 0 ] || _notrun "$FIO_PROG too old, see $seqres.full"
3076 }
3077
3078 # Does freeze work on this fs?
3079 _require_freeze()
3080 {
3081         xfs_freeze -f "$TEST_DIR" >/dev/null 2>&1
3082         local result=$?
3083         xfs_freeze -u "$TEST_DIR" >/dev/null 2>&1
3084         [ $result -eq 0 ] || _notrun "$FSTYP does not support freezing"
3085 }
3086
3087 # Does NFS export work on this fs?
3088 _require_exportfs()
3089 {
3090         _require_test_program "open_by_handle"
3091         mkdir -p "$TEST_DIR"/exportfs_test
3092         $here/src/open_by_handle -c "$TEST_DIR"/exportfs_test 2>&1 \
3093                 || _notrun "$FSTYP does not support NFS export"
3094 }
3095
3096
3097 # Does shutdown work on this fs?
3098 _require_scratch_shutdown()
3099 {
3100         [ -x $here/src/godown ] || _notrun "src/godown executable not found"
3101
3102         _scratch_mkfs > /dev/null 2>&1 || _notrun "_scratch_mkfs failed on $SCRATCH_DEV"
3103         _scratch_mount
3104
3105         if [ $FSTYP = "overlay" ]; then
3106                 if [ -z $OVL_BASE_SCRATCH_DEV ]; then
3107                         # In lagacy overlay usage, it may specify directory as
3108                         # SCRATCH_DEV, in this case OVL_BASE_SCRATCH_DEV
3109                         # will be null, so check OVL_BASE_SCRATCH_DEV before
3110                         # running shutdown to avoid shutting down base fs accidently.
3111                         _notrun "This test requires a valid $OVL_BASE_SCRATCH_DEV as ovl base fs"
3112                 else
3113                         $here/src/godown -f $OVL_BASE_SCRATCH_MNT 2>&1 \
3114                         || _notrun "Underlying filesystem does not support shutdown"
3115                 fi
3116         else
3117                 $here/src/godown -f $SCRATCH_MNT 2>&1 \
3118                         || _notrun "$FSTYP does not support shutdown"
3119         fi
3120
3121         _scratch_unmount
3122 }
3123
3124 # Does dax mount option work on this dev/fs?
3125 _require_scratch_dax()
3126 {
3127         _require_scratch
3128         _scratch_mkfs > /dev/null 2>&1
3129         _try_scratch_mount -o dax || \
3130                 _notrun "mount $SCRATCH_DEV with dax failed"
3131         # Check options to be sure. XFS ignores dax option
3132         # and goes on if dev underneath does not support dax.
3133         _fs_options $SCRATCH_DEV | grep -qw "dax" || \
3134                 _notrun "$SCRATCH_DEV $FSTYP does not support -o dax"
3135         _scratch_unmount
3136 }
3137
3138 # Does norecovery support by this fs?
3139 _require_norecovery()
3140 {
3141         _try_scratch_mount -o ro,norecovery || \
3142                 _notrun "$FSTYP does not support norecovery"
3143         _scratch_unmount
3144 }
3145
3146 # Does this filesystem support metadata journaling?
3147 # We exclude ones here that don't; otherwise we assume that it does, so the
3148 # test will run, fail, and motivate someone to update this test for a new
3149 # filesystem.
3150 #
3151 # It's possible that TEST_DEV and SCRATCH_DEV have different features (it'd be
3152 # odd, but possible) so check $TEST_DEV by default, but we can optionall pass
3153 # any dev we want.
3154 _require_metadata_journaling()
3155 {
3156         if [ -z $1 ]; then
3157                 local dev=$TEST_DEV
3158         else
3159                 local dev=$1
3160         fi
3161
3162         case "$FSTYP" in
3163         ext2|vfat|msdos|udf)
3164                 _notrun "$FSTYP does not support metadata journaling"
3165                 ;;
3166         ext4)
3167                 # ext4 could be mkfs'd without a journal...
3168                 _require_dumpe2fs
3169                 $DUMPE2FS_PROG -h $dev 2>&1 | grep -q has_journal || \
3170                         _notrun "$FSTYP on $dev not configured with metadata journaling"
3171                 # ext4 might not load a journal
3172                 _exclude_scratch_mount_option "noload"
3173                 ;;
3174         overlay)
3175                 # metadata journaling check is based on base filesystem configurations
3176                 # and  because -overlay option saves those configurations to OVL_BASE_*,
3177                 # adding restore/override the configurations before/after the check.
3178                 if [ ! -z $OVL_BASE_FSTYP -a $OVL_BASE_FSTYP != "overlay" ]; then
3179                         _overlay_config_restore
3180                         _require_metadata_journaling
3181                         _overlay_config_override
3182                 else
3183                         _notrun "No metadata journaling support for legacy overlay setup"
3184                 fi
3185                 ;;
3186         *)
3187                 # by default we pass; if you need to, add your fs above!
3188                 ;;
3189         esac
3190 }
3191
3192 _count_extents()
3193 {
3194         $XFS_IO_PROG -c "fiemap" $1 | tail -n +2 | grep -v hole | wc -l
3195 }
3196
3197 _count_holes()
3198 {
3199         $XFS_IO_PROG -c "fiemap" $1 | tail -n +2 | grep hole | wc -l
3200 }
3201
3202 _count_attr_extents()
3203 {
3204         $XFS_IO_PROG -c "fiemap -a" $1 | tail -n +2 | grep -v hole | wc -l
3205 }
3206
3207 # arg 1 is dev to remove and is output of the below eg.
3208 # ls -l /sys/class/block/sdd | rev | cut -d "/" -f 3 | rev
3209 _devmgt_remove()
3210 {
3211         local lun=$1
3212         local disk=$2
3213
3214         echo 1 > /sys/class/scsi_device/${lun}/device/delete || _fail "Remove disk failed"
3215
3216         stat $disk > /dev/null 2>&1
3217         while [ $? -eq 0 ]; do
3218                 sleep 1
3219                 stat $disk > /dev/null 2>&1
3220         done
3221 }
3222
3223 # arg 1 is dev to add and is output of the below eg.
3224 # ls -l /sys/class/block/sdd | rev | cut -d "/" -f 3 | rev
3225 _devmgt_add()
3226 {
3227         local h
3228         local tdl
3229         # arg 1 will be in h:t:d:l format now in the h and "t d l" format
3230         h=`echo ${1} | cut -d":" -f 1`
3231         tdl=`echo ${1} | cut -d":" -f 2-|sed 's/:/ /g'`
3232
3233         echo ${tdl} >  /sys/class/scsi_host/host${h}/scan || _fail "Add disk failed"
3234
3235         # ensure the device comes online
3236         local dev_back_oneline=0
3237         local i
3238         for i in `seq 1 10`; do
3239                 if [ -d /sys/class/scsi_device/${1}/device/block ]; then
3240                         local dev=`ls /sys/class/scsi_device/${1}/device/block`
3241                         local j
3242                         for j in `seq 1 10`;
3243                         do
3244                                 stat /dev/$dev > /dev/null 2>&1
3245                                 if [ $? -eq 0 ]; then
3246                                         dev_back_oneline=1
3247                                         break
3248                                 fi
3249                                 sleep 1
3250                         done
3251                         break
3252                 else
3253                         sleep 1
3254                 fi
3255         done
3256         if [ $dev_back_oneline -eq 0 ]; then
3257                 echo "/dev/$dev online failed" >> $seqres.full
3258         else
3259                 echo "/dev/$dev is back online" >> $seqres.full
3260         fi
3261 }
3262
3263 _require_fstrim()
3264 {
3265         if [ -z "$FSTRIM_PROG" ]; then
3266                 _notrun "This test requires fstrim utility."
3267         fi
3268 }
3269
3270 _require_batched_discard()
3271 {
3272         if [ $# -ne 1 ]; then
3273                 echo "Usage: _require_batched_discard mnt_point" 1>&2
3274                 exit 1
3275         fi
3276         _require_fstrim
3277         $FSTRIM_PROG $1 > /dev/null 2>&1 || _notrun "FITRIM not supported on $1"
3278 }
3279
3280 _require_dumpe2fs()
3281 {
3282         if [ -z "$DUMPE2FS_PROG" ]; then
3283                 _notrun "This test requires dumpe2fs utility."
3284         fi
3285 }
3286
3287 _require_ugid_map()
3288 {
3289         if [ ! -e /proc/self/uid_map ]; then
3290                 _notrun "This test requires procfs uid_map support."
3291         fi
3292         if [ ! -e /proc/self/gid_map ]; then
3293                 _notrun "This test requires procfs gid_map support."
3294         fi
3295 }
3296
3297 _require_fssum()
3298 {
3299         FSSUM_PROG=$here/src/fssum
3300         [ -x $FSSUM_PROG ] || _notrun "fssum not built"
3301 }
3302
3303 _require_cloner()
3304 {
3305         CLONER_PROG=$here/src/cloner
3306         [ -x $CLONER_PROG ] || \
3307                 _notrun "cloner binary not present at $CLONER_PROG"
3308 }
3309
3310 # Normalize mount options from global $MOUNT_OPTIONS
3311 # Convert options like "-o opt1,opt2 -oopt3" to
3312 # "opt1 opt2 opt3"
3313 _normalize_mount_options()
3314 {
3315         echo $MOUNT_OPTIONS | sed -n 's/-o\s*\(\S*\)/\1/gp'| sed 's/,/ /g'
3316 }
3317
3318 # skip test if MOUNT_OPTIONS contains the given strings
3319 _exclude_scratch_mount_option()
3320 {
3321         local mnt_opts=$(_normalize_mount_options)
3322
3323         while [ $# -gt 0 ]; do
3324                 if echo $mnt_opts | grep -qw "$1"; then
3325                         _notrun "mount option \"$1\" not allowed in this test"
3326                 fi
3327                 shift
3328         done
3329 }
3330
3331 _require_atime()
3332 {
3333         _exclude_scratch_mount_option "noatime"
3334         case $FSTYP in
3335         nfs|cifs)
3336                 _notrun "atime related mount options have no effect on $FSTYP"
3337                 ;;
3338         esac
3339
3340 }
3341
3342 _require_relatime()
3343 {
3344         _scratch_mkfs > /dev/null 2>&1
3345         _try_scratch_mount -o relatime || \
3346                 _notrun "relatime not supported by the current kernel"
3347         _scratch_unmount
3348 }
3349
3350 _require_userns()
3351 {
3352         [ -x $here/src/nsexec ] || _notrun "src/nsexec executable not found"
3353         $here/src/nsexec -U true 2>/dev/null || _notrun "userns not supported by this kernel"
3354 }
3355
3356 _create_loop_device()
3357 {
3358         local file=$1 dev
3359         dev=`losetup -f --show $file` || _fail "Cannot assign $file to a loop device"
3360         echo $dev
3361 }
3362
3363 _destroy_loop_device()
3364 {
3365         local dev=$1
3366         losetup -d $dev || _fail "Cannot destroy loop device $dev"
3367 }
3368
3369 _scale_fsstress_args()
3370 {
3371     local args=""
3372     while [ $# -gt 0 ]; do
3373         case "$1" in
3374             -n) args="$args $1 $(($2 * $TIME_FACTOR))"; shift ;;
3375             -p) args="$args $1 $(($2 * $LOAD_FACTOR))"; shift ;;
3376             *) args="$args $1" ;;
3377         esac
3378         shift
3379     done
3380     echo $args
3381 }
3382
3383 #
3384 # Return the logical block size if running on a block device,
3385 # else substitute the page size.
3386 #
3387 _min_dio_alignment()
3388 {
3389     local dev=$1
3390
3391     if [ -b "$dev" ]; then
3392         blockdev --getss $dev
3393     else
3394         $here/src/feature -s
3395     fi
3396 }
3397
3398 run_check()
3399 {
3400         echo "# $@" >> $seqres.full 2>&1
3401         "$@" >> $seqres.full 2>&1 || _fail "failed: '$@'"
3402 }
3403
3404 _require_test_symlinks()
3405 {
3406         local target=`mktemp -p $TEST_DIR`
3407         local link=`mktemp -p $TEST_DIR -u`
3408         ln -s `basename $target` $link
3409         if [ "$?" -ne 0 ]; then
3410                 rm -f $target
3411                 _notrun "Require symlinks support"
3412         fi
3413         rm -f $target $link
3414 }
3415
3416 _require_test_fcntl_advisory_locks()
3417 {
3418         [ "$FSTYP" != "cifs" ] && return 0
3419         cat /proc/mounts | grep $TEST_DEV | grep cifs | grep -q "nobrl" && return 0
3420         cat /proc/mounts | grep $TEST_DEV | grep cifs | grep -qE "nounix|forcemand" && \
3421                 _notrun "Require fcntl advisory locks support"
3422 }
3423
3424 _require_ofd_locks()
3425 {
3426         # Give a test run by getlk wrlck on testfile.
3427         # If the running kernel does not support OFD locks,
3428         # EINVAL will be returned.
3429         _require_test_program "t_ofd_locks"
3430         touch $TEST_DIR/ofd_testfile
3431         $here/src/t_ofd_locks -t $TEST_DIR/ofd_testfile > /dev/null 2>&1
3432         [ $? -eq 22 ] && _notrun "Require OFD locks support"
3433 }
3434
3435 _require_test_lsattr()
3436 {
3437         local testio=$(lsattr -d $TEST_DIR 2>&1)
3438         echo $testio | grep -q "Operation not supported" && \
3439                 _notrun "lsattr not supported by test filesystem type: $FSTYP"
3440         echo $testio | grep -q "Inappropriate ioctl for device" && \
3441                 _notrun "lsattr not supported by test filesystem type: $FSTYP"
3442 }
3443
3444 _require_chattr()
3445 {
3446         if [ -z "$1" ]; then
3447                 echo "Usage: _require_chattr <attr>"
3448                 exit 1
3449         fi
3450         local attribute=$1
3451
3452         touch $TEST_DIR/syscalltest
3453         chattr "+$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
3454         local ret=$?
3455         chattr "-$attribute" $TEST_DIR/syscalltest > $TEST_DIR/syscalltest.out 2>&1
3456         if [ "$ret" -ne 0 ]; then
3457                 _notrun "file system doesn't support chattr +$attribute"
3458         fi
3459         cat $TEST_DIR/syscalltest.out >> $seqres.full
3460         rm -f $TEST_DIR/syscalltest.out
3461 }
3462
3463 _get_total_inode()
3464 {
3465         if [ -z "$1" ]; then
3466                 echo "Usage: _get_total_inode <mnt>"
3467                 exit 1
3468         fi
3469         local nr_inode;
3470         nr_inode=`$DF_PROG -i $1 | tail -1 | awk '{print $3}'`
3471         echo $nr_inode
3472 }
3473
3474 _get_used_inode()
3475 {
3476         if [ -z "$1" ]; then
3477                 echo "Usage: _get_used_inode <mnt>"
3478                 exit 1
3479         fi
3480         local nr_inode;
3481         nr_inode=`$DF_PROG -i $1 | tail -1 | awk '{print $4}'`
3482         echo $nr_inode
3483 }
3484
3485 _get_used_inode_percent()
3486 {
3487         if [ -z "$1" ]; then
3488                 echo "Usage: _get_used_inode_percent <mnt>"
3489                 exit 1
3490         fi
3491         local pct_inode;
3492         pct_inode=`$DF_PROG -i $1 | tail -1 | awk '{ print $6 }' | \
3493                    sed -e 's/%//'`
3494         echo $pct_inode
3495 }
3496
3497 _get_free_inode()
3498 {
3499         if [ -z "$1" ]; then
3500                 echo "Usage: _get_free_inode <mnt>"
3501                 exit 1
3502         fi
3503         local nr_inode;
3504         nr_inode=`$DF_PROG -i $1 | tail -1 | awk '{print $5}'`
3505         echo $nr_inode
3506 }
3507
3508 # get the available space in bytes
3509 #
3510 _get_available_space()
3511 {
3512         if [ -z "$1" ]; then
3513                 echo "Usage: _get_available_space <mnt>"
3514                 exit 1
3515         fi
3516         local avail_kb;
3517         avail_kb=`$DF_PROG $1 | tail -n1 | awk '{ print $5 }'`
3518         echo $((avail_kb * 1024))
3519 }
3520
3521 # return device size in kb
3522 _get_device_size()
3523 {
3524         grep `_short_dev $1` /proc/partitions | awk '{print $3}'
3525 }
3526
3527 # Make sure we actually have dmesg checking set up.
3528 _require_check_dmesg()
3529 {
3530         test -w /dev/kmsg || \
3531                 _notrun "Test requires writable /dev/kmsg."
3532 }
3533
3534 # Return the dmesg log since the start of this test.  Caller must ensure that
3535 # /dev/kmsg was writable when the test was started so that we can find the
3536 # beginning of this test's log messages; _require_check_dmesg does this.
3537 _dmesg_since_test_start()
3538 {
3539         # search the dmesg log of last run of $seqnum for possible failures
3540         # use sed \cregexpc address type, since $seqnum contains "/"
3541         dmesg | tac | sed -ne "0,\#run fstests $seqnum at $date_time#p" | \
3542                 tac
3543 }
3544
3545 # check dmesg log for a specific string, subject to the same requirements as
3546 # _dmesg_since_test_start.
3547 _check_dmesg_for()
3548 {
3549         _dmesg_since_test_start | egrep -q "$1"
3550 }
3551
3552 # Default filter for dmesg scanning.
3553 # Ignore lockdep complaining about its own bugginess when scanning dmesg
3554 # output, because we shouldn't be failing filesystem tests on account of
3555 # lockdep.
3556 _check_dmesg_filter()
3557 {
3558         egrep -v -e "BUG: MAX_LOCKDEP_CHAIN_HLOCKS too low" \
3559                 -e "BUG: MAX_STACK_TRACE_ENTRIES too low"
3560 }
3561
3562 # check dmesg log for WARNING/Oops/etc.
3563 _check_dmesg()
3564 {
3565         if [ ! -f ${RESULT_DIR}/check_dmesg ]; then
3566                 return 0
3567         fi
3568         rm -f ${RESULT_DIR}/check_dmesg
3569
3570         # default filter is a simple cat command, caller could provide a
3571         # customized filter and pass the name through the first argument, to
3572         # filter out intentional WARNINGs or Oopses
3573         local filter=${1:-_check_dmesg_filter}
3574
3575         _dmesg_since_test_start | $filter >$seqres.dmesg
3576         egrep -q -e "kernel BUG at" \
3577              -e "WARNING:" \
3578              -e "\bBUG:" \
3579              -e "Oops:" \
3580              -e "possible recursive locking detected" \
3581              -e "Internal error" \
3582              -e "(INFO|ERR): suspicious RCU usage" \
3583              -e "INFO: possible circular locking dependency detected" \
3584              -e "general protection fault:" \
3585              -e "BUG .* remaining" \
3586              -e "UBSAN:" \
3587              $seqres.dmesg
3588         if [ $? -eq 0 ]; then
3589                 _dump_err "_check_dmesg: something found in dmesg (see $seqres.dmesg)"
3590                 return 1
3591         else
3592                 rm -f $seqres.dmesg
3593                 return 0
3594         fi
3595 }
3596
3597 # capture the kmemleak report
3598 _capture_kmemleak()
3599 {
3600         local kern_knob="$DEBUGFS_MNT/kmemleak"
3601         local leak_file="$1"
3602
3603         # Tell the kernel to scan for memory leaks.  Apparently the write
3604         # returns before the scan is complete, so do it twice in the hopes
3605         # that twice is enough to capture all the leaks.
3606         echo "scan" > "$kern_knob"
3607         cat "$kern_knob" > /dev/null
3608         echo "scan" > "$kern_knob"
3609         cat "$kern_knob" > "$leak_file.tmp"
3610         if [ -s "$leak_file.tmp" ]; then
3611                 cat > "$leak_file" << ENDL
3612 EXPERIMENTAL kmemleak reported some memory leaks!  Due to the way kmemleak
3613 works, the leak might be from an earlier test, or something totally unrelated.
3614 ENDL
3615                 cat "$leak_file.tmp" >> "$leak_file"
3616         fi
3617         rm -rf "$leak_file.tmp"
3618         echo "clear" > "$kern_knob"
3619 }
3620
3621 # Figure out if the running kernel supports kmemleak; if it does, clear out
3622 # anything that leaked before we even started testing.  The leak checker only
3623 # needs to be primed like this once per ./check invocation.
3624 _detect_kmemleak()
3625 {
3626         local kern_knob="$DEBUGFS_MNT/kmemleak"
3627         KMEMLEAK_CHECK_FILE="/tmp/check_kmemleak"
3628
3629         # Since kernel v4.19-rc3, the kmemleak knob exists even if kmemleak is
3630         # disabled, but returns EBUSY on write. So instead of relying on
3631         # existance of writable knob file, we use a test file to indicate that
3632         # _check_kmemleak() is enabled only if we actually managed to write to
3633         # the knob file.
3634         rm -f "$KMEMLEAK_CHECK_FILE"
3635
3636         if [ ! -w "$kern_knob" ]; then
3637                 return 0
3638         fi
3639
3640         # Disable the automatic scan so that we can control it completely,
3641         # then dump all the leaks recorded so far.
3642         if echo "scan=off" > "$kern_knob" 2>/dev/null; then
3643                 _capture_kmemleak /dev/null
3644                 touch "$KMEMLEAK_CHECK_FILE"
3645         fi
3646 }
3647
3648 # Kick the kmemleak checker to scan for leaks.  Background leak scan mode is
3649 # not enabled, so we must call the kernel to ask for a scan and deal with the
3650 # results appropriately.  This we do after every test completes, whether or not
3651 # it was successful.
3652 _check_kmemleak()
3653 {
3654         local kern_knob="$DEBUGFS_MNT/kmemleak"
3655         local leak_file="$seqres.kmemleak"
3656
3657         if [ ! -f "$KMEMLEAK_CHECK_FILE" ]; then
3658                 return 0
3659         fi
3660
3661         # Not enabled, so discard any report of leaks found.
3662         if [ "$USE_KMEMLEAK" != "yes" ]; then
3663                 _capture_kmemleak /dev/null
3664                 return 0
3665         fi
3666
3667         # Capture and report any leaks
3668         _capture_kmemleak "$leak_file"
3669         if [ -s "$leak_file" ]; then
3670                 _dump_err "_check_kmemleak: something found in kmemleak (see $leak_file)"
3671                 return 1
3672         else
3673                 rm -f "$leak_file"
3674                 return 0
3675         fi
3676 }
3677
3678 # don't check dmesg log after test
3679 _disable_dmesg_check()
3680 {
3681         rm -f ${RESULT_DIR}/check_dmesg
3682 }
3683
3684 init_rc()
3685 {
3686         # make some further configuration checks here
3687         if [ "$TEST_DEV" = ""  ]
3688         then
3689                 echo "common/rc: Error: \$TEST_DEV is not set"
3690                 exit 1
3691         fi
3692
3693         # if $TEST_DEV is not mounted, mount it now as XFS
3694         if [ -z "`_fs_type $TEST_DEV`" ]
3695         then
3696                 # $TEST_DEV is not mounted
3697                 if ! _test_mount
3698                 then
3699                         echo "common/rc: retrying test device mount with external set"
3700                         [ "$USE_EXTERNAL" != "yes" ] && export USE_EXTERNAL=yes
3701                         if ! _test_mount
3702                         then
3703                                 echo "common/rc: could not mount $TEST_DEV on $TEST_DIR"
3704                                 exit 1
3705                         fi
3706                 fi
3707         fi
3708
3709         # Sanity check that TEST partition is not mounted at another mount point
3710         # or as another fs type
3711         _check_mounted_on TEST_DEV $TEST_DEV TEST_DIR $TEST_DIR $FSTYP || exit 1
3712         if [ -n "$SCRATCH_DEV" ]; then
3713                 # Sanity check that SCRATCH partition is not mounted at another
3714                 # mount point, because it is about to be unmounted and formatted.
3715                 # Another fs type for scratch is fine (bye bye old fs type).
3716                 _check_mounted_on SCRATCH_DEV $SCRATCH_DEV SCRATCH_MNT $SCRATCH_MNT
3717                 [ $? -le 1 ] || exit 1
3718         fi
3719
3720         # Figure out if we need to add -F ("foreign", deprecated) option to xfs_io
3721         $XFS_IO_PROG -c stat $TEST_DIR 2>&1 | grep -q "is not on an XFS filesystem" && \
3722                 export XFS_IO_PROG="$XFS_IO_PROG -F"
3723
3724         # xfs_io -i option starts an idle thread for xfs_io.
3725         # With single threaded process, the file table is not shared
3726         # and file structs are not reference counted.
3727         # Spawning an idle thread can help detecting file struct
3728         # reference leaks, so we want to enable the option whenever
3729         # it is supported.
3730         $XFS_IO_PROG -i -c quit 2>/dev/null && \
3731                 export XFS_IO_PROG="$XFS_IO_PROG -i"
3732
3733         # xfs_copy on v5 filesystems do not require the "-d" option if xfs_db
3734         # can change the UUID on v5 filesystems
3735         if [ "$FSTYP" == "xfs" ]; then
3736                 touch /tmp/$$.img
3737                 $MKFS_XFS_PROG -d file,name=/tmp/$$.img,size=512m >/dev/null 2>&1
3738                 # xfs_db will return 0 even if it can't generate a new uuid, so
3739                 # check the output to make sure if it can change UUID of V5 xfs
3740                 $XFS_DB_PROG -x -c "uuid generate" /tmp/$$.img \
3741                         | grep -q "invalid UUID\|supported on V5 fs" \
3742                         && export XFS_COPY_PROG="$XFS_COPY_PROG -d"
3743                 rm -f /tmp/$$.img
3744         fi
3745 }
3746
3747 # get real device path name by following link
3748 _real_dev()
3749 {
3750         local dev=$1
3751         if [ -b "$dev" ] && [ -L "$dev" ]; then
3752                 dev=`readlink -f "$dev"`
3753         fi
3754         echo $dev
3755 }
3756
3757 # basename of a device
3758 _short_dev()
3759 {
3760         echo `basename $(_real_dev $1)`
3761 }
3762
3763 _sysfs_dev()
3764 {
3765         local dev=`_real_dev $1`
3766         local maj=$(stat -c%t $dev | tr [:lower:] [:upper:])
3767         local min=$(stat -c%T $dev | tr [:lower:] [:upper:])
3768         maj=$(echo "ibase=16; $maj" | bc)
3769         min=$(echo "ibase=16; $min" | bc)
3770         echo /sys/dev/block/$maj:$min
3771 }
3772
3773 # Get the minimum block size of a file.  Usually this is the
3774 # minimum fs block size, but some filesystems (ocfs2) do block
3775 # mappings in larger units.
3776 _get_file_block_size()
3777 {
3778         if [ -z $1 ] || [ ! -d $1 ]; then
3779                 echo "Missing mount point argument for _get_file_block_size"
3780                 exit 1
3781         fi
3782         if [ "$FSTYP" = "ocfs2" ]; then
3783                 stat -c '%o' $1
3784         else
3785                 _get_block_size $1
3786         fi
3787 }
3788
3789 # Get the minimum block size of an fs.
3790 _get_block_size()
3791 {
3792         if [ -z $1 ] || [ ! -d $1 ]; then
3793                 echo "Missing mount point argument for _get_block_size"
3794                 exit 1
3795         fi
3796         stat -f -c %S $1
3797 }
3798
3799 get_page_size()
3800 {
3801         echo $(getconf PAGE_SIZE)
3802 }
3803
3804
3805 run_fsx()
3806 {
3807         echo fsx $@
3808         local args=`echo $@ | sed -e "s/ BSIZE / $bsize /g" -e "s/ PSIZE / $psize /g"`
3809         set -- $here/ltp/fsx $args $FSX_AVOID $TEST_DIR/junk
3810         echo "$@" >>$seqres.full
3811         rm -f $TEST_DIR/junk
3812         "$@" 2>&1 | tee -a $seqres.full >$tmp.fsx
3813         if [ ${PIPESTATUS[0]} -ne 0 ]; then
3814                 cat $tmp.fsx
3815                 rm -f $tmp.fsx
3816                 exit 1
3817         fi
3818         rm -f $tmp.fsx
3819 }
3820
3821 # Test for the existence of a sysfs entry at /sys/fs/$FSTYP/DEV/$ATTR
3822 #
3823 # Only one argument is needed:
3824 #  - attr: path name under /sys/fs/$FSTYP/DEV
3825 #
3826 # Usage example:
3827 #   _require_fs_sysfs error/fail_at_unmount
3828 _require_fs_sysfs()
3829 {
3830         local attr=$1
3831         local dname=$(_short_dev $TEST_DEV)
3832
3833         if [ -z "$attr" -o -z "$dname" ];then
3834                 _fail "Usage: _require_fs_sysfs <sysfs_attr_path>"
3835         fi
3836
3837         if [ ! -e /sys/fs/${FSTYP}/${dname}/${attr} ];then
3838                 _notrun "This test requires /sys/fs/${FSTYP}/${dname}/${attr}"
3839         fi
3840 }
3841
3842 _require_statx()
3843 {
3844         $here/src/stat_test --check-statx ||
3845         _notrun "This test requires the statx system call"
3846 }
3847
3848 # Write "content" into /sys/fs/$FSTYP/$DEV/$ATTR
3849 #
3850 # All arguments are necessary, and in this order:
3851 #  - dev: device name, e.g. $SCRATCH_DEV
3852 #  - attr: path name under /sys/fs/$FSTYP/$dev
3853 #  - content: the content of $attr
3854 #
3855 # Usage example:
3856 #   _set_fs_sysfs_attr /dev/mapper/scratch-dev error/fail_at_unmount 0
3857 _set_fs_sysfs_attr()
3858 {
3859         local dev=$1
3860         shift
3861         local attr=$1
3862         shift
3863         local content="$*"
3864
3865         if [ ! -b "$dev" -o -z "$attr" -o -z "$content" ];then
3866                 _fail "Usage: _set_fs_sysfs_attr <mounted_device> <attr> <content>"
3867         fi
3868
3869         local dname=$(_short_dev $dev)
3870         echo "$content" > /sys/fs/${FSTYP}/${dname}/${attr}
3871 }
3872
3873 # Print the content of /sys/fs/$FSTYP/$DEV/$ATTR
3874 #
3875 # All arguments are necessary, and in this order:
3876 #  - dev: device name, e.g. $SCRATCH_DEV
3877 #  - attr: path name under /sys/fs/$FSTYP/$dev
3878 #
3879 # Usage example:
3880 #   _get_fs_sysfs_attr /dev/mapper/scratch-dev error/fail_at_unmount
3881 _get_fs_sysfs_attr()
3882 {
3883         local dev=$1
3884         local attr=$2
3885
3886         if [ ! -b "$dev" -o -z "$attr" ];then
3887                 _fail "Usage: _get_fs_sysfs_attr <mounted_device> <attr>"
3888         fi
3889
3890         local dname=$(_short_dev $dev)
3891         cat /sys/fs/${FSTYP}/${dname}/${attr}
3892 }
3893
3894 # Generic test for specific filesystem feature.
3895 # Currently only implemented to test overlayfs features.
3896 _require_scratch_feature()
3897 {
3898         local feature=$1
3899
3900         case "$FSTYP" in
3901         overlay)
3902                 _require_scratch_overlay_features ${feature}
3903                 ;;
3904         *)
3905                 _fail "Test for feature '${feature}' of ${FSTYP} is not implemented"
3906                 ;;
3907         esac
3908 }
3909
3910 # Get the maximum size of a file in $TEST_DIR (s_maxbytes).  On ext4 this will
3911 # be UINT32_MAX * block_size, but other filesystems may allow up to LLONG_MAX.
3912 _get_max_file_size()
3913 {
3914         local testfile=$TEST_DIR/maxfilesize.$seq
3915         local l=0
3916         local r=9223372036854775807 # LLONG_MAX
3917
3918         rm -f $testfile
3919         while (( l < r )); do
3920                 # Use _math() to avoid signed integer overflow.
3921                 local m=$(_math "($l + $r + 1) / 2")
3922                 if $XFS_IO_PROG -f -c "truncate $m" $testfile \
3923                         |& grep -q 'File too large'
3924                 then
3925                         r=$(( m - 1 ))
3926                 else
3927                         l=$m
3928                 fi
3929         done
3930         echo $l
3931 }
3932
3933 # get MAX_LFS_FILESIZE
3934 _get_max_lfs_filesize()
3935 {
3936         case "$(getconf LONG_BIT)" in
3937         "32")
3938                 echo $(( ($(getconf PAGE_SIZE) << ($(getconf LONG_BIT) - 1) ) - 1))
3939                 ;;
3940         "64")
3941                 echo 9223372036854775807
3942                 ;;
3943         *)
3944                 _fail "sizeof(long) == $(getconf LONG_BIT)?"
3945                 ;;
3946         esac
3947 }
3948
3949 # The maximum filesystem label length, /not/ including terminating NULL
3950 _label_get_max()
3951 {
3952         case $FSTYP in
3953         xfs)
3954                 echo 12
3955                 ;;
3956         btrfs)
3957                 echo 255
3958                 ;;
3959         f2fs)
3960                 echo 255
3961                 ;;
3962         *)
3963                 _notrun "$FSTYP does not define maximum label length"
3964                 ;;
3965         esac
3966 }
3967
3968 # Helper to check above early in a script
3969 _require_label_get_max()
3970 {
3971         # Just call _label_get_max which will notrun if appropriate
3972         dummy=$(_label_get_max)
3973 }
3974
3975 _dmsetup_remove()
3976 {
3977         $UDEV_SETTLE_PROG >/dev/null 2>&1
3978         $DMSETUP_PROG remove "$@" >>$seqres.full 2>&1
3979         $DMSETUP_PROG mknodes >/dev/null 2>&1
3980 }
3981
3982 _dmsetup_create()
3983 {
3984         $DMSETUP_PROG create "$@" >>$seqres.full 2>&1 || return 1
3985         $DMSETUP_PROG mknodes >/dev/null 2>&1
3986         $UDEV_SETTLE_PROG >/dev/null 2>&1
3987 }
3988
3989 _require_btime()
3990 {
3991         # Note: filesystems are not required to report btime (creation time)
3992         # if the caller doesn't ask for it, so we define STATX_BTIME here and
3993         # pass it in to the statx command.
3994         export STATX_BTIME=0x800
3995         $XFS_IO_PROG -f $TEST_DIR/test_creation_time -c "statx -m $STATX_BTIME -v" \
3996                 | grep btime >>$seqres.full 2>&1 || \
3997                 _notrun "inode creation time not supported by this filesystem"
3998         rm -f $TEST_DIR/test_creation_time
3999 }
4000
4001 _require_scratch_btime()
4002 {
4003         _require_scratch
4004         _scratch_mkfs > /dev/null 2>&1
4005         _scratch_mount
4006
4007         # Note: filesystems are not required to report btime (creation time)
4008         # if the caller doesn't ask for it, so we define STATX_BTIME here and
4009         # pass it in to the statx command.
4010         export STATX_BTIME=0x800
4011         $XFS_IO_PROG -f $SCRATCH_MNT/test_creation_time -c "statx -m $STATX_BTIME -v" \
4012                 | grep btime >>$seqres.full 2>&1 || \
4013                 _notrun "inode creation time not supported by this filesystem"
4014
4015         _scratch_unmount
4016 }
4017
4018 _require_inode_limits()
4019 {
4020         if [ $(_get_free_inode $TEST_DIR) -eq 0 ]; then
4021                 _notrun "$FSTYP does not have a fixed number of inodes available"
4022         fi
4023 }
4024
4025 _require_filefrag_options()
4026 {
4027         _require_command "$FILEFRAG_PROG" filefrag
4028
4029         local options=$1
4030         local file="$TEST_DIR/options_testfile"
4031
4032         echo "XX" > $file
4033         ${FILEFRAG_PROG} -$options $file 2>&1 | grep -q "invalid option" && \
4034                 _notrun "filefrag doesn't support $options option"
4035         rm -f $file
4036 }
4037
4038 _require_fibmap()
4039 {
4040         _require_filefrag_options "B"
4041
4042         local file="$TEST_DIR/fibmap_testfile"
4043
4044         echo "XX" > $file
4045         ${FILEFRAG_PROG} -B $file 2>&1 | grep -q "FIBMAP[[:space:]]*unsupported"
4046         if [ $? -eq 0 ]; then
4047                 _notrun "FIBMAP not supported by this filesystem"
4048         fi
4049         rm -f $file
4050 }
4051
4052 _try_wipe_scratch_devs()
4053 {
4054         test -x "$WIPEFS_PROG" || return 0
4055
4056         # Do specified filesystem wipe at first
4057         case "$FSTYP" in
4058         "xfs")
4059                 _try_wipe_scratch_xfs
4060                 ;;
4061         esac
4062
4063         # Then do wipefs on all scratch devices
4064         for dev in $SCRATCH_DEV_POOL $SCRATCH_DEV $SCRATCH_LOGDEV $SCRATCH_RTDEV; do
4065                 test -b $dev && $WIPEFS_PROG -a $dev
4066         done
4067 }
4068
4069 # Only run this on xfs if xfs_scrub is available and has the unicode checker
4070 _check_xfs_scrub_does_unicode() {
4071         [ "${FSTYP}" == "xfs" ] || return 1
4072
4073         local mount="$1"
4074         local dev="$2"
4075
4076         _supports_xfs_scrub "${mount}" "${dev}" || return 1
4077
4078         # We only care if xfs_scrub has unicode string support...
4079         if ! type ldd > /dev/null 2>&1 || \
4080            ! ldd "${XFS_SCRUB_PROG}" | grep -q libicui18n; then
4081                 return 1
4082         fi
4083
4084         return 0
4085 }
4086
4087 init_rc
4088
4089 ################################################################################
4090 # make sure this script returns success
4091 /bin/true