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