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