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