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