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