xfstests: convert tests to use new results directory
authorDave Chinner <dchinner@redhat.com>
Fri, 15 Mar 2013 12:28:02 +0000 (12:28 +0000)
committerRich Johnston <rjohnston@sgi.com>
Wed, 27 Mar 2013 02:38:47 +0000 (21:38 -0500)
Essentially the change is simply this. Converting:

... >> $seq.????

to:

.... >> $RESULT_DIR/$seq.????

so that output files are directed to the defined output directory.

sed to the rescue:

$ sed -i -e '/^seq=.*$/a seqres=$RESULT_DIR/$seq' -e 's/seq.full/seqres.full/' tests/*/*

will do most of the work automatically.

Signed-off-by: Dave Chinner <dchinner@redhat.com>
Reviewed-by: Phil White <pwhite@sgi.com>
[rjohnston@sgi.com reworked for TOT changes]
Signed-off-by: Rich Johnston <rjohnston@sgi.com>
308 files changed:
new
tests/btrfs/254
tests/btrfs/264
tests/btrfs/265
tests/btrfs/276
tests/btrfs/284
tests/btrfs/307
tests/ext4/271
tests/ext4/301
tests/ext4/302
tests/ext4/303
tests/ext4/304
tests/generic/001
tests/generic/002
tests/generic/005
tests/generic/006
tests/generic/007
tests/generic/010
tests/generic/011
tests/generic/013
tests/generic/014
tests/generic/015
tests/generic/020
tests/generic/053
tests/generic/062
tests/generic/068
tests/generic/069
tests/generic/070
tests/generic/074
tests/generic/075
tests/generic/076
tests/generic/077
tests/generic/079
tests/generic/083
tests/generic/088
tests/generic/089
tests/generic/091
tests/generic/093
tests/generic/097
tests/generic/099
tests/generic/100
tests/generic/105
tests/generic/112
tests/generic/113
tests/generic/117
tests/generic/120
tests/generic/123
tests/generic/124
tests/generic/125
tests/generic/126
tests/generic/127
tests/generic/128
tests/generic/129
tests/generic/130
tests/generic/131
tests/generic/132
tests/generic/133
tests/generic/135
tests/generic/141
tests/generic/169
tests/generic/184
tests/generic/192
tests/generic/193
tests/generic/198
tests/generic/204
tests/generic/207
tests/generic/208
tests/generic/209
tests/generic/210
tests/generic/211
tests/generic/212
tests/generic/213
tests/generic/214
tests/generic/215
tests/generic/219
tests/generic/221
tests/generic/223
tests/generic/224
tests/generic/225
tests/generic/226
tests/generic/228
tests/generic/230
tests/generic/231
tests/generic/232
tests/generic/233
tests/generic/234
tests/generic/235
tests/generic/236
tests/generic/237
tests/generic/239
tests/generic/240
tests/generic/241
tests/generic/245
tests/generic/246
tests/generic/247
tests/generic/248
tests/generic/249
tests/generic/251
tests/generic/255
tests/generic/256
tests/generic/257
tests/generic/258
tests/generic/260
tests/generic/263
tests/generic/269
tests/generic/270
tests/generic/273
tests/generic/274
tests/generic/275
tests/generic/277
tests/generic/280
tests/generic/285
tests/generic/286
tests/generic/288
tests/generic/294
tests/generic/299
tests/generic/300
tests/generic/306
tests/shared/032
tests/shared/051
tests/shared/218
tests/shared/243
tests/shared/272
tests/shared/289
tests/shared/298
tests/shared/305
tests/udf/098
tests/udf/101
tests/udf/102
tests/xfs/003
tests/xfs/004
tests/xfs/008
tests/xfs/009
tests/xfs/012
tests/xfs/016
tests/xfs/017
tests/xfs/018
tests/xfs/019
tests/xfs/021
tests/xfs/022
tests/xfs/023
tests/xfs/024
tests/xfs/025
tests/xfs/026
tests/xfs/027
tests/xfs/028
tests/xfs/029
tests/xfs/030
tests/xfs/031
tests/xfs/033
tests/xfs/034
tests/xfs/035
tests/xfs/036
tests/xfs/037
tests/xfs/038
tests/xfs/039
tests/xfs/040
tests/xfs/041
tests/xfs/042
tests/xfs/043
tests/xfs/044
tests/xfs/045
tests/xfs/046
tests/xfs/047
tests/xfs/048
tests/xfs/049
tests/xfs/050
tests/xfs/052
tests/xfs/054
tests/xfs/055
tests/xfs/056
tests/xfs/057
tests/xfs/058
tests/xfs/059
tests/xfs/060
tests/xfs/061
tests/xfs/063
tests/xfs/064
tests/xfs/065
tests/xfs/066
tests/xfs/067
tests/xfs/071
tests/xfs/072
tests/xfs/073
tests/xfs/078
tests/xfs/080
tests/xfs/081
tests/xfs/082
tests/xfs/084
tests/xfs/085
tests/xfs/086
tests/xfs/087
tests/xfs/090
tests/xfs/092
tests/xfs/094
tests/xfs/095
tests/xfs/096
tests/xfs/103
tests/xfs/104
tests/xfs/106
tests/xfs/107
tests/xfs/108
tests/xfs/109
tests/xfs/110
tests/xfs/111
tests/xfs/114
tests/xfs/115
tests/xfs/116
tests/xfs/118
tests/xfs/119
tests/xfs/121
tests/xfs/122
tests/xfs/134
tests/xfs/136
tests/xfs/137
tests/xfs/138
tests/xfs/139
tests/xfs/140
tests/xfs/142
tests/xfs/143
tests/xfs/144
tests/xfs/145
tests/xfs/146
tests/xfs/147
tests/xfs/148
tests/xfs/149
tests/xfs/150
tests/xfs/151
tests/xfs/152
tests/xfs/153
tests/xfs/154
tests/xfs/155
tests/xfs/156
tests/xfs/157
tests/xfs/158
tests/xfs/159
tests/xfs/160
tests/xfs/161
tests/xfs/162
tests/xfs/163
tests/xfs/164
tests/xfs/165
tests/xfs/166
tests/xfs/167
tests/xfs/168
tests/xfs/170
tests/xfs/171
tests/xfs/172
tests/xfs/173
tests/xfs/174
tests/xfs/175
tests/xfs/176
tests/xfs/177
tests/xfs/178
tests/xfs/179
tests/xfs/180
tests/xfs/181
tests/xfs/182
tests/xfs/183
tests/xfs/185
tests/xfs/186
tests/xfs/187
tests/xfs/188
tests/xfs/189
tests/xfs/190
tests/xfs/191
tests/xfs/194
tests/xfs/195
tests/xfs/196
tests/xfs/197
tests/xfs/199
tests/xfs/200
tests/xfs/201
tests/xfs/202
tests/xfs/203
tests/xfs/205
tests/xfs/206
tests/xfs/216
tests/xfs/217
tests/xfs/220
tests/xfs/222
tests/xfs/227
tests/xfs/229
tests/xfs/238
tests/xfs/242
tests/xfs/244
tests/xfs/250
tests/xfs/252
tests/xfs/253
tests/xfs/259
tests/xfs/261
tests/xfs/262
tests/xfs/266
tests/xfs/267
tests/xfs/268
tests/xfs/278
tests/xfs/279
tests/xfs/281
tests/xfs/282
tests/xfs/283
tests/xfs/287
tests/xfs/290
tests/xfs/291
tests/xfs/292
tests/xfs/293
tests/xfs/295
tests/xfs/296
tests/xfs/297

diff --git a/new b/new
index 8dde6c5..94638f6 100755 (executable)
--- a/new
+++ b/new
@@ -106,6 +106,7 @@ cat <<End-of-File >$id
 #
 # creator
 seq=\`basename \$0\`
+seqres=$RESULT_DIR/$seq
 echo "QA output created by \$seq"
 
 here=\`pwd\`
@@ -134,7 +135,7 @@ exit
 
 # optional stuff if your test has verbose output to help resolve problems
 #echo
-#echo "If failure, check \$seq.full (this) and \$seq.full.ok (reference)"
+#echo "If failure, check \$seqres.full (this) and \$seqres.full.ok (reference)"
 
 # success, all done
 status=0
index 73089d1..d81f211 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index a589c7c..ae10fea 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index f28d4e5..04050d8 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 07d288c..2787009 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -36,7 +40,7 @@ noise_pid=0
 _cleanup()
 {
        if [ $noise_pid -ne 0 ]; then
-               echo "background noise kill $noise_pid" >>$seq.full
+               echo "background noise kill $noise_pid" >>$seqres.full
                kill $noise_pid
                noise_pid=0
                wait
@@ -60,7 +64,7 @@ _require_no_large_scratch_dev
 _require_btrfs inspect-internal
 _require_command "/usr/sbin/filefrag"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 FILEFRAG_FILTER='if (/, blocksize (\d+)/) {$blocksize = $1; next} ($ext, '\
 '$logical, $physical, $expected, $length, $flags) = (/^\s*(\d+)\s+(\d+)'\
@@ -74,18 +78,18 @@ FILEFRAG_FILTER='if (/, blocksize (\d+)/) {$blocksize = $1; next} ($ext, '\
 # sample output: "1234#10#5678" -> physical 1234, length 10, logical 5678
 _filter_extents()
 {
-       tee -a $seq.full | $PERL_PROG -ne "$FILEFRAG_FILTER"
+       tee -a $seqres.full | $PERL_PROG -ne "$FILEFRAG_FILTER"
 }
 
 _check_file_extents()
 {
        cmd="filefrag -v $1"
-       echo "# $cmd" >> $seq.full
+       echo "# $cmd" >> $seqres.full
        out=`$cmd | _filter_extents`
        if [ -z "$out" ]; then
                return 1
        fi
-       echo "after filter: $out" >> $seq.full
+       echo "after filter: $out" >> $seqres.full
        echo $out
        return 0
 }
@@ -101,9 +105,9 @@ _btrfs_inspect_addr()
        expect_inum=$4
        file=$5
        cmd="$BTRFS_UTIL_PROG inspect-internal logical-resolve -P $addr $mp"
-       echo "# $cmd" >> $seq.full
+       echo "# $cmd" >> $seqres.full
        out=`$cmd`
-       echo "$out" >> $seq.full
+       echo "$out" >> $seqres.full
        grep_expr="inode $expect_inum offset $expect_addr root"
        echo "$out" | grep "^$grep_expr 5$" >/dev/null
        ret=$?
@@ -134,9 +138,9 @@ _btrfs_inspect_inum()
        snap_name=$3
        mp="$SCRATCH_MNT/$snap_name"
        cmd="$BTRFS_UTIL_PROG inspect-internal inode-resolve $inum $mp"
-       echo "# $cmd" >> $seq.full
+       echo "# $cmd" >> $seqres.full
        out=`$cmd`
-       echo "$out" >> $seq.full
+       echo "$out" >> $seqres.full
        grep_expr="^$file$"
        cnt=`echo "$out" | grep "$grep_expr" | wc -l`
        if [ $cnt -ge "1" ]; then
@@ -157,9 +161,9 @@ _btrfs_inspect_check()
        logical=$4
        snap_name=$5
        cmd="stat -c %i $file"
-       echo "# $cmd" >> $seq.full
+       echo "# $cmd" >> $seqres.full
        inum=`$cmd`
-       echo "$inum" >> $seq.full
+       echo "$inum" >> $seqres.full
        _btrfs_inspect_addr $SCRATCH_MNT $physical $logical $inum $file
        ret=$?
        if [ $ret -eq 0 ]; then
@@ -178,9 +182,9 @@ workout()
        do_bg_noise=$5
 
        umount $SCRATCH_DEV >/dev/null 2>&1
-       echo "*** mkfs -dsize=$fsz"    >>$seq.full
-       echo ""                                     >>$seq.full
-       _scratch_mkfs_sized $fsz >>$seq.full 2>&1 \
+       echo "*** mkfs -dsize=$fsz"    >>$seqres.full
+       echo ""                                     >>$seqres.full
+       _scratch_mkfs_sized $fsz >>$seqres.full 2>&1 \
                || _fail "size=$fsz mkfs failed"
        run_check _scratch_mount
        # -w ensures that the only ops are ones which cause write I/O
@@ -210,13 +214,13 @@ workout()
        if [ $do_bg_noise -ne 0 ]; then
                # make background noise while backrefs are being walked
                while /bin/true; do
-                       echo background fsstress >>$seq.full
+                       echo background fsstress >>$seqres.full
                        run_check $FSSTRESS_PROG -d $SCRATCH_MNT/bgnoise -n 999
-                       echo background rm >>$seq.full
+                       echo background rm >>$seqres.full
                        rm -rf $SCRATCH_MNT/bgnoise/
                done &
                noise_pid=`jobs -p %1`
-               echo "background noise by $noise_pid" >>$seq.full
+               echo "background noise by $noise_pid" >>$seqres.full
        fi
 
        cnt=0
index b86ef32..e57371c 100644 (file)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 here="`pwd`"
 tmp=/tmp/$$
index 0653833..f84ea90 100644 (file)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "== QA output created by $seq"
 
 here=`pwd`
@@ -48,16 +52,16 @@ _supported_os Linux
 _require_scratch
 _require_scratch_dev_pool
 
-rm -f $seq.full
+rm -f $seqres.full
 
 FIRST_POOL_DEV=`echo $SCRATCH_DEV_POOL | awk '{print $1}'`
 LAST_POOL_DEV=`echo $SCRATCH_DEV_POOL | awk '{print $NF}'`
 TOTAL_DEVS=`echo $SCRATCH_DEV $SCRATCH_DEV_POOL | wc -w`
 LABEL=TestLabel.$seq
 
-echo "Scratch $SCRATCH_DEV First $FIRST_POOL_DEV last $LAST_POOL_DEV Total $TOTAL_DEVS" > $seq.full
+echo "Scratch $SCRATCH_DEV First $FIRST_POOL_DEV last $LAST_POOL_DEV Total $TOTAL_DEVS" > $seqres.full
 
-_scratch_mkfs $SCRATCH_DEV_POOL >> $seq.full 2>&1 || _fail "mkfs failed"
+_scratch_mkfs $SCRATCH_DEV_POOL >> $seqres.full 2>&1 || _fail "mkfs failed"
 
 # These have to be done unmounted...?
 echo "== Set filesystem label to $LABEL"
@@ -72,7 +76,7 @@ echo "== Show filesystem by label"
 $BTRFS_UTIL_PROG filesystem show $LABEL | _filter_btrfs_filesystem_show $TOTAL_DEVS
 UUID=`$BTRFS_UTIL_PROG filesystem show $LABEL | grep uuid: | awk '{print $NF}'`
 
-echo "UUID $UUID" >> $seq.full
+echo "UUID $UUID" >> $seqres.full
 
 echo "== Show filesystem by UUID"
 $BTRFS_UTIL_PROG filesystem show $UUID | _filter_btrfs_filesystem_show $TOTAL_DEVS $UUID
index 50b4c0b..372c56b 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -40,7 +43,7 @@ _supported_os Linux
 _need_to_be_root
 _require_scratch
 
-_scratch_mkfs_sized $((128 * 1024 * 1024)) >> $seq.full 2>&1
+_scratch_mkfs_sized $((128 * 1024 * 1024)) >> $seqres.full 2>&1
 
 # -onoload and EXT4_SYNC_FL on file is important becase result in
 # metadata sync writes inside ext4_handle_dirty_metadata()
index dc19c3a..847a2f0 100644 (file)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -101,13 +104,13 @@ _workout()
        echo ""
        echo " Start defragment activity"
        echo ""
-       cat $tmp-$seq.fio >>  $seq.full
+       cat $tmp-$seq.fio >>  $seqres.full
        run_check $FIO_PROG $tmp-$seq.fio
 }
 
 _require_fio $tmp-$seq.fio
 
-_scratch_mkfs  >> $seq.full 2>&1
+_scratch_mkfs  >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index 43a9517..d819928 100644 (file)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -117,13 +120,13 @@ _workout()
        echo ""
        echo " Start defragment activity"
        echo ""
-       cat $tmp-$seq.fio >>  $seq.full
+       cat $tmp-$seq.fio >>  $seqres.full
        run_check $FIO_PROG $tmp-$seq.fio
 }
 
 _require_fio $tmp-$seq.fio
 
-_scratch_mkfs  >> $seq.full 2>&1
+_scratch_mkfs  >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index 9bb5584..62947c6 100644 (file)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -127,13 +130,13 @@ _workout()
        echo ""
        echo " Start defragment activity"
        echo ""
-       cat $tmp-$seq.fio >>  $seq.full
+       cat $tmp-$seq.fio >>  $seqres.full
        run_check $FIO_PROG $tmp-$seq.fio
 }
 
 _require_fio $tmp-$seq.fio
 
-_scratch_mkfs  >> $seq.full 2>&1
+_scratch_mkfs  >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index f9b3721..24b0102 100644 (file)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -104,13 +107,13 @@ _workout()
        echo ""
        echo " Start defragment activity"
        echo ""
-       cat $tmp-$seq.fio >>  $seq.full
+       cat $tmp-$seq.fio >>  $seqres.full
        run_check $FIO_PROG $tmp-$seq.fio
 }
 
 _require_fio $tmp-$seq.fio
 
-_scratch_mkfs  >> $seq.full 2>&1
+_scratch_mkfs  >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index b9997f3..4e8b114 100755 (executable)
@@ -32,6 +32,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 # get standard environment, filters and checks
@@ -189,7 +192,7 @@ _mark_iteration()
 #
 _chain()
 {
-    $AWK_PROG -v full_file=$here/$seq.full -v verify=$verify <$tmp.config '
+    $AWK_PROG -v full_file=$here/$seqres.full -v verify=$verify <$tmp.config '
 BEGIN  { nfile = 0 }
 /^\#/  { next }
        { file[nfile] = $1
@@ -237,7 +240,7 @@ END { srand('$iter')
            }
          }
        }' \
-       | tee -a $here/$seq.full | sh
+       | tee -a $here/$seqres.full | sh
 }
 
 _check()
@@ -291,7 +294,7 @@ _cleanup()
     fi
 }
 
-rm -f $here/$seq.full
+rm -f $here/$seqres.full
 status=0
 _cleanup
 status=1
@@ -305,7 +308,7 @@ _setup
 for iter in 1 2 3 4 5
 do
     echo -n "iter $iter chain ... "
-    echo "iter $iter" >> $here/$seq.full
+    echo "iter $iter" >> $here/$seqres.full
     _chain
     _check
     if [ -f $tmp.bad ]
index db63fa0..b9fd888 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 # get standard environment, filters and checks
index 27da3d3..42c4f0b 100755 (executable)
@@ -33,6 +33,9 @@
 # 
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 1437b46..252ed5b 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 2bb981f..bc9148e 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 245f407..18f2eaa 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -59,11 +62,11 @@ _supported_os IRIX Linux
 
 _setup_testdir
 
-rm -f $seq.full
+rm -f $seqres.full
 
 cd $testdir
 
-$here/src/dbtest -l 5 -n 1000 2>&1 | tee -a $here/$seq.full | _filter_dbtest
+$here/src/dbtest -l 5 -n 1000 2>&1 | tee -a $here/$seqres.full | _filter_dbtest
 
 # success, all done
 exit
index 4ede2d8..731500f 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 out=""
@@ -51,7 +54,7 @@ _setup_testdir
 
 out=$testdir/dirstress.$$
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _test()
 {
@@ -63,8 +66,8 @@ _test()
     if ! $here/src/dirstress -d $out -f $count $args >$tmp.out 2>&1
     then
         echo "    dirstress failed"
-        echo "*** TEST $test -d $out -f $count $args" >>$seq.full
-        cat $tmp.out >>$seq.full
+        echo "*** TEST $test -d $out -f $count $args" >>$seqres.full
+        cat $tmp.out >>$seqres.full
         status=1
     fi
 }
index 0879a2a..641a9dc 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -73,15 +76,15 @@ _do_test()
     echo "fsstress.$_n : $_param"
     echo "-----------------------------------------------"
     # -m limits number of users/groups so check doesn't fail (malloc) later
-    dbgoutfile=$seq.full
+    dbgoutfile=$seqres.full
     if ! $FSSTRESS_PROG $_param $FSSTRESS_AVOID -v -m 8 -n $_count -d $out >>$dbgoutfile 2>&1
     then
-        echo "    fsstress (count=$_count) returned $? - see $seq.full"
-        echo "--------------------------------------"       >>$here/$seq.full
-        echo "$_n - output from fsstress:"                  >>$here/$seq.full
-        echo "--------------------------------------"       >>$here/$seq.full
-        echo "<NOT LOGGED>"                                 >>$here/$seq.full
-        #cat $tmp.out                                       >>$here/$seq.full
+        echo "    fsstress (count=$_count) returned $? - see $seqres.full"
+        echo "--------------------------------------"       >>$here/$seqres.full
+        echo "$_n - output from fsstress:"                  >>$here/$seqres.full
+        echo "--------------------------------------"       >>$here/$seqres.full
+        echo "<NOT LOGGED>"                                 >>$here/$seqres.full
+        #cat $tmp.out                                       >>$here/$seqres.full
         status=1
     fi
 
@@ -95,7 +98,7 @@ _supported_os IRIX Linux
 
 _setup_testdir
 
-rm -f $here/$seq.full
+rm -f $here/$seqres.full
 echo "brevity is wit..."
 
 count=1000
@@ -115,8 +118,8 @@ _do_test 2 "-p $procs -r" $count
 
 _do_test 3 "-p 4 -z -f rmdir=10 -f link=10 -f creat=10 -f mkdir=10 -f rename=30 -f stat=30 -f unlink=30 -f truncate=20" $count
 
-# if all ok by here then probably don't need $seq.full
-rm -f $seq.full
+# if all ok by here then probably don't need $seqres.full
+rm -f $seqres.full
 
 exit
 
index 93caaa6..8205efc 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 52ab251..b87144f 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -56,7 +59,7 @@ _scratch_mkfs_sized `expr 50 \* 1024 \* 1024` >/dev/null 2>&1 \
     || _fail "mkfs failed"
 _scratch_mount || _fail "mount failed"
 out=$SCRATCH_MNT/fillup.$$
-rm -f $seq.full
+rm -f $seqres.full
 
 free0=`_free`
 if [ -z "$free0" ]
@@ -64,7 +67,7 @@ then
     echo "   *** failed to get free space (0)"
     exit 1
 fi
-echo "free space at start $free0" >> $seq.full
+echo "free space at start $free0" >> $seqres.full
 
 echo "fill disk:"      # well, filesystem really - not disk
 
@@ -78,7 +81,7 @@ then
     echo "   *** failed to get free space (1)"
     exit 1
 fi
-echo "free space after fill $free1" >> $seq.full
+echo "free space after fill $free1" >> $seqres.full
 
 if [ ! -e $out ]
 then
@@ -116,7 +119,7 @@ then
     echo "   *** failed to get free space (2)"
     exit 1
 fi
-echo "free space after delete $free2" >> $seq.full
+echo "free space after delete $free2" >> $seqres.full
 
 echo -n "   !!! "
 _within_tolerance "free space" $free2 $free0 1% -v
index 2bd1d9f..94695eb 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -85,7 +88,7 @@ _require_attrs
 
 _setup_testdir
 
-rm -f $seq.full
+rm -f $seqres.full
 
 testfile=$testdir/attribute_$$
 
@@ -120,7 +123,7 @@ v=0
 
 while [ $v -lt $MAX_ATTRS ]
 do
-    echo -n "value_$v" | attr -s "attribute_$v" $testfile >>$seq.full
+    echo -n "value_$v" | attr -s "attribute_$v" $testfile >>$seqres.full
     if [ $? -ne 0 ]
     then
         echo "!!! failed to add \"attribute_$v\""
@@ -133,7 +136,7 @@ done
 echo "*** check"
 # don't print it all out...
 getfattr --absolute-names $testfile \
-    | tee -a $seq.full \
+    | tee -a $seqres.full \
     | $AWK_PROG '
        /^#/ { next }
        /^[     ]*$/ { next }
@@ -145,7 +148,7 @@ echo "*** remove lots of attributes"
 v=0
 while [ $v -lt $MAX_ATTRS ]
 do
-    if ! $ATTR_PROG -r "attribute_$v" $testfile >>$seq.full
+    if ! $ATTR_PROG -r "attribute_$v" $testfile >>$seqres.full
     then
         echo "!!! failed to remove \"attribute_$v\""
         exit 1
index 388c9b4..f5daddd 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 5a6081e..dde4baf 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -75,7 +78,7 @@ _supported_os Linux
 _require_scratch
 _require_attrs
 
-rm -f $tmp.backup1 $tmp.backup2 $seq.full
+rm -f $tmp.backup1 $tmp.backup2 $seqres.full
 
 # real QA test starts here
 _scratch_mkfs > /dev/null 2>&1 || _fail "mkfs failed"
@@ -181,8 +184,8 @@ _backup()
 {
        # NB: no filtering of scratch here... (need to restore too)
        $GETFATTR_PROG --absolute-names -dh -R -m '.' $SCRATCH_MNT >$1
-       echo BACKUP $1 >>$seq.full
-       cat $1 >> $seq.full
+       echo BACKUP $1 >>$seqres.full
+       cat $1 >> $seqres.full
        [ ! -s $1 ] && echo "warning: $1 (backup file) is empty"
 }
 
@@ -191,8 +194,8 @@ _backup $tmp.backup1
 
 echo "*** clear out the scratch device"
 rm -fr $SCRATCH_MNT/*
-echo "AFTER REMOVE" >>$seq.full
-getfattr -L -R -m '.' $SCRATCH_MNT >>$seq.full
+echo "AFTER REMOVE" >>$seqres.full
+getfattr -L -R -m '.' $SCRATCH_MNT >>$seqres.full
 
 echo "*** reset test bed with no extended attributes"
 _create_test_bed
@@ -202,8 +205,8 @@ echo "*** restore everything"
 setfattr -h --restore=$tmp.backup1
 _backup $tmp.backup2
 
-echo "AFTER RESTORE" >>$seq.full
-getfattr -L -R -m '.' $SCRATCH_MNT >>$seq.full
+echo "AFTER RESTORE" >>$seqres.full
+getfattr -L -R -m '.' $SCRATCH_MNT >>$seqres.full
 
 echo "*** compare before and after backups"
 diff $tmp.backup1 $tmp.backup2
index 4f10a54..1a531a3 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -57,13 +60,13 @@ _require_freeze
 
 echo "*** init FS"
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
-echo "*** MKFS ***"                         >>$seq.full
-echo ""                                     >>$seq.full
-_scratch_mkfs                               >>$seq.full 2>&1 \
+echo "*** MKFS ***"                         >>$seqres.full
+echo ""                                     >>$seqres.full
+_scratch_mkfs                               >>$seqres.full 2>&1 \
     || _fail "mkfs failed"
-_scratch_mount                              >>$seq.full 2>&1 \
+_scratch_mount                              >>$seqres.full 2>&1 \
     || _fail "mount failed"
 
 touch $tmp.running
@@ -106,23 +109,23 @@ touch $tmp.running
 i=0
 let ITERATIONS=$ITERATIONS-1
 
-echo | tee -a $seq.full
+echo | tee -a $seqres.full
 while [ $i -le $ITERATIONS ]
 do
-        echo "*** iteration: $i" | tee -a $seq.full
-       echo "*** freezing \$SCRATCH_MNT" | tee -a $seq.full
-       xfs_freeze -f "$SCRATCH_MNT" | tee -a $seq.full
+        echo "*** iteration: $i" | tee -a $seqres.full
+       echo "*** freezing \$SCRATCH_MNT" | tee -a $seqres.full
+       xfs_freeze -f "$SCRATCH_MNT" | tee -a $seqres.full
        [ $? != 0 ] && echo xfs_freeze -f "$SCRATCH_MNT" failed | \
-           tee -a $seq.full
+           tee -a $seqres.full
        sleep 2
 
-       echo "*** thawing  \$SCRATCH_MNT" | tee -a $seq.full
-       xfs_freeze -u "$SCRATCH_MNT" | tee -a $seq.full
+       echo "*** thawing  \$SCRATCH_MNT" | tee -a $seqres.full
+       xfs_freeze -u "$SCRATCH_MNT" | tee -a $seqres.full
        [ $? != 0 ] && echo xfs_freeze -u "$SCRATCH_MNT" failed | \
-           tee -a $seq.full
+           tee -a $seqres.full
        sleep 2
 
-       echo  | tee -a $seq.full
+       echo  | tee -a $seqres.full
        let i=$i+1
 done
 
index 3451715..f16bdc8 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -39,7 +42,7 @@ _supported_fs generic
 _supported_os IRIX Linux
 
 _require_scratch
-rm -f $seq.full
+rm -f $seqres.full
 
 umount $SCRATCH_DEV >/dev/null 2>&1
 
@@ -60,19 +63,19 @@ done
 cd $here
 
 wait
-ls -lh $SCRATCH_MNT >> $seq.full
-echo "*** PIDs file" >> $seq.full
-cat $SCRATCH_MNT/pids >> $seq.full
+ls -lh $SCRATCH_MNT >> $seqres.full
+echo "*** PIDs file" >> $seqres.full
+cat $SCRATCH_MNT/pids >> $seqres.full
 
 cat $SCRATCH_MNT/pids | while read pid size
 do
        echo "*** checking file with $size integers"
-       echo checking pid=$pid size=$size >> $seq.full
+       echo checking pid=$pid size=$size >> $seqres.full
        $here/src/append_reader $SCRATCH_MNT/testfile.$pid
        status=$?
        [ $status -ne 0 ] && \
                echo "maybe corrupt O_APPEND to $SCRATCH_MOUNT/testfile.$pid!"
-       echo status: $status >> $seq.full
+       echo status: $status >> $seqres.full
 done
 
 # success, all done
index 02fe142..120c4d9 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -61,7 +64,7 @@ FSSTRESS_ARGS=`_scale_fsstress_args \
        -f attr_set=100 \
        -f attr_remove=100 \
         -p 1 -n 10000 -S c`
-$FSSTRESS_PROG $FSSTRESS_ARGS >$seq.full 2>&1
+$FSSTRESS_PROG $FSSTRESS_ARGS >$seqres.full 2>&1
 
 status=$?
 exit
index 0e5e820..ce6cc20 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -64,9 +67,9 @@ _do_test()
     echo "-----------------------------------------------"
     echo "fstest.$_n : $_filter_param"
     echo "-----------------------------------------------"
-    if ! $here/src/fstest $_param -p $out >>$seq.full
+    if ! $here/src/fstest $_param -p $out >>$seqres.full
     then
-        echo "    fstest ($_param) returned $? - see $seq.full"
+        echo "    fstest ($_param) returned $? - see $seqres.full"
         status=1
        exit
     fi
@@ -107,7 +110,7 @@ _process_args()
 
 
 # real QA test starts here
-rm -f $here/$seq.full
+rm -f $here/$seqres.full
 
 _supported_fs generic
 _supported_os IRIX Linux
@@ -153,8 +156,8 @@ fi
 # can override the params here
 _process_args "$@"
 
-echo "Params are for $param_type" >>$seq.full
-echo "Params: n = $numchildren l = $numloops f = $numfiles" >>$seq.full
+echo "Params are for $param_type" >>$seqres.full
+echo "Params: n = $numchildren l = $numloops f = $numfiles" >>$seqres.full
 
 _setup_testdir
 
index de581b6..7d7a211 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -133,12 +136,12 @@ numops2=10000
 # can override the params here
 _process_args "$@"
 
-echo "Params are for $param_type" >>$seq.full
-echo "Params: n = $numops1 N = $numops2 l = $filelen" >>$seq.full
+echo "Params are for $param_type" >>$seqres.full
+echo "Params: n = $numops1 N = $numops2 l = $filelen" >>$seqres.full
 
 _setup_testdir
 
-rm -f $here/$seq.full
+rm -f $here/$seqres.full
 echo "brevity is wit..."
 
 _check_test_fs
index 11a0792..ed012e7 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -58,13 +61,13 @@ _require_scratch
 
 echo "*** init fs"
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
-echo "*** MKFS ***"                         >>$seq.full
-echo ""                                     >>$seq.full
-_scratch_mkfs                               >>$seq.full 2>&1 \
+echo "*** MKFS ***"                         >>$seqres.full
+echo ""                                     >>$seqres.full
+_scratch_mkfs                               >>$seqres.full 2>&1 \
        || _fail "mkfs failed"
-_scratch_mount                              >>$seq.full 2>&1 \
+_scratch_mount                              >>$seqres.full 2>&1 \
        || _fail "mount failed"
 
 echo "*** test concurrent block/fs access"
@@ -73,8 +76,8 @@ cat $SCRATCH_DEV >/dev/null &
 pid=$!
 
 FSSTRESS_ARGS=`_scale_fsstress_args -p 2 -n 2000 $FSSTRESS_AVOID`
-echo "run fsstress with args: $FSSTRESS_ARGS" >>$seq.full
-$FSSTRESS_PROG $FSSTRESS_ARGS >>$seq.full
+echo "run fsstress with args: $FSSTRESS_ARGS" >>$seqres.full
+$FSSTRESS_PROG $FSSTRESS_ARGS >>$seqres.full
 _lets_get_pidst
 _check_scratch_fs
 
index 2b86a37..f7f1eb8 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -56,29 +59,29 @@ _require_user
 
 echo "*** create filesystem"
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
-echo "*** MKFS ***"                         >>$seq.full
-echo ""                                     >>$seq.full
+echo "*** MKFS ***"                         >>$seqres.full
+echo ""                                     >>$seqres.full
 SIZE=`expr 50 \* 1024 \* 1024`
-_scratch_mkfs_sized $SIZE                   >>$seq.full 2>&1 \
+_scratch_mkfs_sized $SIZE                   >>$seqres.full 2>&1 \
        || _fail "mkfs failed"
-_scratch_mount                              >>$seq.full 2>&1 \
+_scratch_mount                              >>$seqres.full 2>&1 \
        || _fail "mount failed"
 mkdir $SCRATCH_MNT/subdir
 
 echo "*** set default ACL"
 setfacl -R -dm u:fsgqa:rwx,g::rwx,o::r-x,m::rwx $SCRATCH_MNT/subdir
 
-echo "*** populate filesystem, pass #1" | tee -a $seq.full
-cp -rf $filler $SCRATCH_MNT/subdir >$seq.full 2>&1
+echo "*** populate filesystem, pass #1" | tee -a $seqres.full
+cp -rf $filler $SCRATCH_MNT/subdir >$seqres.full 2>&1
 
-echo "*** populate filesystem, pass #2" | tee -a $seq.full
-cp -rf $filler $SCRATCH_MNT/subdir >$seq.full 2>&1
+echo "*** populate filesystem, pass #2" | tee -a $seqres.full
+cp -rf $filler $SCRATCH_MNT/subdir >$seqres.full 2>&1
 
 _check_scratch_fs
 
 echo "*** all done"
-rm -f $seq.full
+rm -f $seqres.full
 status=0
 exit
index 048b220..9700879 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 1a5913a..d7f58f7 100755 (executable)
@@ -33,6 +33,9 @@
 
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -58,7 +61,7 @@ _supported_os IRIX Linux
 _require_scratch
 _require_no_large_scratch_dev
 
-rm -f $seq.full
+rm -f $seqres.full
 
 workout()
 {
@@ -68,22 +71,22 @@ workout()
        nops=$4
 
        umount $SCRATCH_DEV >/dev/null 2>&1
-       echo "*** mkfs -dsize=$fsz,agcount=$ags"    >>$seq.full
-       echo ""                                     >>$seq.full
+       echo "*** mkfs -dsize=$fsz,agcount=$ags"    >>$seqres.full
+       echo ""                                     >>$seqres.full
        if [ $FSTYP = xfs ]
        then
-               _scratch_mkfs_xfs -dsize=$fsz,agcount=$ags  >>$seq.full 2>&1 \
+               _scratch_mkfs_xfs -dsize=$fsz,agcount=$ags  >>$seqres.full 2>&1 \
                        || _fail "size=$fsz,agcount=$ags mkfs failed"
        else
-               _scratch_mkfs_sized $fsz >>$seq.full 2>&1 \
+               _scratch_mkfs_sized $fsz >>$seqres.full 2>&1 \
                        || _fail "size=$fsz mkfs failed"
        fi
-       _scratch_mount                              >>$seq.full 2>&1 \
+       _scratch_mount                              >>$seqres.full 2>&1 \
                || _fail "mount failed"
 
        # -w ensures that the only ops are ones which cause write I/O
        FSSTRESS_ARGS=`_scale_fsstress_args -d $SCRATCH_MNT -w -p $procs -n $nops $FSSTRESS_AVOID`
-       $FSSTRESS_PROG $FSSTRESS_ARGS >>$seq.full
+       $FSSTRESS_PROG $FSSTRESS_ARGS >>$seqres.full
        _check_scratch_fs
 }
 
index b6266ef..031e85e 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -48,7 +51,7 @@ _supported_fs generic
 _supported_os IRIX Linux
 
 path=$TEST_DIR/t_access
-src/t_access_root $path | tee $seq.full | _filter
+src/t_access_root $path | tee $seqres.full | _filter
 
 # success, all done
 status=0
index 2653183..f3e77fe 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 mtab_output=$TEST_DIR/mtab_output
@@ -51,7 +54,7 @@ addentries()
 _supported_fs generic
 _supported_os Linux
 
-rm -f $seq.full
+rm -f $seqres.full
 [ "X$TEST_DIR" = "X" ] && exit 1
 cd $TEST_DIR
 rm -fr test
@@ -72,8 +75,8 @@ mtab()
 
        echo directory entries:
        ls | grep mtab
-       echo directory entries >> $here/$seq.full
-       ls -li >> $here/$seq.full
+       echo directory entries >> $here/$seqres.full
+       ls -li >> $here/$seqres.full
 }
 
 # directory with only a few entries
index ad82b8e..4107656 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -38,16 +41,16 @@ trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
 _supported_fs generic
 _supported_os Linux
 
-rm -f $seq.full
+rm -f $seqres.full
 
 run_fsx()
 {
-       echo fsx $@ | tee -a $seq.full
+       echo fsx $@ | tee -a $seqres.full
        args=`echo $@ | sed -e "s/ BSIZE / $bsize /g" -e "s/ PSIZE / $psize /g"`
        rm -f $TEST_DIR/junk
-       $here/ltp/fsx $args $TEST_DIR/junk >>$seq.full 2>&1
+       $here/ltp/fsx $args $TEST_DIR/junk >>$seqres.full 2>&1
        if [ $? -ne 0 ]; then
-               cat $seq.full
+               cat $seqres.full
                exit 1
        fi
 }
index 881a833..123ea7d 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 
 here=`pwd`
 tmp=/tmp/$$
@@ -62,7 +65,7 @@ _require_attrs
 
 [ -x $runas ] || _notrun "$runas executable not found"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _setup_testdir
 _need_to_be_root
index d3174e4..373ee64 100755 (executable)
@@ -28,6 +28,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -250,7 +253,7 @@ _check_scratch_fs
 
 # optional stuff if your test has verbose output to help resolve problems
 #echo
-#echo "If failure, check $seq.full (this) and $seq.full.ok (reference)"
+#echo "If failure, check $seqres.full (this) and $seqres.full.ok (reference)"
 
 # success, all done
 status=0
index edd88a9..8a21277 100755 (executable)
@@ -24,6 +24,9 @@
 # modifier
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -72,7 +75,7 @@ _cleanup()
 #   -> this would be done by simultaneously matching on ACEs
 #   -> interesting if it allows user to specify ACEs in any order
 #
-rm -f $seq.full
+rm -f $seqres.full
 
 #-------------------------------------------------------
 # real QA test starts here
index 1ba5eb7..a9d0a76 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -54,17 +57,17 @@ DEPTH=5
 POPULATED_DIR=$TEMP_DIR/populate_root
 SIZE=10
 
-rm -f $seq.full
+rm -f $seqres.full
 
 # Clean up if file exist from prevous run
 rm -rf $POPULATED_DIR
 rm -f $TEMP_DIR/$TAR_FILE
 
 # Create the new directory structure
-_populate_fs -n $NDIRS -f $NFILES -d $DEPTH -r $POPULATED_DIR -s $SIZE >>$here/$seq.full 2>&1
+_populate_fs -n $NDIRS -f $NFILES -d $DEPTH -r $POPULATED_DIR -s $SIZE >>$here/$seqres.full 2>&1
 
 # Then tar up the directory structure
-tar -cvf $TEMP_DIR/$TAR_FILE $POPULATED_DIR >>$here/$seq.full 2>&1
+tar -cvf $TEMP_DIR/$TAR_FILE $POPULATED_DIR >>$here/$seqres.full 2>&1
 
 # create f/s
 _require_scratch
@@ -72,12 +75,12 @@ _setup_testdir
 
 # untar on f/s
 cd $testdir
-tar -xRvf $TEMP_DIR/$TAR_FILE >>$here/$seq.full 2>&1
+tar -xRvf $TEMP_DIR/$TAR_FILE >>$here/$seqres.full 2>&1
 cd $here
 
 
 # use diff -qr to compare
-ls -R -l ${testdir}${POPULATED_DIR} >>$here/$seq.full 2>&1
+ls -R -l ${testdir}${POPULATED_DIR} >>$here/$seqres.full 2>&1
 diff -qr $POPULATED_DIR ${testdir}${POPULATED_DIR}
 
 cd /
index 01bae98..09a47df 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -49,7 +52,7 @@ _supported_os IRIX Linux
 
 # real QA test starts here
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _require_scratch
 _require_acls
@@ -57,11 +60,11 @@ _require_acls
 _acl_setup_ids
 
 umount $SCRATCH_DEV >/dev/null 2>&1
-echo "*** MKFS ***"                         >>$seq.full
-echo ""                                     >>$seq.full
-_scratch_mkfs                               >>$seq.full 2>&1 \
+echo "*** MKFS ***"                         >>$seqres.full
+echo ""                                     >>$seqres.full
+_scratch_mkfs                               >>$seqres.full 2>&1 \
        || _fail "mkfs failed"
-_scratch_mount                              >>$seq.full 2>&1 \
+_scratch_mount                              >>$seqres.full 2>&1 \
        || _fail "mount failed"
 
 cd $SCRATCH_MNT
index bcdcfec..6ffefe5 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -134,12 +137,12 @@ numops2=10000
 # can override the params here
 _process_args "$@"
 
-echo "Params are for $param_type" >>$seq.full
-echo "Params: n = $numops1 N = $numops2 l = $filelen" >>$seq.full
+echo "Params are for $param_type" >>$seqres.full
+echo "Params: n = $numops1 N = $numops2 l = $filelen" >>$seqres.full
 
 _setup_testdir
 
-rm -f $here/$seq.full
+rm -f $here/$seqres.full
 echo "brevity is wit..."
 
 _check_test_fs
index fd301cd..4a4bf20 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 8afc962..7f8563d 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -82,13 +85,13 @@ _setup_testdir
 _require_scratch
 _require_attrs
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
-echo "*** MKFS ***"                         >>$seq.full
-echo ""                                     >>$seq.full
-_scratch_mkfs                               >>$seq.full 2>&1 \
+echo "*** MKFS ***"                         >>$seqres.full
+echo ""                                     >>$seqres.full
+_scratch_mkfs                               >>$seqres.full 2>&1 \
     || _fail "mkfs failed"
-_scratch_mount                              >>$seq.full 2>&1 \
+_scratch_mount                              >>$seqres.full 2>&1 \
     || _fail "mount failed"
 
 mkdir -p $SCRATCH_MNT/fsstress
@@ -97,10 +100,10 @@ echo
 echo Running fsstress in serial:
 i=0
 while [ $i -lt $ITERATIONS ]; do
-    echo fsstress iteration: $i | tee -a $seq.full
+    echo fsstress iteration: $i | tee -a $seqres.full
     $FSSTRESS_PROG \
        -d $SCRATCH_MNT/fsstress \
-       $fss_ops -S c >>$seq.full 2>&1
+       $fss_ops -S c >>$seqres.full 2>&1
 
     let i=$i+1
 done
index 8389925..afc2408 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index d45c516..df0a347 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 6fbb028..7babdd3 100755 (executable)
@@ -27,6 +27,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index c7215a3..c606f29 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index a95c1e4..5bad7d1 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index d1101df..b9098a1 100755 (executable)
@@ -27,6 +27,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 85d0f45..2cb414c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 18d891b..9d1440e 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 943df72..ebdbb71 100755 (executable)
@@ -32,6 +32,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 176c8b4..a2602c2 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 98229a9..002b330 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index ec225f3..be6244b 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index f0bf9b9..3bb05e3 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 45c1b5e..7df988f 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 413a86b..99cf547 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
 tmp=/tmp/$$
-rm -f $seq.full
+rm -f $seqres.full
 status=1    # failure is the default!
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
@@ -56,10 +59,10 @@ _supported_os Linux
 
 _require_scratch
 
-_scratch_mkfs >>$seq.full 2>&1 \
+_scratch_mkfs >>$seqres.full 2>&1 \
        || _fail "mkfs scratch failed"
 
-_scratch_mount >>$seq.full 2>&1 \
+_scratch_mount >>$seqres.full 2>&1 \
     || _fail "mount failed: $MOUNT_OPTIONS"
 
 echo "# creating new file for io"
@@ -73,11 +76,11 @@ xfs_io -F -a -c "pwrite 0 5k" -c "fsync" \
        | _show_wrote_and_stat_only
 
 echo "# unmounting scratch"
-umount $SCRATCH_MNT>>$seq.full 2>&1 \
+umount $SCRATCH_MNT>>$seqres.full 2>&1 \
     || _fail "unmount failed"
 
 echo "# mounting scratch"
-_scratch_mount >>$seq.full 2>&1 \
+_scratch_mount >>$seqres.full 2>&1 \
     || _fail "mount failed: $MOUNT_OPTIONS"
 
 echo "# stating file to confirm correct size"
@@ -90,11 +93,11 @@ xfs_io -F -f -c "pwrite 0 5" -c s -c "pwrite 5 5" \
        | _show_wrote_and_stat_only
 
 echo "# unmounting scratch"
-umount $SCRATCH_MNT>>$seq.full 2>&1 \
+umount $SCRATCH_MNT>>$seqres.full 2>&1 \
     || _fail "unmount failed"
 
 echo "# mounting scratch"
-_scratch_mount >>$seq.full 2>&1 \
+_scratch_mount >>$seqres.full 2>&1 \
     || _fail "mount failed: $MOUNT_OPTIONS"
 
 echo "# stating file to confirm correct size"
index a37f700..56efc3c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq - silence is golden"
 
 here=`pwd`
index 691ab7d..321a92f 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -53,20 +56,20 @@ delay=40
 
 testfile=$TEST_DIR/testfile
 rm -f $testfile
-rm -f $seq.full
+rm -f $seqres.full
 
 echo test >$testfile
-time1=`_access_time $testfile | tee -a $seq.full` 
+time1=`_access_time $testfile | tee -a $seqres.full`
 
 echo "sleep for $delay"
 sleep $delay # sleep to allow time to move on for access
 cat $testfile
-time2=`_access_time $testfile | tee -a $seq.full` 
+time2=`_access_time $testfile | tee -a $seqres.full`
 
 cd /
 umount $TEST_DIR
 _test_mount
-time3=`_access_time $testfile | tee -a $here/$seq.full`
+time3=`_access_time $testfile | tee -a $here/$seqres.full`
 
 delta1=`expr $time2 - $time1`
 delta2=`expr $time3 - $time1`
index 88ab971..48deac7 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -247,5 +250,5 @@ _cleanup_files
 
 # success, all done
 echo "*** done"
-rm -f $seq.full
+rm -f $seqres.full
 status=0
index 31de96c..b2d4cba 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -47,7 +50,7 @@ _require_aiodio aiodio_sparse2
 echo "Silence is golden."
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
 rm -f "$TEST_DIR/aiodio_sparse*"
 $AIO_TEST "$TEST_DIR/aiodio_sparse"
index 6c4a3f0..baf45ef 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -44,7 +47,7 @@ _scratch_mount
 
 # fix the reserve block pool to a known size so that the enospc calculations
 # work out correctly.
-_scratch_resvblks 1024 > $seq.full 2>&1
+_scratch_resvblks 1024 > $seqres.full 2>&1
 
 for i in `seq 1 22500`; do
     echo -n > $SCRATCH_MNT/$i
@@ -53,5 +56,5 @@ done
 
 # success, all done
 echo "*** done"
-rm -f $seq.full
+rm -f $seqres.full
 status=0
index 6eaf50c..faef4a4 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 7ea7514..437547c 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 8b2a4e1..dc9c47e 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 56ac8ad..f4f997a 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 5667d20..193cd0d 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index e211cc4..2f46c09 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index e297fdf..40829c3 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 _cleanup()
@@ -51,7 +54,7 @@ _supported_os Linux
 
 [ -n "$XFS_IO_PROG" ] || _notrun "xfs_io executable not found"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _require_xfs_io_falloc
 
index 682cfca..d26d077 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 _cleanup()
@@ -49,7 +52,7 @@ _supported_os Linux
 
 [ -n "$XFS_IO_PROG" ] || _notrun "xfs_io executable not found"
 
-rm -f $seq.full
+rm -f $seqres.full
 rm -f $TEST_DIR/ouch*
 
 _require_xfs_io_falloc
index 749b27b..f03af0d 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 _cleanup()
@@ -79,5 +82,5 @@ fi
 
 # success, all done
 echo "*** done"
-rm -f $seq.full
+rm -f $seqres.full
 status=0
index 3f4ec09..d942098 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -78,17 +81,17 @@ check_usage()
 test_accounting()
 {
        echo "### some controlled buffered, direct and mmapd IO (type=$type)"
-       echo "--- initiating parallel IO..." >>$seq.full
+       echo "--- initiating parallel IO..." >>$seqres.full
        # Small ios here because ext3 will account for indirect blocks too ...
        # 48k will fit w/o indirect for 4k blocks (default blocksize)
        $XFS_IO_PROG -F -c 'pwrite 0 48k' -c 'fsync' \
-                                       $SCRATCH_MNT/buffer >>$seq.full 2>&1 &
+                                       $SCRATCH_MNT/buffer >>$seqres.full 2>&1 &
        $XFS_IO_PROG -F -c 'pwrite 0 48k' -d \
-                                       $SCRATCH_MNT/direct >>$seq.full 2>&1 &
+                                       $SCRATCH_MNT/direct >>$seqres.full 2>&1 &
        $XFS_IO_PROG -F -c 't 48k' -c 'mm -rw 0 48k' -c 'mw 0 48k' -c 'ms -s' \
-                                       $SCRATCH_MNT/mmap   >>$seq.full 2>&1 &
+                                       $SCRATCH_MNT/mmap   >>$seqres.full 2>&1 &
        wait
-       echo "--- completed parallel IO ($type)" >>$seq.full
+       echo "--- completed parallel IO ($type)" >>$seqres.full
 
        for file in $SCRATCH_MNT/{buffer,direct,mmap}; do
                $here/src/lstat64 $file | head -2 | _filter_scratch
@@ -103,10 +106,10 @@ test_accounting()
 }
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
 umount $SCRATCH_DEV 2>/dev/null
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
 quotaon $SCRATCH_MNT 2>/dev/null
index 9cab3c4..f554fe3 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 8eba2d7..8c83387 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -47,7 +50,7 @@ _supported_os Linux
 _require_scratch
 _require_xfs_io_falloc
 
-rm -f $seq.full
+rm -f $seqres.full
 
 BLOCKSIZE=4096
 
@@ -57,7 +60,7 @@ for SUNIT_K in 8 16 32 64 128; do
 
        echo "=== mkfs with su $SUNIT_BLOCKS blocks x 4 ==="
        export MKFS_OPTIONS=""
-       _scratch_mkfs_geom $SUNIT_BYTES 4 $BLOCKSIZE >> $seq.full 2>&1
+       _scratch_mkfs_geom $SUNIT_BYTES 4 $BLOCKSIZE >> $seqres.full 2>&1
        _scratch_mount
 
        for SIZE_MULT in 1 2 8 64 256; do
@@ -67,10 +70,10 @@ for SUNIT_K in 8 16 32 64 128; do
                for FILE in 1 2 3 4; do
                        xfs_io -F -f -c "falloc 0 $SIZE" \
                                $SCRATCH_MNT/file-$FILE-$SIZE-falloc \
-                                       >> $seq.full 2>&1
+                                       >> $seqres.full 2>&1
                        xfs_io -F -f -c "pwrite 0 $SIZE" \
                                $SCRATCH_MNT/file-$FILE-$SIZE-write \
-                                       >> $seq.full 2>&1
+                                       >> $seqres.full 2>&1
                        src/t_stripealign $SCRATCH_MNT/file-$FILE-$SIZE-falloc \
                                $SUNIT_BLOCKS | _filter_scratch
                        src/t_stripealign $SCRATCH_MNT/file-$FILE-$SIZE-write \
@@ -80,7 +83,7 @@ for SUNIT_K in 8 16 32 64 128; do
 
        echo "=== Testing size 1g falloc on ${SUNIT_K}k stripe ==="
        xfs_io -F -f -c "falloc 0 1g" \
-           $SCRATCH_MNT/file-1g-falloc >> $seq.full 2>&1
+           $SCRATCH_MNT/file-1g-falloc >> $seqres.full 2>&1
        src/t_stripealign $SCRATCH_MNT/file-1g-falloc $SUNIT_BLOCKS \
            | _filter_scratch
 
@@ -88,7 +91,7 @@ for SUNIT_K in 8 16 32 64 128; do
 
        echo "=== Testing size 1073745920 falloc on ${SUNIT_K}k stripe ==="
        xfs_io -F -f -c "falloc 0 1073745920" \
-               $SCRATCH_MNT/file-1073745920-falloc >> $seq.full 2>&1
+               $SCRATCH_MNT/file-1073745920-falloc >> $seqres.full 2>&1
        src/t_stripealign $SCRATCH_MNT/file-1073745920-falloc \
                $SUNIT_BLOCKS | _filter_scratch
 
index 23ee7c2..c59b6b9 100755 (executable)
@@ -28,6 +28,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -53,12 +56,12 @@ _supported_os Linux
 _require_scratch
 
 # make a 1GB filesystem
-_scratch_mkfs_sized `expr 1024 \* 1024 \* 1024` > $seq.full 2>&1
-_scratch_mount >> $seq.full 2>&1
+_scratch_mkfs_sized `expr 1024 \* 1024 \* 1024` > $seqres.full 2>&1
+_scratch_mount >> $seqres.full 2>&1
 
 # set the reserved block pool to almost empty for XFS
 if [ "$FSTYP" = "xfs" ]; then
-       xfs_io -x -c "resblks 4" $SCRATCH_MNT >> $seq.full 2>&1
+       xfs_io -x -c "resblks 4" $SCRATCH_MNT >> $seqres.full 2>&1
 fi
 
 FILES=1000
index c09bd2a..31d0204 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -48,7 +51,7 @@ _require_scratch
 _scratch_mkfs > /dev/null 2>&1
 _scratch_mount > /dev/null 2>&1
 
-rm -f $seq.full
+rm -f $seqres.full
 fiemapfile=$SCRATCH_MNT/$seq.fiemap
 fiemaplog=$SCRATCH_MNT/$seq.log
 
index 2179f2a..5111c9a 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -38,11 +41,11 @@ _supported_os Linux IRIX
 _require_scratch
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
 umount $SCRATCH_DEV 2>/dev/null
 echo "--> mkfs 256m filesystem"
-_scratch_mkfs_sized `expr 256 \* 1024 \* 1024` >> $seq.full 2>&1
+_scratch_mkfs_sized `expr 256 \* 1024 \* 1024` >> $seqres.full 2>&1
 _scratch_mount
 
 loops=16
@@ -54,7 +57,7 @@ echo "--> $loops buffered 64m writes in a loop"
 for I in `seq 1 $loops`; do
        echo -n "$I "
        xfs_io -F -f \
-               -c "pwrite ${buffer} 0 64m" $SCRATCH_MNT/test >> $seq.full
+               -c "pwrite ${buffer} 0 64m" $SCRATCH_MNT/test >> $seqres.full
        rm -f $SCRATCH_MNT/test
 done
 
@@ -66,7 +69,7 @@ echo "--> $loops direct 64m writes in a loop"
 for I in `seq 1 $loops`; do
        echo -n "$I "
        xfs_io -F -f -d \
-               -c "pwrite ${buffer} 0 64m" $SCRATCH_MNT/test >> $seq.full
+               -c "pwrite ${buffer} 0 64m" $SCRATCH_MNT/test >> $seqres.full
        rm -f $SCRATCH_MNT/test 
 done
 
index 2704934..f58982d 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 _cleanup()
@@ -49,7 +52,7 @@ _supported_os Linux
 
 [ -n "$XFS_IO_PROG" ] || _notrun "xfs_io executable not found"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 # Sanity check to see if fallocate works
 _require_xfs_io_falloc
index a442857..005af42 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -58,49 +61,49 @@ test_files()
 test_enforcement()
 {
        echo "### some buffered IO (type=$type)"
-       echo "--- initiating IO..." >>$seq.full
+       echo "--- initiating IO..." >>$seqres.full
        # Firstly fit below block soft limit
        echo "Write 900k..."
        su $qa_user -c "$XFS_IO_PROG -F -c 'pwrite 0 900k' -c fsync \
-               $SCRATCH_MNT/file1" 2>&1 >>$seq.full | tee -a $seq.full
-       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seq.full 2>&1
+               $SCRATCH_MNT/file1" 2>&1 >>$seqres.full | tee -a $seqres.full
+       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
        # Secondly overcome block soft limit
        echo "Rewrite 1001k..."
        su $qa_user -c "$XFS_IO_PROG -F -c 'pwrite 0 1001k' -c fsync \
-               $SCRATCH_MNT/file1" 2>&1 >>$seq.full | tee -a $seq.full
-       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seq.full 2>&1
+               $SCRATCH_MNT/file1" 2>&1 >>$seqres.full | tee -a $seqres.full
+       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
        # Now try to overcome block hardlimit
        echo "Write 1000k..."
        su $qa_user -c "$XFS_IO_PROG -F -c 'pwrite 0 1000k' -c fsync \
-               $SCRATCH_MNT/file2" 2>&1 >>$seq.full | tee -a $seq.full
-       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seq.full 2>&1
+               $SCRATCH_MNT/file2" 2>&1 >>$seqres.full | tee -a $seqres.full
+       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
        # Now sleep for grace time and check that softlimit got enforced
        sleep $((grace+1))
        echo "Write 4096..."
        su $qa_user -c "$XFS_IO_PROG -F -c 'truncate 0' -c 'pwrite 0 4096' \
-               $SCRATCH_MNT/file2" 2>&1 >>$seq.full | tee -a $seq.full
-       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seq.full 2>&1
+               $SCRATCH_MNT/file2" 2>&1 >>$seqres.full | tee -a $seqres.full
+       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
        # And now the softlimit test for inodes
        # First reset space limits so that we don't have problems with
        # space reservations on XFS
        setquota -$type $qa_user 0 0 3 5 $SCRATCH_MNT
        echo "Touch 3+4"
        su $qa_user -c "touch $SCRATCH_MNT/file3 $SCRATCH_MNT/file4" \
-               2>&1 >>$seq.full | _filter_scratch | tee -a $seq.full
-       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seq.full 2>&1
+               2>&1 >>$seqres.full | _filter_scratch | tee -a $seqres.full
+       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
        # Try to exceed inode hardlimit
        echo "Touch 5+6"
        su $qa_user -c "touch $SCRATCH_MNT/file5 $SCRATCH_MNT/file6" \
-               2>&1 >>$seq.full | _filter_scratch | tee -a $seq.full
-       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seq.full 2>&1
+               2>&1 >>$seqres.full | _filter_scratch | tee -a $seqres.full
+       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
        # Wait and check grace time enforcement
-       rm -f $SCRATCH_MNT/file5 >>$seq.full 2>&1
+       rm -f $SCRATCH_MNT/file5 >>$seqres.full 2>&1
        sleep $((grace+1))
        echo "Touch 5"
-       su $qa_user -c "touch $SCRATCH_MNT/file5" 2>&1 >>$seq.full |
-               _filter_scratch | tee -a $seq.full
-       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seq.full 2>&1
-       echo "--- completed IO ($type)" >>$seq.full
+       su $qa_user -c "touch $SCRATCH_MNT/file5" 2>&1 >>$seqres.full |
+               _filter_scratch | tee -a $seqres.full
+       repquota -$type $SCRATCH_MNT  | grep -v "^root" >>$seqres.full 2>&1
+       echo "--- completed IO ($type)" >>$seqres.full
 }
 
 cleanup_files()
@@ -109,11 +112,11 @@ cleanup_files()
 }
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
 grace=2
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
 quotaon $SCRATCH_MNT 2>/dev/null
index 6d8bda7..2719ad7 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -45,19 +48,19 @@ _fsx()
        echo "=== FSX Standard Mode, Memory Mapping, $tasks Tasks ==="
        for (( i = 1; i <= $tasks; i++ )); do
                SEED=$RANDOM
-               echo "ltp/fsx $FSX_ARGS -S $SEED $SCRATCH_MNT/fsx_file$i" >>$seq.full
+               echo "ltp/fsx $FSX_ARGS -S $SEED $SCRATCH_MNT/fsx_file$i" >>$seqres.full
                su $qa_user -c "ltp/fsx $FSX_ARGS -S $SEED \
                        $SCRATCH_MNT/fsx_file$i" >$tmp.output$i 2>&1 &
        done
 
        for (( i = 1; i <= $tasks; i++ )); do
                if ! wait %$i; then
-                       cat $tmp.output$i | tee -a $seq.full
+                       cat $tmp.output$i | tee -a $seqres.full
                        wait
                        return 1
                fi
                $XFS_IO_PROG -F -c 'fsync' $SCRATCH_MNT/fsx_file$i
-               cat $tmp.output$i | tee -a $seq.full
+               cat $tmp.output$i | tee -a $seqres.full
        done
        return 0
 }
@@ -70,7 +73,7 @@ _require_quota
 _require_user
 _need_to_be_root
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 chmod 777 $SCRATCH_MNT
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
index f7a1eb7..53e023f 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -38,7 +41,7 @@ trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
 
 _filter_num()
 {
-       tee -a $here/$seq.full |\
+       tee -a $here/$seqres.full |\
        sed -e 's/[0-9][0-9]* inodes/I inodes/g' \
            -e 's/[0-9][0-9]* paths/P paths/g' \
            -e 's/seed = [0-9][0-9]*/seed = S/'
@@ -54,11 +57,11 @@ _fsstress()
        count=2000
        args=`_scale_fsstress_args -d $out -n $count -p 7`
 
-       echo "fsstress $args" >> tee -a $here/$seq.full
-       if ! $FSSTRESS_PROG $args | tee -a $here/$seq.full | _filter_num
+       echo "fsstress $args" >> tee -a $here/$seqres.full
+       if ! $FSSTRESS_PROG $args | tee -a $here/$seqres.full | _filter_num
        then
                echo "    fsstress $args returned $?"
-               cat $tmp.out | tee -a $here/$seq.full
+               cat $tmp.out | tee -a $here/$seqres.full
                status=1
        fi
 }
@@ -70,7 +73,7 @@ _require_scratch
 _require_quota
 _need_to_be_root
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 chmod 777 $SCRATCH_MNT
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
index 330041c..40b3f5d 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -42,7 +45,7 @@ FSX_ARGS="-q -l $FSX_FILE_SIZE -o 65536 -S 191110531 -N 100000"
 
 _filter_num()
 {
-       tee -a $here/$seq.full |\
+       tee -a $here/$seqres.full |\
        sed -e 's/[0-9][0-9]* inodes/I inodes/g' \
            -e 's/[0-9][0-9]* paths/P paths/g' \
            -e 's/seed = [0-9][0-9]*/seed = S/'
@@ -61,11 +64,11 @@ _fsstress()
 -f rename=10 -f fsync=2 -f write=15 -f dwrite=15 \
 -n $count -d $out -p 7`
 
-       echo "fsstress $args" >> tee -a $here/$seq.full
-       if ! su $qa_user -c "$FSSTRESS_PROG $args" | tee -a $here/$seq.full | _filter_num
+       echo "fsstress $args" >> tee -a $here/$seqres.full
+       if ! su $qa_user -c "$FSSTRESS_PROG $args" | tee -a $here/$seqres.full | _filter_num
        then
                echo "    fsstress $args returned $?"
-               cat $tmp.out | tee -a $here/$seq.full
+               cat $tmp.out | tee -a $here/$seqres.full
                status=1
        fi
 }
@@ -78,7 +81,7 @@ _require_quota
 _require_user
 _need_to_be_root
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 chmod 777 $SCRATCH_MNT
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
index dbb13f6..8bd19e4 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -46,7 +49,7 @@ test_setting()
        idmod=200000
        seed=$RANDOM
        RANDOM=$seed
-       echo "Starting test with procs=$procs, idmod=$idmod, and seed=$seed" >>$seq.full
+       echo "Starting test with procs=$procs, idmod=$idmod, and seed=$seed" >>$seqres.full
 
        for (( i = 0; i < $procs; i++ )); do
                ( SETUCOUNT=1; SETGCOUNT=1; SETUIDS[0]=0; SETGIDS[0]=0
@@ -93,9 +96,9 @@ _require_quota
 _need_to_be_root
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
 quotaon -u -g $SCRATCH_MNT 2>/dev/null
index f4a1fce..5560fa6 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -47,9 +50,9 @@ _require_user
 _need_to_be_root
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
 quotaon $SCRATCH_MNT 2>/dev/null
@@ -64,12 +67,12 @@ repquota -u -g $SCRATCH_MNT  | grep -v "^root" | _filter_scratch
 #
 # We work around it by editing the context out of mtab.  Sigh.
 sed -i "s#^$SCRATCH_DEV\(.*\),context=\"system_u:object_r:nfs_t:s0\"#$SCRATCH_DEV\1#" /etc/mtab
-mount -o remount,ro $SCRATCH_DEV 2>&1 | tee -a $seq.full | _filter_scratch
-touch $SCRATCH_MNT/failed 2>&1 | tee -a $seq.full | _filter_scratch
-mount -o remount,rw $SCRATCH_DEV 2>&1 | tee -a $seq.full | _filter_scratch
+mount -o remount,ro $SCRATCH_DEV 2>&1 | tee -a $seqres.full | _filter_scratch
+touch $SCRATCH_MNT/failed 2>&1 | tee -a $seqres.full | _filter_scratch
+mount -o remount,rw $SCRATCH_DEV 2>&1 | tee -a $seqres.full | _filter_scratch
 
 $XFS_IO_PROG -F -c 'pwrite 0 8k' -c 'fsync' \
-                       $SCRATCH_MNT/testfile >>$seq.full 2>&1
+                       $SCRATCH_MNT/testfile >>$seqres.full 2>&1
 repquota -u -g $SCRATCH_MNT  | grep -v "^root" | _filter_scratch
 
 umount $SCRATCH_DEV 2>/dev/null
index ec70cdb..831afc7 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 _cleanup()
index 7ebb88e..171d96c 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -52,7 +55,7 @@ _supported_os Linux
 
 [ -x $runas ] || _notrun "$runas executable not found"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _setup_testdir
 
index 8aa4ed0..aae4f7e 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index d5f8940..9b6982f 100755 (executable)
@@ -29,6 +29,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -55,7 +58,7 @@ _require_aiodio aiodio_sparse2
 echo "Silence is golden."
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
 rm -f $TEST_DIR/aiodio_sparse
 
index ee572a7..297ae02 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -47,12 +50,12 @@ _supported_os Linux
 echo "Silence is golden."
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
 rm -rf $TEST_DIR/dbench
 mkdir $TEST_DIR/dbench
 
-dbench -t 60 -D $TEST_DIR/dbench 4 >> $seq.full
+dbench -t 60 -D $TEST_DIR/dbench 4 >> $seqres.full
 
 status=$?
 exit
index fb81d39..ec81c4c 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index d82e27d..68c8c27 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 3a2f735..31b94a9 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index f245c1c..3f68146 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index e72092d..32f82e3 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -50,11 +53,11 @@ echo "Feel the serenity."
 
 SRC=$TEST_DIR/$seq.src
 DST=$TEST_DIR/$seq.dst
-rm -f $seq.full
+rm -f $seqres.full
 
-$XFS_IO_PROG -F -f -c "pwrite -S 0xa5a55a5a 0 32768k" -c fsync $SRC >> $seq.full 2>&1
+$XFS_IO_PROG -F -f -c "pwrite -S 0xa5a55a5a 0 32768k" -c fsync $SRC >> $seqres.full 2>&1
 [ $? -ne 0 ] && _fail "xfs_io pwrite failed"
-$XFS_IO_PROG -F -f -c "sendfile -i $SRC 0 32768k" -c fsync $DST >> $seq.full 2>&1
+$XFS_IO_PROG -F -f -c "sendfile -i $SRC 0 32768k" -c fsync $DST >> $seqres.full 2>&1
 [ $? -ne 0 ] && _fail "xfs_io sendfile failed"
 
 diff -q $SRC $DST
index 25f14bd..c91e67f 100755 (executable)
@@ -25,6 +25,9 @@
 
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index d2973a8..181f87e 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 0d72795..384bd3c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index b58bd56..d341063 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -50,5 +53,5 @@ src/t_dir_offset2 $TEST_DIR/ttt
 
 # success, all done
 echo "*** done"
-rm -f $seq.full
+rm -f $seqres.full
 status=0
index 87817bc..b8fe984 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 65a01c3..e514128 100755 (executable)
@@ -23,6 +23,9 @@
 
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 18cd5de..56f4ae3 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -38,16 +41,16 @@ trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
 _supported_fs generic
 _supported_os Linux
 
-rm -f $seq.full
+rm -f $seqres.full
 
 run_fsx()
 {
-       echo fsx $@ | tee -a $seq.full
+       echo fsx $@ | tee -a $seqres.full
        args=`echo $@ | sed -e "s/ BSIZE / $bsize /g" -e "s/ PSIZE / $psize /g"`
        rm -f $TEST_DIR/junk
-       $here/ltp/fsx $args $TEST_DIR/junk >>$seq.full 2>&1
+       $here/ltp/fsx $args $TEST_DIR/junk >>$seqres.full 2>&1
        if [ $? -ne 0 ]; then
-               cat $seq.full
+               cat $seqres.full
                exit 1
        fi
 }
index ed27fb4..7b387b2 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -44,7 +47,7 @@ _workout()
        enospc_time=2
        out=$SCRATCH_MNT/fsstress.$$
        args=`_scale_fsstress_args -p128 -n999999999 -f setattr=1 $FSSTRESS_AVOID -d $out`
-       echo "fsstress $args" >> $here/$seq.full
+       echo "fsstress $args" >> $here/$seqres.full
        $FSSTRESS_PROG $args > /dev/null 2>&1 &
        pid=$!
        echo "Run dd writers in parallel"
@@ -52,7 +55,7 @@ _workout()
        do
                # File will be opened with O_TRUNC each time
                dd if=/dev/zero of=$SCRATCH_MNT/SPACE_CONSUMER bs=1M \
-                       >> $here/$seq.full 2>&1
+                       >> $here/$seqres.full 2>&1
                sleep $enospc_time
        done
        kill $pid
@@ -65,7 +68,7 @@ _supported_os Linux
 _need_to_be_root
 _require_scratch
 
-_scratch_mkfs_sized $((512 * 1024 * 1024)) >> $seq.full 2>&1
+_scratch_mkfs_sized $((512 * 1024 * 1024)) >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index 7841cd1..8ca8aa2 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -47,7 +50,7 @@ _workout()
        enospc_time=2
        out=$SCRATCH_MNT/fsstress.$$
        args=`_scale_fsstress_args -p128 -n999999999 -f setattr=1 $FSSTRESS_AVOID -d $out`
-       echo "fsstress $args" >> $here/$seq.full
+       echo "fsstress $args" >> $here/$seqres.full
        # Grant chown capability 
        cp $FSSTRESS_PROG  $tmp.fsstress.bin
        if [ "`whereis setcap`" == "setcap:" ]; then
@@ -64,7 +67,7 @@ _workout()
                # File will be opened with O_TRUNC each time
                su $qa_user -c "dd if=/dev/zero \
                        of=$SCRATCH_MNT/SPACE_CONSUMER bs=1M " \
-                       >> $here/$seq.full 2>&1
+                       >> $here/$seqres.full 2>&1
                sleep $enospc_time
        done
 
@@ -80,7 +83,7 @@ _require_user
 _need_to_be_root
 _require_scratch
 
-_scratch_mkfs_sized $((512 * 1024 * 1024)) >> $seq.full 2>&1
+_scratch_mkfs_sized $((512 * 1024 * 1024)) >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 chmod 777 $SCRATCH_MNT
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
index 4473fd4..63e64b1 100755 (executable)
@@ -24,6 +24,9 @@
 #creator
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -91,7 +94,7 @@ _porter()
                exit
        fi
 
-       cp -r $SCRATCH_MNT/origin $SCRATCH_MNT/sub_$_suffix >>$seq.full 2>&1
+       cp -r $SCRATCH_MNT/origin $SCRATCH_MNT/sub_$_suffix >>$seqres.full 2>&1
        if [ $? -ne 0 ]
        then
                echo "_porter $_suffix not complete"
@@ -129,10 +132,10 @@ echo "------------------------------"
 echo "start the workload"
 echo "------------------------------"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _scratch_unmount 2>/dev/null
-_scratch_mkfs_sized $((2 * 1024 * 1024 * 1024)) >>$seq.full 2>&1
+_scratch_mkfs_sized $((2 * 1024 * 1024 * 1024)) >>$seqres.full 2>&1
 _scratch_mount
 
 _do_workload
index 9b0fb71..00f869d 100755 (executable)
@@ -26,6 +26,9 @@
 #creator
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -53,48 +56,48 @@ echo "------------------------------"
 echo "preallocation test"
 echo "------------------------------"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 umount $SCRATCH_DEV 2>/dev/null
-_scratch_mkfs_sized $((1 * 1024 * 1024 * 1024)) >>$seq.full 2>&1
+_scratch_mkfs_sized $((1 * 1024 * 1024 * 1024)) >>$seqres.full 2>&1
 _scratch_mount
 
 # Create a 4k file and Allocate 4M past EOF on that file
 xfs_io -F -f -c "pwrite 0 4k" -c "falloc -k 4k 4m" $SCRATCH_MNT/test \
-       >>$seq.full 2>&1 || _fail "failed to create test file"
+       >>$seqres.full 2>&1 || _fail "failed to create test file"
 
 # Fill the rest of the fs completely
-# Note, this will show ENOSPC errors in $seq.full, that's ok.
-echo "Fill fs with 1M IOs; ENOSPC expected" >> $seq.full
-dd if=/dev/zero of=$SCRATCH_MNT/tmp1 bs=1M >>$seq.full 2>&1
-echo "Fill fs with 4K IOs; ENOSPC expected" >> $seq.full
-dd if=/dev/zero of=$SCRATCH_MNT/tmp2 bs=4K >>$seq.full 2>&1
+# Note, this will show ENOSPC errors in $seqres.full, that's ok.
+echo "Fill fs with 1M IOs; ENOSPC expected" >> $seqres.full
+dd if=/dev/zero of=$SCRATCH_MNT/tmp1 bs=1M >>$seqres.full 2>&1
+echo "Fill fs with 4K IOs; ENOSPC expected" >> $seqres.full
+dd if=/dev/zero of=$SCRATCH_MNT/tmp2 bs=4K >>$seqres.full 2>&1
 sync
 # Last effort, use O_SYNC
-echo "Fill fs with 4K DIOs; ENOSPC expected" >> $seq.full
-dd if=/dev/zero of=$SCRATCH_MNT/tmp3 bs=4K oflag=sync >>$seq.full 2>&1
+echo "Fill fs with 4K DIOs; ENOSPC expected" >> $seqres.full
+dd if=/dev/zero of=$SCRATCH_MNT/tmp3 bs=4K oflag=sync >>$seqres.full 2>&1
 # Save space usage info
-echo "Post-fill space:" >> $seq.full
-df $SCRATCH_MNT >>$seq.full 2>&1
+echo "Post-fill space:" >> $seqres.full
+df $SCRATCH_MNT >>$seqres.full 2>&1
 
 # Now attempt a write into all of the preallocated space -
 # in a very nasty way, badly fragmenting it and then filling it in.
-echo "Fill in prealloc space; fragment at offsets:" >> $seq.full
+echo "Fill in prealloc space; fragment at offsets:" >> $seqres.full
 for i in `seq 1 2 1023`; do
-       echo -n "$i " >> $seq.full
+       echo -n "$i " >> $seqres.full
        dd if=/dev/zero of=$SCRATCH_MNT/test seek=$i bs=4K count=1 conv=notrunc \
-               >>$seq.full 2>/dev/null || _fail "failed to write to test file"
+               >>$seqres.full 2>/dev/null || _fail "failed to write to test file"
 done
 sync
-echo >> $seq.full
-echo "Fill in prealloc space; fill holes at offsets:" >> $seq.full
+echo >> $seqres.full
+echo "Fill in prealloc space; fill holes at offsets:" >> $seqres.full
 for i in `seq 2 2 1023`; do
-       echo -n "$i " >> $seq.full
+       echo -n "$i " >> $seqres.full
        dd if=/dev/zero of=$SCRATCH_MNT/test seek=$i bs=4K count=1 conv=notrunc \
-               >>$seq.full 2>/dev/null || _fail "failed to fill test file"
+               >>$seqres.full 2>/dev/null || _fail "failed to fill test file"
 done
 sync
-echo >> $seq.full
+echo >> $seqres.full
 
 echo "done"
 exit
index dc1eeeb..2d726fa 100755 (executable)
@@ -25,6 +25,9 @@
 #creator
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -50,38 +53,38 @@ echo "------------------------------"
 echo "write until ENOSPC test"
 echo "------------------------------"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 umount $SCRATCH_DEV 2>/dev/null
-_scratch_mkfs_sized $((2 * 1024 * 1024 * 1024)) >>$seq.full 2>&1
+_scratch_mkfs_sized $((2 * 1024 * 1024 * 1024)) >>$seqres.full 2>&1
 _scratch_mount
 
-dd if=/dev/zero of=$SCRATCH_MNT/tmp1 bs=256K count=1 >>$seq.full 2>&1
+dd if=/dev/zero of=$SCRATCH_MNT/tmp1 bs=256K count=1 >>$seqres.full 2>&1
 [ $? -ne 0 ] && _fail "Error creating file"
 
 # Attempt to completely fill fs
-dd if=/dev/zero of=$SCRATCH_MNT/tmp2 bs=1M >>$seq.full 2>&1
+dd if=/dev/zero of=$SCRATCH_MNT/tmp2 bs=1M >>$seqres.full 2>&1
 sync
-dd if=/dev/zero of=$SCRATCH_MNT/tmp3 bs=4K >>$seq.full 2>&1
+dd if=/dev/zero of=$SCRATCH_MNT/tmp3 bs=4K >>$seqres.full 2>&1
 sync
 # Last effort, use O_SYNC
-dd if=/dev/zero of=$SCRATCH_MNT/tmp4 bs=4K oflag=sync >>$seq.full 2>&1
+dd if=/dev/zero of=$SCRATCH_MNT/tmp4 bs=4K oflag=sync >>$seqres.full 2>&1
 # Save space usage info to the full file
-echo "Pre rm space:" >> $seq.full
-df $SCRATCH_MNT >>$seq.full 2>&1
+echo "Pre rm space:" >> $seqres.full
+df $SCRATCH_MNT >>$seqres.full 2>&1
 
 # Should leave approx 256k free
 rm -f $SCRATCH_MNT/tmp1
 sync
-echo "Post rm space:" >> $seq.full
-df $SCRATCH_MNT >>$seq.full 2>&1
+echo "Post rm space:" >> $seqres.full
+df $SCRATCH_MNT >>$seqres.full 2>&1
 _freespace=`df -k $SCRATCH_MNT | tail -n 1 | awk '{print $4}'`
 [ $_freespace -gt 1024 ] && _fail "could not sufficiently fill filesystem"
 
 # Try a write larger than available space
-dd if=/dev/zero of=$SCRATCH_MNT/tmp1 bs=1M count=1 >>$seq.full 2>&1
-echo "Bytes written until ENOSPC:" >>$seq.full
-du $SCRATCH_MNT/tmp1 >>$seq.full
+dd if=/dev/zero of=$SCRATCH_MNT/tmp1 bs=1M count=1 >>$seqres.full 2>&1
+echo "Bytes written until ENOSPC:" >>$seqres.full
+du $SCRATCH_MNT/tmp1 >>$seqres.full
 
 # And at least some of it should succeed.
 _filesize=`ls -l $SCRATCH_MNT/tmp1 | awk '{print $5}'`
index 8ef809c..2118104 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 status=1       # failure is the default!
index 336bea6..27d5a20 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -51,10 +54,10 @@ _require_freeze
 _supported_os Linux
 _supported_fs generic
 
-rm -f $seq.full
+rm -f $seqres.full
 
 umount $SCRATCH_DEV 2>/dev/null
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount "-o usrquota,grpquota"
 quotacheck -u -g $SCRATCH_MNT 2>/dev/null
 quotaon $SCRATCH_MNT 2>/dev/null
index 3bf080c..71bd688 100644 (file)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -48,7 +51,7 @@ _cleanup()
        eval "rm -f $BASE_TEST_FILE.*"
 }
 
-$here/src/seek_sanity_test $BASE_TEST_FILE > $seq.full 2>&1 ||
+$here/src/seek_sanity_test $BASE_TEST_FILE > $seqres.full 2>&1 ||
        _fail "seek sanity check failed!"
 
 # success, all done
index 1bf0c87..d2acd0f 100644 (file)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -61,11 +64,11 @@ test01()
                write_cmd="$write_cmd -c \"pwrite $offset 1m\""
        done
 
-       echo "*** test01() create sparse file ***" >>$seq.full
-       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seq.full 2>&1 ||
+       echo "*** test01() create sparse file ***" >>$seqres.full
+       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seqres.full 2>&1 ||
                _fail "create sparse file failed!"
-       echo "*** test01() create sparse file done ***" >>$seq.full
-       echo >>$seq.full
+       echo "*** test01() create sparse file done ***" >>$seqres.full
+       echo >>$seqres.full
 
        $here/src/seek_copy_test $src $dest
        
@@ -89,11 +92,11 @@ test02()
                write_cmd="$write_cmd -c \"falloc $offset 3m\" -c \"pwrite $offset 1m\""
        done
 
-       echo "*** test02() create sparse file ***" >>$seq.full
-       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seq.full 2>&1 ||
+       echo "*** test02() create sparse file ***" >>$seqres.full
+       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seqres.full 2>&1 ||
                _fail "create sparse file failed!"
-       echo "*** test02() create sparse file done ***" >>$seq.full
-       echo >>$seq.full
+       echo "*** test02() create sparse file done ***" >>$seqres.full
+       echo >>$seqres.full
 
        $here/src/seek_copy_test $src $dest
 
@@ -132,11 +135,11 @@ test03()
                write_cmd="$write_cmd -c \"pwrite $offset 10m\""
        done
 
-       echo "*** test03() create sparse file ***" >>$seq.full
-       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seq.full 2>&1 ||
+       echo "*** test03() create sparse file ***" >>$seqres.full
+       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seqres.full 2>&1 ||
                _fail "create sparse file failed!"
-       echo "*** test03() create sparse file done ***" >>$seq.full
-       echo >>$seq.full
+       echo "*** test03() create sparse file done ***" >>$seqres.full
+       echo >>$seqres.full
        $here/src/seek_copy_test $src $dest
 
        test $(stat --printf "%s" $src) = $(stat --printf "%s" $dest) ||
@@ -174,11 +177,11 @@ test04()
                write_cmd="$write_cmd -c \"pwrite $offset 2m\""
        done
 
-       echo "*** test04() create sparse file ***" >>$seq.full
-       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seq.full 2>&1 ||
+       echo "*** test04() create sparse file ***" >>$seqres.full
+       eval ${XFS_IO_PROG} -F -f "${write_cmd}" $src >>$seqres.full 2>&1 ||
                _fail "create sparse file failed!"
-       echo "*** test04() create sparse file done ***" >>$seq.full
-       echo >>$seq.full
+       echo "*** test04() create sparse file done ***" >>$seqres.full
+       echo >>$seqres.full
        $here/src/seek_copy_test $src $dest
 
        test $(stat --printf "%s" $src) = $(stat --printf "%s" $dest) ||
@@ -187,7 +190,7 @@ test04()
        cmp $src $dest || _fail "TEST04: file bytes check failed"
 }
 
-rm -f $seq.full
+rm -f $seqres.full
 test01
 test02
 test03
index 9e2e583..b8bea87 100644 (file)
@@ -23,6 +23,9 @@
 
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 status=0
index 3433c9b..618e8a4 100644 (file)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 80aa07e..dba9212 100644 (file)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -114,7 +117,7 @@ _workout()
        echo ""
        echo "Run fio with random aio-dio pattern"
        echo ""
-       cat $tmp-$seq.fio >>  $seq.full
+       cat $tmp-$seq.fio >>  $seqres.full
        run_check $FIO_PROG $tmp-$seq.fio &
        pid=$!
        echo "Start fallocate/truncate loop"
@@ -124,7 +127,7 @@ _workout()
            for ((k=1; k <= NUM_JOBS; k++))
            do
                fallocate -l $FILE_SIZE $SCRATCH_MNT/direct_aio.$k.0 \
-                       >> $seq.full 2>&1
+                       >> $seqres.full 2>&1
            done
            for ((k=1; k <= NUM_JOBS; k++))
            do
@@ -137,7 +140,7 @@ _workout()
        wait $pid
 }
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index 854efc8..efd7ec8 100644 (file)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -127,13 +130,13 @@ _workout()
        echo ""
        echo "Run fio with random aio-dio pattern"
        echo ""
-       cat $tmp-$seq.fio >>  $seq.full
+       cat $tmp-$seq.fio >>  $seqres.full
        run_check $FIO_PROG $tmp-$seq.fio
 }
 
 _require_fio $tmp-$seq.fio
 
-_scratch_mkfs_sized $FS_SIZE >> $seq.full 2>&1
+_scratch_mkfs_sized $FS_SIZE >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index 0be57dd..72e32ca 100644 (file)
@@ -22,6 +22,7 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -49,8 +50,8 @@ _require_scratch
 DEVNULL=$SCRATCH_MNT/devnull
 DEVZERO=$SCRATCH_MNT/devzero
 
-rm -f $seq.full
-_scratch_mkfs > $seq.full 2>&1
+rm -f $seqres.full
+_scratch_mkfs > $seqres.full 2>&1
 _scratch_mount
 
 rm -f $DEVNULL $DEVZERO
index 768b7f0..1701c77 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
 tmp=/tmp/$$
 status=1       # failure is the default!
 trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
-rm -f $seq.full
+rm -f $seqres.full
 
 # get standard environment, filters and checks
 . ./common.rc
@@ -75,18 +76,18 @@ do
        src/devzero -n 20 $SCRATCH_DEV >/dev/null
 
        # create a filesystem of this type
-       echo "=== Creating $fs filesystem..." >>$seq.full
-       echo "    ( $preop mkfs -t $fs $preargs $SCRATCH_DEV $postargs )" >>$seq.full
-       eval $preop mkfs -t $fs $preargs $SCRATCH_DEV $postargs >>$seq.full 2>&1
+       echo "=== Creating $fs filesystem..." >>$seqres.full
+       echo "    ( $preop mkfs -t $fs $preargs $SCRATCH_DEV $postargs )" >>$seqres.full
+       eval $preop mkfs -t $fs $preargs $SCRATCH_DEV $postargs >>$seqres.full 2>&1
 
        if [ $? -eq 0 ] ; then
                # next, ensure we don't overwrite it
-               echo "=== Attempting $FSTYP overwrite of $fs..." >>$seq.full
-               ${MKFS_PROG}.$FSTYP $SCRATCH_DEV >>$seq.full 2>&1
+               echo "=== Attempting $FSTYP overwrite of $fs..." >>$seqres.full
+               ${MKFS_PROG}.$FSTYP $SCRATCH_DEV >>$seqres.full 2>&1
 
                [ $? -eq 0 ] && echo "Failed - overwrote fs type ${fs}!"
        else
-               echo "mkfs of type ${fs} failed" >>$seq.full
+               echo "mkfs of type ${fs} failed" >>$seqres.full
        fi
 done
 
index 07d5a9b..f1eb956 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 
 here=`pwd`
 tmp=/tmp/$$
@@ -73,7 +76,7 @@ _supported_os Linux
 
 [ -x $runas ] || _notrun "$runas executable not found"
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _setup_testdir
 
index 4b46452..6ede97a 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -59,36 +62,36 @@ rm -f $fragfile
 
 # Craft some fragmented files, defrag them, check the result.
 
-echo "zero-length file:" | tee -a $seq.full
+echo "zero-length file:" | tee -a $seqres.full
 touch $fragfile
 _defrag $fragfile
 
-echo "Sparse file (no blocks):" | tee -a $seq.full
+echo "Sparse file (no blocks):" | tee -a $seqres.full
 xfs_io -F -f -c "truncate 1m" $fragfile
 _defrag $fragfile
 
-echo "Contiguous file:" | tee -a $seq.full
+echo "Contiguous file:" | tee -a $seqres.full
 dd if=/dev/zero of=$fragfile bs=4k count=4 &>/dev/null
 _defrag $fragfile
 
-echo "Write backwards sync, but contiguous - should defrag to 1 extent" | tee -a $seq.full
+echo "Write backwards sync, but contiguous - should defrag to 1 extent" | tee -a $seqres.full
 for I in `seq 9 -1 0`; do
        dd if=/dev/zero of=$fragfile bs=4k count=1 conv=notrunc seek=$I oflag=sync &>/dev/null
 done
 _defrag $fragfile
 
-echo "Write backwards sync leaving holes - defrag should do nothing" | tee -a $seq.full
+echo "Write backwards sync leaving holes - defrag should do nothing" | tee -a $seqres.full
 for I in `seq 31 -2 0`; do
        dd if=/dev/zero of=$fragfile bs=4k count=1 conv=notrunc seek=$I oflag=sync &>/dev/null
 done
 _defrag $fragfile
 
-echo "Write forwards sync leaving holes - defrag should do nothing" | tee -a $seq.full
+echo "Write forwards sync leaving holes - defrag should do nothing" | tee -a $seqres.full
 for I in `seq 0 2 31`; do
        dd if=/dev/zero of=$fragfile bs=4k count=1 conv=notrunc seek=$I oflag=sync &>/dev/null
 done
 _defrag $fragfile
 
-rm -f $seq.full
+rm -f $seqres.full
 status=0
 exit
index 6a1b6d7..56ffafc 100755 (executable)
@@ -42,6 +42,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -85,23 +88,23 @@ _check_ext4_eof_flag()
 
     # Ensure that the iflags value was parsed correctly.
     if [ -z ${iflags} ]; then
-      echo "iFlags value was not parsed successfully." >> $seq.full
+      echo "iFlags value was not parsed successfully." >> $seqres.full
       status=1
       exit ${status}
     fi
 
     # Check if EOFBLOCKS_FL is set.
     if ((${iflags} & 0x400000)); then
-      echo "EOFBLOCK_FL bit is set." >> $seq.full
+      echo "EOFBLOCK_FL bit is set." >> $seqres.full
       bit_set=1
     else
-      echo "EOFBLOCK_FL bit is not set." >> $seq.full
+      echo "EOFBLOCK_FL bit is not set." >> $seqres.full
       bit_set=0
     fi
 
     # Check current bit state to expected value.
     if [ ${bit_set} -ne ${2} ]; then
-      echo "Error: Current bit state incorrect." >> $seq.full
+      echo "Error: Current bit state incorrect." >> $seqres.full
       status=1
       exit ${status}
     fi
@@ -121,14 +124,14 @@ _supported_os Linux
 _require_xfs_io_falloc
 
 # Real QA test starts here.
-rm -f $seq.full
+rm -f $seqres.full
 
 # Remove any leftover files from last run.
 rm -f ${TEST_DIR}/test_?
 
 # Begin test cases.
 echo "Test 1: Fallocate 40960 bytes and write 4096 bytes (buffered io)." \
-    >> $seq.full
+    >> $seqres.full
 ${XFS_IO_PROG} -F -f                    \
     -c 'falloc -k 0 40960'              \
     -c 'pwrite 0 4096'                  \
@@ -136,7 +139,7 @@ ${XFS_IO_PROG} -F -f                    \
 _check_ext4_eof_flag test_1 ${BIT_SET}
 
 echo "Test 2: Fallocate 40960 bytes and write 4096 bytes (direct io)." \
-    >> $seq.full
+    >> $seqres.full
 ${XFS_IO_PROG} -F -f -d                 \
     -c 'falloc -k 0 40960'              \
     -c 'pwrite 0 4096'                  \
@@ -144,7 +147,7 @@ ${XFS_IO_PROG} -F -f -d                 \
 _check_ext4_eof_flag test_2 ${BIT_SET}
 
 echo "Test 3: Fallocate 40960 bytes and write 40960 bytes (buffered io)." \
-    >> $seq.full
+    >> $seqres.full
 ${XFS_IO_PROG} -F -f                    \
     -c 'falloc -k 0 40960'              \
     -c 'pwrite 0 40960'                 \
@@ -152,7 +155,7 @@ ${XFS_IO_PROG} -F -f                    \
 _check_ext4_eof_flag test_3 ${BIT_NOT_SET}
 
 echo "Test 4: Fallocate 40960 bytes and write 40960 bytes (direct io)." \
-    >> $seq.full
+    >> $seqres.full
 ${XFS_IO_PROG} -F -f -d                 \
     -c 'falloc -k 0 40960'              \
     -c 'pwrite 0 40960'                 \
@@ -160,7 +163,7 @@ ${XFS_IO_PROG} -F -f -d                 \
 _check_ext4_eof_flag test_4 ${BIT_NOT_SET}
 
 echo "Test 5: Fallocate 128k, seek 256k and write 4k block (buffered io)." \
-    >> $seq.full
+    >> $seqres.full
 ${XFS_IO_PROG} -F -f                    \
     -c 'falloc -k 0 128k'               \
     -c 'pwrite 256k 4k'                 \
@@ -168,7 +171,7 @@ ${XFS_IO_PROG} -F -f                    \
 _check_ext4_eof_flag test_5 ${BIT_NOT_SET}
 
 echo "Test 6: Fallocate 128k, seek to 256k and write a 4k block (direct io)." \
-    >> $seq.full
+    >> $seqres.full
 ${XFS_IO_PROG} -F -f -d                 \
     -c 'falloc -k 0 128k'               \
     -c 'pwrite 256k 4k'                 \
index 9a2a06b..3e2fffc 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -51,11 +54,11 @@ _workout()
                do
                    
                        echo "OP write_opt: $write_opt 4M, \
-chattr_opt: $chattr_opt" >>$seq.full
+chattr_opt: $chattr_opt" >>$seqres.full
                        dd if=/dev/zero of=$SCRATCH_MNT/file.$idx \
                                bs=1M count=4 $write_opt \
-                               >> $seq.full 2>&1 || exit
-                       chattr $chattr_opt $SCRATCH_MNT/file.$idx >> $seq.full \
+                               >> $seqres.full 2>&1 || exit
+                       chattr $chattr_opt $SCRATCH_MNT/file.$idx >> $seqres.full \
                                || exit
                done
        done
@@ -69,11 +72,11 @@ chattr_opt: $chattr_opt" >>$seq.full
                do
 
                        echo "OP write_opt: $write_opt ENOSPC, \
-chattr_opt: $chattr_opt" >>$seq.full
+chattr_opt: $chattr_opt" >>$seqres.full
                        dd if=/dev/zero of=$SCRATCH_MNT/file.$idx \
-                               bs=1M $write_opt >> $seq.full 2>&1
+                               bs=1M $write_opt >> $seqres.full 2>&1
                        chattr $chattr_opt $SCRATCH_MNT/file.$idx \
-                               >> $seq.full || exit
+                               >> $seqres.full || exit
                done
                sync
                unlink $SCRATCH_MNT/file.$idx
@@ -86,7 +89,7 @@ _supported_os Linux
 _need_to_be_root
 _require_scratch
 
-_scratch_mkfs_sized $((64 * 1024 * 1024)) >> $seq.full 2>&1
+_scratch_mkfs_sized $((64 * 1024 * 1024)) >> $seqres.full 2>&1
 _scratch_mount
 
 if ! _workout; then
index 1a7cff5..d3affd2 100755 (executable)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -46,9 +49,9 @@ _supported_fs ext2 ext3 ext4
 _supported_os Linux
 _require_scratch
 
-rm -f $seq.full
+rm -f $seqres.full
 
-_scratch_mkfs >> $seq.full 2>&1
+_scratch_mkfs >> $seqres.full 2>&1
 
 # Get the honest truth about block counts straight from metadata on disk
 TOTAL_BLOCKS=`dumpe2fs -h $SCRATCH_DEV 2>/dev/null \
@@ -94,10 +97,10 @@ _scratch_mount "-o bsddf"
 BSD_F_BLOCKS=`stat -f $SCRATCH_MNT | awk '/^Blocks/{print $3}'`
 umount $SCRATCH_MNT
 
-# Echo data to $seq.full for analysis
-echo "Overhead is $OVERHEAD blocks out of $TOTAL_BLOCKS ($FREE_BLOCKS free)" >> $seq.full
-echo "MINIX free blocks $MINIX_F_BLOCKS" >> $seq.full
-echo "BSD free blocks $BSD_F_BLOCKS" >> $seq.full
+# Echo data to $seqres.full for analysis
+echo "Overhead is $OVERHEAD blocks out of $TOTAL_BLOCKS ($FREE_BLOCKS free)" >> $seqres.full
+echo "MINIX free blocks $MINIX_F_BLOCKS" >> $seqres.full
+echo "BSD free blocks $BSD_F_BLOCKS" >> $seqres.full
 
 # minix should be exactly equal (hence tolerance of 0)
 _within_tolerance "minix f_blocks" $MINIX_F_BLOCKS $TOTAL_BLOCKS 0 -v
index 5d789a0..4609f55 100644 (file)
@@ -22,6 +22,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 status=1       # failure is the default!
index 4cc1a20..d9b5110 100644 (file)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -61,7 +64,7 @@ disallow_fail_make_request()
 start_fail_scratch_dev()
 {
     echo "Force SCRATCH_DEV device failure"
-    echo " echo 1 > /sys/block/$SCRATCH_BDEV/make-it-fail" >> $here/$seq.full
+    echo " echo 1 > /sys/block/$SCRATCH_BDEV/make-it-fail" >> $here/$seqres.full
     echo 1 > /sys/block/$SCRATCH_BDEV/make-it-fail
 
 }
@@ -69,7 +72,7 @@ start_fail_scratch_dev()
 stop_fail_scratch_dev()
 {
     echo "Make SCRATCH_DEV device operable again"
-    echo " echo 0 > /sys/block/$SCRATCH_BDEV/make-it-fail" >> $here/$seq.full
+    echo " echo 0 > /sys/block/$SCRATCH_BDEV/make-it-fail" >> $here/$seqres.full
     echo 0 > /sys/block/$SCRATCH_BDEV/make-it-fail
 
 }
@@ -138,12 +141,12 @@ _workout()
        echo ""
        echo "Start fsstress.."
        echo ""
-       echo "fsstress $args" >> $here/$seq.full
+       echo "fsstress $args" >> $here/$seqres.full
        $FSSTRESS_PROG $args > /dev/null 2>&1 &
        fs_pid=$!
        echo "Start fio.."
-       cat $tmp-$seq.fio >>  $seq.full
-       $FIO_PROG $tmp-$seq.fio >> $here/$seq.full 2>&1 &
+       cat $tmp-$seq.fio >>  $seqres.full
+       $FIO_PROG $tmp-$seq.fio >> $here/$seqres.full 2>&1 &
        fio_pid=$!
 
        # Let's it work for awhile, and force device failure
@@ -153,7 +156,7 @@ _workout()
        # that so buffered write(2) may succeed, but any integrity operations
        # such as (sync, fsync, fdatasync, direct-io) should fail.
        dd if=/dev/zero of=$SCRATCH_MNT/touch_failed_filesystem count=1 bs=4k conv=fsync \
-           >> $here/$seq.full 2>&1 && \
+           >> $here/$seqres.full 2>&1 && \
            _fail "failed: still able to perform integrity fsync on $SCRATCH_MNT"
 
        kill $fs_pid
@@ -175,7 +178,7 @@ _workout()
 
 # real QA test starts here
 
-_scratch_mkfs >> $here/$seq.full 2>&1 || _fail "mkfs failed"
+_scratch_mkfs >> $here/$seqres.full 2>&1 || _fail "mkfs failed"
 _scratch_mount || _fail "mount failed"
 allow_fail_make_request
 _workout
index 58d2a95..504ed08 100755 (executable)
@@ -30,6 +30,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -268,7 +271,7 @@ _check_udf_filesystem $SCRATCH_DEV
 
 # optional stuff if your test has verbose output to help resolve problems
 #echo
-#echo "If failure, check $seq.full (this) and $seq.full.ok (reference)"
+#echo "If failure, check $seqres.full (this) and $seqres.full.ok (reference)"
 
 # success, all done
 status=0
index 0d274e5..10694cc 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 68407a7..bd0399c 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 79b6bc5..1d44b93 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 # get standard environment, filters and checks
index d75c3c0..076fc4b 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -39,8 +42,8 @@ trap "_cleanup" 0 1 2 3 15
 
 _populate_scratch()
 {
-       echo "=== mkfs output ===" >>$seq.full
-       _scratch_mkfs_xfs | tee -a $seq.full | _filter_mkfs 2>$tmp.mkfs
+       echo "=== mkfs output ===" >>$seqres.full
+       _scratch_mkfs_xfs | tee -a $seqres.full | _filter_mkfs 2>$tmp.mkfs
        . $tmp.mkfs
        _scratch_mount
        dd if=/dev/zero of=$SCRATCH_MNT/foo count=200 bs=4096 >/dev/null 2>&1 &
@@ -64,7 +67,7 @@ _need_to_be_root
 _require_scratch
 _require_no_large_scratch_dev
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _populate_scratch
 
@@ -72,16 +75,16 @@ _populate_scratch
 
 eval `$DF_PROG $SCRATCH_MNT 2>&1 \
        | tail -1 | $AWK_PROG '{ printf "blocks=%u used=%u avail=%u\n", $3, $4, $5 }'`
-echo "df gave: blocks=$blocks used=$used avail=$avail" >>$seq.full
-echo "blocksize from mkfs is '$dbsize'" >>$seq.full
+echo "df gave: blocks=$blocks used=$used avail=$avail" >>$seqres.full
+echo "blocksize from mkfs is '$dbsize'" >>$seqres.full
 
 xfs_db -r -c "freesp -s" $SCRATCH_DEV >$tmp.xfs_db
-echo "xfs_db for $SCRATCH_DEV" >>$seq.full
-cat $tmp.xfs_db >>$seq.full
+echo "xfs_db for $SCRATCH_DEV" >>$seqres.full
+cat $tmp.xfs_db >>$seqres.full
 
 eval `$XFS_IO_PROG -x -c resblks $SCRATCH_MNT 2>&1 \
        | $AWK_PROG '/available/ { printf "resblks=%u\n", $5 }'`
-echo "resblks gave: resblks=$resblks" >>$seq.full
+echo "resblks gave: resblks=$resblks" >>$seqres.full
 
 # check the 'blocks' field from freesp command is OK
 # since 2.6.18, df does not report the 4 blocks per AG that cannot
index 0dee9f5..be37202 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 1883f15..7528f34 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 10498d5..8cd0e7d 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 538ba14..20ea752 100755 (executable)
@@ -36,6 +36,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -72,7 +75,7 @@ _init()
     if _scratch_mkfs_xfs -N -K $force_opts >/dev/null 2>&1; then
         force_opts="-K $force_opts"
     fi
-    echo mkfs_xfs $force_opts $SCRATCH_DEV >>$seq.full
+    echo mkfs_xfs $force_opts $SCRATCH_DEV >>$seqres.full
     _scratch_mkfs_xfs $force_opts >$tmp.mkfs0 2>&1
     [ $? -ne 0 ] && \
         _notrun "Cannot mkfs for this test using MKFS_OPTIONS specified"
@@ -163,8 +166,8 @@ _check_corrupt()
 {
     f="c6c6c6c6"
     echo "*** check for corruption"
-    echo "expect $f..." >>$seq.full
-    xfs_db -r -c "fsblock $2" -c "print" $1 | head | tee -a $seq.full | \
+    echo "expect $f..." >>$seqres.full
+    xfs_db -r -c "fsblock $2" -c "print" $1 | head | tee -a $seqres.full | \
         grep -q -v "$f $f $f $f $f $f $f $f" && \
             _fail "!!! block $2 corrupted!"
 }
@@ -177,7 +180,7 @@ _check_corrupt()
 _supported_fs xfs
 _supported_os Linux
 
-rm -f $seq.full
+rm -f $seqres.full
 
 # mkfs sizes
 log_size=2097152
@@ -187,15 +190,15 @@ _require_scratch
 _init
 
 block=`_after_log $SCRATCH_DEV`
-echo "fsblock after log = $block"               >>$seq.full
+echo "fsblock after log = $block"               >>$seqres.full
 _check_corrupt $SCRATCH_DEV $block
 
 actual_log_size=`_log_size`
-echo "log size = $actual_log_size BB"                      >>$seq.full
+echo "log size = $actual_log_size BB"                      >>$seqres.full
 head=`_log_head`
-echo "log position = $head"                     >>$seq.full
+echo "log position = $head"                     >>$seqres.full
 lsunit=`_log_sunit`
-echo "log sunit = $lsunit"                     >>$seq.full
+echo "log sunit = $lsunit"                     >>$seqres.full
 
 # sanity checks
 [ $actual_log_size -eq $log_size_bb ] || \
@@ -206,36 +209,36 @@ echo "log sunit = $lsunit"                        >>$seq.full
 # find how how many blocks per op for 100 ops
 # ignore the fact that it will also include an unmount record etc...
 # this should be small overall
-echo "    lots of traffic for sampling" >>$seq.full
+echo "    lots of traffic for sampling" >>$seqres.full
 sample_size_ops=100
 _log_traffic $sample_size_ops
 head1=`_log_head`
 num_blocks=`expr $head1 - $head`
 blocks_per_op=`echo "scale=3; $num_blocks / $sample_size_ops" | bc`
-echo "blocks_per_op = $blocks_per_op" >>$seq.full
+echo "blocks_per_op = $blocks_per_op" >>$seqres.full
 num_expected_ops=`echo "$log_size_bb / $blocks_per_op" | bc`
-echo "num_expected_ops = $num_expected_ops" >>$seq.full
+echo "num_expected_ops = $num_expected_ops" >>$seqres.full
 num_expected_to_go=`echo "$num_expected_ops - $sample_size_ops" | bc`
-echo "num_expected_to_go = $num_expected_to_go" >>$seq.full
+echo "num_expected_to_go = $num_expected_to_go" >>$seqres.full
 
-echo "    lots more traffic" >>$seq.full
+echo "    lots more traffic" >>$seqres.full
 _log_traffic $num_expected_to_go
 head=`_log_head`
-echo "log position = $head"                     >>$seq.full
+echo "log position = $head"                     >>$seqres.full
 
 # e.g. 3891
 near_end_min=`echo "0.95 * $log_size_bb" | bc | sed 's/\..*//'`
-echo "near_end_min = $near_end_min" >>$seq.full
+echo "near_end_min = $near_end_min" >>$seqres.full
 
 [ $head -gt $near_end_min -a $head -lt $log_size_bb ] || \
     _fail "!!! unexpected near end log position $head"
 
 for c in `seq 0 20`
 do
-    echo "   little traffic"            >>$seq.full
+    echo "   little traffic"            >>$seqres.full
     _log_traffic 2
     head=`_log_head`
-    echo "log position = $head"         >>$seq.full
+    echo "log position = $head"         >>$seqres.full
     _check_corrupt $SCRATCH_DEV $block
 done
 
index 2b91b33..4ab1dc2 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -52,13 +55,13 @@ _require_no_large_scratch_dev
 
 echo "*** init FS"
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
-echo "*** MKFS ***"                         >>$seq.full
-echo ""                                     >>$seq.full
-_scratch_mkfs_xfs                           >>$seq.full 2>&1 \
+echo "*** MKFS ***"                         >>$seqres.full
+echo ""                                     >>$seqres.full
+_scratch_mkfs_xfs                           >>$seqres.full 2>&1 \
     || _fail "mkfs failed"
-_scratch_mount                              >>$seq.full 2>&1 \
+_scratch_mount                              >>$seqres.full 2>&1 \
     || _fail "mount failed"
 
 echo "*** test"
@@ -67,21 +70,21 @@ for l in 0 1 2 3 4
 do
         echo "    *** test $l"
        FSSTRESS_ARGS=`_scale_fsstress_args -d $SCRATCH_MNT -n 1000 $FSSTRESS_AVOID`
-        $FSSTRESS_PROG  $FSSTRESS_ARGS >>$seq.full
+        $FSSTRESS_PROG  $FSSTRESS_ARGS >>$seqres.full
 
         _scratch_mount -o remount,ro \
             || _fail "remount ro failed"
 
-        echo ""                                 >>$seq.full
-        echo "*** xfs_logprint ***"             >>$seq.full
-        echo ""                                 >>$seq.full
-        _scratch_xfs_logprint -tb               | tee -a $seq.full \
+        echo ""                                 >>$seqres.full
+        echo "*** xfs_logprint ***"             >>$seqres.full
+        echo ""                                 >>$seqres.full
+        _scratch_xfs_logprint -tb               | tee -a $seqres.full \
             | head | grep -q "<CLEAN>" || _fail "DIRTY LOG"
 
-        echo ""                             >>$seq.full
-        echo "*** XFS_CHECK ***"            >>$seq.full
-        echo ""                             >>$seq.full
-        _scratch_xfs_check                  >>$seq.full 2>&1 \
+        echo ""                             >>$seqres.full
+        echo "*** XFS_CHECK ***"            >>$seqres.full
+        echo ""                             >>$seqres.full
+        _scratch_xfs_check                  >>$seqres.full 2>&1 \
             || _fail "xfs_check failed"
         _scratch_mount -o remount,rw \
             || _fail "remount rw failed"
@@ -89,6 +92,6 @@ done
 
 echo "*** done"
 # happy exit
-rm -f $seq.full
+rm -f $seqres.full
 status=0
 exit 0
index 156cc1d..d684ccd 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -47,7 +50,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fs xfs
 _supported_os IRIX Linux
 # prelim
-rm -f $seq.full $tmp.*
+rm -f $seqres.full $tmp.*
 _require_scratch
 _require_v2log
 
index 3bedc05..4f5916b 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
 tmp=/tmp/$$
-seqfull="$seq.full"
+seqfull="$seqres.full"
 status=1       # failure is the default!
 # get standard environment, filters and checks
 . ./common.rc
index 18fe40e..d9fa4f4 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -78,7 +81,7 @@ _supported_os Linux
 _require_scratch
 _require_attrs
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
 
 echo "*** mkfs"
@@ -124,7 +127,7 @@ echo ""
 inum_2=`ls -li $testfile.2 | $AWK_PROG '{ print $1 }'`
 
 echo "*** unmount FS"
-umount $SCRATCH_DEV >>$seq.full 2>&1 \
+umount $SCRATCH_DEV >>$seqres.full 2>&1 \
        || _fail "umount failed"
 
 echo "*** dump attributes (1)"
index 962316f..a733f5b 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 3e7fdd2..9cea5a7 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index b7f1c10..ee1339c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -42,11 +45,11 @@ _require_tape $TAPE_DEV
 _create_dumpdir_fill
 # ensure file/dir timestamps precede dump timestamp
 sleep 2
-src/bstat $SCRATCH_MNT >>$here/$seq.full
+src/bstat $SCRATCH_MNT >>$here/$seqres.full
 _erase_hard
 _do_dump
 _append_dumpdir_fill
-src/bstat $SCRATCH_MNT >>$here/$seq.full
+src/bstat $SCRATCH_MNT >>$here/$seqres.full
 _erase_hard
 _do_dump -l 1
 _do_restore
index 4ccb5de..5a3b0bc 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 37a23cc..73feb6b 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 772705d..71ca7f3 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 0bf042f..acbbcd5 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -59,7 +62,7 @@ while [ $i -lt 5 ]; do
     let i=$i+1
 done
 
-echo "middate = $middate" >>$seq.full
+echo "middate = $middate" >>$seqres.full
 
 #
 # Now do the xfsinvutil and
index 70c0d10..83dddb4 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 080d3fe..4918ef2 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 422a271..467638f 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
 tmp=/tmp/$$
 status=1       # failure is the default!
 trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
-rm -f $seq.full
+rm -f $seqres.full
 
 # get standard environment, filters and checks
 . ./common.rc
@@ -41,15 +44,15 @@ _link_out_file $seq.out
 
 _check_repair()
 {
-       echo "Repairing, round 0" >> $seq.full
-       _scratch_xfs_repair 2>&1 | _filter_repair | tee -a $seq.full >$tmp.0
+       echo "Repairing, round 0" >> $seqres.full
+       _scratch_xfs_repair 2>&1 | _filter_repair | tee -a $seqres.full >$tmp.0
        for i in 1 2 3 4
        do
-               echo "Repairing, iteration $i" | tee -a $seq.full
+               echo "Repairing, iteration $i" | tee -a $seqres.full
                _scratch_xfs_repair 2>&1 | _filter_repair >$tmp.$i
-               diff $tmp.0 $tmp.$i >> $seq.full
+               diff $tmp.0 $tmp.$i >> $seqres.full
                if [ $? -ne 0 ]; then
-                       echo "ERROR: repair round $i differs to round 0 (see $seq.full)" | tee -a $seq.full
+                       echo "ERROR: repair round $i differs to round 0 (see $seqres.full)" | tee -a $seqres.full
                        break
                fi
                # echo all interesting stuff...
index dc5a32d..208ed8f 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 27f3f22..46e65a0 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -50,13 +53,13 @@ _require_scratch
 
 echo "*** init FS"
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
-echo "*** MKFS ***"                         >>$seq.full
-echo ""                                     >>$seq.full
-_scratch_mkfs_xfs                           >>$seq.full 2>&1 \
+echo "*** MKFS ***"                         >>$seqres.full
+echo ""                                     >>$seqres.full
+_scratch_mkfs_xfs                           >>$seqres.full 2>&1 \
     || _fail "mkfs failed"
-_scratch_mount                              >>$seq.full 2>&1 \
+_scratch_mount                              >>$seqres.full 2>&1 \
     || _fail "mount failed"
 
 echo "*** test"
@@ -69,7 +72,7 @@ then
     exit
 fi
 
-if ! src/xfsctl $SCRATCH_MNT $SCRATCH_MNT/fish >>$seq.full 2>&1
+if ! src/xfsctl $SCRATCH_MNT $SCRATCH_MNT/fish >>$seqres.full 2>&1
 then
     echo "!!! failed to run xfsctl test program"
     exit
index b2fc417..bec87ca 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index e9bb411..056ce99 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index e2e71c5..e2b193a 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index b62a4c9..217fa6f 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 428e8bb..d5982f0 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 0021c22..a6e98e3 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -49,9 +52,9 @@ trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
 # real QA test starts here
 cd "$WORKAREA/xfstests"
 echo Silence is golden.
-perl tools/srcdiff -q >$seq.full
-if ! diff $seq.full $seq.good >/dev/null; then
-    echo "FAILED: srcdiff output $seq.full differs to $seq.good"
+perl tools/srcdiff -q >$seqres.full
+if ! diff $seqres.full $seq.good >/dev/null; then
+    echo "FAILED: srcdiff output $seqres.full differs to $seq.good"
     exit 1
 fi
 
index a9a9a23..aa73245 100755 (executable)
@@ -25,6 +25,9 @@
 set +x
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -59,7 +62,7 @@ _fill()
 }
 
 _do_die_on_error=message_only
-rm -f $seq.full
+rm -f $seqres.full
 agsize=32
 echo -n "Make $agsize megabyte filesystem on SCRATCH_DEV and mount... "
 _scratch_mkfs_xfs -dsize=${agsize}m,agcount=1 2>&1 >/dev/null || _fail "mkfs failed"
@@ -84,7 +87,7 @@ do
     echo "done"
     echo -n "Check files... "
     if ! _do "src/fill2fs_check $tmp.manifest"; then
-      echo "fail (see $seq.full)"
+      echo "fail (see $seqres.full)"
       _do "cat $tmp.manifest"
       _do "ls -altrR $SCRATCH_MNT"
       _do "dd if=$SCRATCH_DEV bs=4096 count=$grow_size | gzip -9 > $seq.fsimage.gz"
index 15fa5dc..5a60da1 100755 (executable)
@@ -26,6 +26,9 @@
 set +x
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -86,7 +89,7 @@ _cull_files()
 # create 3 minimum sized (16Mb) allocation groups
 # xfs_repair is going to need three to verify the superblock
 
-rm -f $seq.full
+rm -f $seqres.full
 _do_die_on_error=message_only
 
 echo -n "Make a 48 megabyte filesystem on SCRATCH_DEV and mount... "
@@ -147,7 +150,7 @@ echo -n "Check fill file... "
 _do "sum $SCRATCH_MNT/fill >$tmp.fillsum2"
 if ! _do "diff $tmp.fillsum1 $tmp.fillsum2"; then
     echo "fail"
-    echo "Fill file is corrupt/missing after fsr. Test failed see $seq.full"
+    echo "Fill file is corrupt/missing after fsr. Test failed see $seqres.full"
     status=1; exit
 fi
 echo "done"
@@ -157,7 +160,7 @@ echo -n "Check large file... "
 _do "sum $SCRATCH_MNT/fragmented >$tmp.sum2"
 if ! _do "diff $tmp.sum1 $tmp.sum2"; then
     echo "fail"
-    echo "File is corrupt/missing after fsr. Test failed see $seq.full"
+    echo "File is corrupt/missing after fsr. Test failed see $seqres.full"
     status=1; exit
 fi
 echo "done"
index ef92c0a..35b195b 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index d0d8bd8..369454c 100755 (executable)
@@ -27,6 +27,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index c20e3a8..c8e19a4 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index fb83b7a..1420a3f 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 7c5e896..4891c6c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -59,7 +62,7 @@ while [ $i -lt 5 ]; do
     let i=$i+1
 done
 
-echo "middate = $middate" >>$seq.full
+echo "middate = $middate" >>$seqres.full
 
 # Only say No to 1st question to prune
 cat >$tmp.input <<EOF
index 6139361..30e16ee 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 144cc71..8591c36 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 _cleanup()
@@ -32,10 +35,10 @@ _cleanup()
     umount -d $SCRATCH_MNT/test > /dev/null 2>&1
     rm -f $tmp.*
 
-    if [ -w $seq.full ]
+    if [ -w $seqres.full ]
     then
-        echo "--- mounts at end (after cleanup)" >> $seq.full
-        mount >> $seq.full
+        echo "--- mounts at end (after cleanup)" >> $seqres.full
+        mount >> $seqres.full
     fi
 }
 
@@ -55,7 +58,7 @@ _supported_os Linux
 _log()
 {
     echo "--- $*"
-    echo "--- $*" >> $seq.full
+    echo "--- $*" >> $seqres.full
 }
 
 _require_nonexternal
@@ -64,75 +67,75 @@ _require_no_large_scratch_dev
 _require_loop
 _require_ext2
 
-rm -f $seq.full
+rm -f $seqres.full
 
-echo "(dev=$SCRATCH_DEV, mount=$SCRATCH_MNT)" >> $seq.full
-echo "" >> $seq.full
+echo "(dev=$SCRATCH_DEV, mount=$SCRATCH_MNT)" >> $seqres.full
+echo "" >> $seqres.full
 
-echo "--- mounts" >> $seq.full
-mount >> $seq.full
+echo "--- mounts" >> $seqres.full
+mount >> $seqres.full
 
 _log "Create ext2 fs on scratch"
-mkfs -t ext2 -F $SCRATCH_DEV >> $seq.full 2>&1 \
+mkfs -t ext2 -F $SCRATCH_DEV >> $seqres.full 2>&1 \
     || _fail "!!! failed to mkfs ext2"
 
 _log "Mount ext2 fs on scratch"
-mount -t ext2 $SCRATCH_DEV $SCRATCH_MNT >> $seq.full 2>&1 \
+mount -t ext2 $SCRATCH_DEV $SCRATCH_MNT >> $seqres.full 2>&1 \
     || _fail "!!! failed to mount"
 
 _log "Create xfs fs in file on scratch"
 ${MKFS_PROG}.xfs -f -dfile,name=$SCRATCH_MNT/test.xfs,size=40m \
-    >> $seq.full 2>&1 \
+    >> $seqres.full 2>&1 \
     || _fail "!!! failed to mkfs xfs"
 
 _log "Make mount points"
-mkdir $SCRATCH_MNT/test $SCRATCH_MNT/test2 >> $seq.full 2>&1 \
+mkdir $SCRATCH_MNT/test $SCRATCH_MNT/test2 >> $seqres.full 2>&1 \
     || _fail "!!! failed to make mount points"
 
 _log "Mount xfs via loop"
-mount -t xfs -o loop $SCRATCH_MNT/test.xfs $SCRATCH_MNT/test >> $seq.full 2>&1 \
+mount -t xfs -o loop $SCRATCH_MNT/test.xfs $SCRATCH_MNT/test >> $seqres.full 2>&1 \
     || _fail "!!! failed to loop mount xfs"
 
 _log "stress"
-$FSSTRESS_PROG -d $SCRATCH_MNT/test -n 1000 $FSSTRESS_AVOID >> $seq.full 2>&1 \
+$FSSTRESS_PROG -d $SCRATCH_MNT/test -n 1000 $FSSTRESS_AVOID >> $seqres.full 2>&1 \
     || _fail "!!! stress failed"
 
 _log "clean"
-rm -rf $SCRATCH_MNT/test/* >> $seq.full 2>&1 \
+rm -rf $SCRATCH_MNT/test/* >> $seqres.full 2>&1 \
     || _fail "!!! clean failed"
 
 _log "create file for ext2 fs"
-dd if=/dev/zero of=$SCRATCH_MNT/test/test.ext2 bs=1024 count=10240 >> $seq.full 2>&1 \
+dd if=/dev/zero of=$SCRATCH_MNT/test/test.ext2 bs=1024 count=10240 >> $seqres.full 2>&1 \
     || _fail "!!! create file failed"
 
 _log "Create ext2 fs in file on looped xfs"
-echo y | mkfs -t ext2 $SCRATCH_MNT/test/test.ext2 >> $seq.full 2>&1 \
+echo y | mkfs -t ext2 $SCRATCH_MNT/test/test.ext2 >> $seqres.full 2>&1 \
     || _fail "!!! failed to mkfs ext2 on xfs"
 
 _log "Mount ext2 on xfs via loop"
-mount -t ext2 -o loop $SCRATCH_MNT/test/test.ext2 $SCRATCH_MNT/test2 >> $seq.full 2>&1 \
+mount -t ext2 -o loop $SCRATCH_MNT/test/test.ext2 $SCRATCH_MNT/test2 >> $seqres.full 2>&1 \
     || _fail "!!! failed to loop mount xfs"
 
 _log "stress ext2 on xfs via loop"
-$FSSTRESS_PROG -d $SCRATCH_MNT/test2 -n 1000 $FSSTRESS_AVOID >> $seq.full 2>&1 \
+$FSSTRESS_PROG -d $SCRATCH_MNT/test2 -n 1000 $FSSTRESS_AVOID >> $seqres.full 2>&1 \
     || _fail "!!! stress ext2 failed"
 
 _log "clean"
-rm -rf $SCRATCH_MNT/test/* >> $seq.full 2>&1 \
+rm -rf $SCRATCH_MNT/test/* >> $seqres.full 2>&1 \
     || _fail "!!! clean failed"
 
 _log "umount ext2 on xfs"
-umount -d $SCRATCH_MNT/test2 >> $seq.full 2>&1 \
+umount -d $SCRATCH_MNT/test2 >> $seqres.full 2>&1 \
     || _fail "!!! umount ext2 failed"
 
 _log "umount xfs"
-umount -d $SCRATCH_MNT/test >> $seq.full 2>&1 \
+umount -d $SCRATCH_MNT/test >> $seqres.full 2>&1 \
     || _fail "!!! umount xfs failed"
 
-echo "--- mounts at end (before cleanup)" >> $seq.full
-mount >> $seq.full
+echo "--- mounts at end (before cleanup)" >> $seqres.full
+mount >> $seqres.full
 
-rm -f $seq.full
+rm -f $seqres.full
 # success, all done
 status=0
 exit
index 29c103b..d5da34a 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -49,8 +52,8 @@ _supported_fs xfs
 _supported_os Linux IRIX
 
 
-cp /dev/null $seq.full
-chmod a+rwx $seq.full  # arbitrary users will write here
+cp /dev/null $seqres.full
+chmod a+rwx $seqres.full       # arbitrary users will write here
 
 _require_scratch
 _require_xfs_quota
@@ -100,7 +103,7 @@ _filter_and_check_blks()
 _exercise()
 {
        _scratch_mkfs_xfs | _filter_mkfs 2>$tmp.mkfs
-       cat $tmp.mkfs >>$seq.full
+       cat $tmp.mkfs >>$seqres.full
 
        # keep the blocksize and data size for dd later
        . $tmp.mkfs
@@ -117,20 +120,20 @@ _exercise()
 
        _qsetup
 
-       echo "Using output from '" `ls -l $seq.out` "'" >>$seq.full
-       echo "and using type=$type id=$id" >>$seq.full
+       echo "Using output from '" `ls -l $seq.out` "'" >>$seqres.full
+       echo "and using type=$type id=$id" >>$seqres.full
 
        echo
-       echo "*** report no quota settings" | tee -a $seq.full
+       echo "*** report no quota settings" | tee -a $seqres.full
        xfs_quota -D $tmp.projects -P $tmp.projid -x \
                -c "repquota -birnN -$type" $SCRATCH_DEV |
                _filter_report | LC_COLLATE=POSIX sort -ru
 
        echo
-       echo "*** report initial settings" | tee -a $seq.full
+       echo "*** report initial settings" | tee -a $seqres.full
        _file_as_id $SCRATCH_MNT/initme $id $type 1024 0
-       echo "ls -l $SCRATCH_MNT" >>$seq.full
-       ls -l $SCRATCH_MNT >>$seq.full
+       echo "ls -l $SCRATCH_MNT" >>$seqres.full
+       ls -l $SCRATCH_MNT >>$seqres.full
        xfs_quota -D $tmp.projects -P $temp.projid -x \
                -c "limit -$type bsoft=${bsoft}k bhard=${bhard}k $id" \
                -c "limit -$type isoft=$isoft ihard=$ihard $id" \
@@ -140,7 +143,7 @@ _exercise()
                _filter_report | LC_COLLATE=POSIX sort -ru
 
        echo
-       echo "*** push past the soft inode limit" | tee -a $seq.full
+       echo "*** push past the soft inode limit" | tee -a $seqres.full
        _file_as_id $SCRATCH_MNT/softie1 $id $type 1024 0
        _file_as_id $SCRATCH_MNT/softie2 $id $type 1024 0
        _qmount
@@ -149,7 +152,7 @@ _exercise()
                _filter_report | LC_COLLATE=POSIX sort -ru
 
        echo
-       echo "*** push past the soft block limit" | tee -a $seq.full
+       echo "*** push past the soft block limit" | tee -a $seqres.full
        _file_as_id $SCRATCH_MNT/softie $id $type 1024 140
        _qmount
        xfs_quota -D $tmp.projects -P $tmp.projid -x \
@@ -158,7 +161,7 @@ _exercise()
 
        echo
        # Note: for quota accounting (not enforcement), EDQUOT is not expected
-       echo "*** push past the hard inode limit (expect EDQUOT)" | tee -a $seq.full
+       echo "*** push past the hard inode limit (expect EDQUOT)" | tee -a $seqres.full
        for i in 1 2 3 4 5 6 7 8 9 10 11 12
        do
                _file_as_id $SCRATCH_MNT/hard$i $id $type 1024 0
@@ -170,10 +173,10 @@ _exercise()
 
        echo
        # Note: for quota accounting (not enforcement), EDQUOT is not expected
-       echo "*** push past the hard block limit (expect EDQUOT)" | tee -a $seq.full
+       echo "*** push past the hard block limit (expect EDQUOT)" | tee -a $seqres.full
        _file_as_id $SCRATCH_MNT/softie $id $type 1024 540
-       echo "ls -l $SCRATCH_MNT" >>$seq.full
-       ls -l $SCRATCH_MNT >>$seq.full
+       echo "ls -l $SCRATCH_MNT" >>$seqres.full
+       ls -l $SCRATCH_MNT >>$seqres.full
        _qmount
        xfs_quota -D $tmp.projects -P $tmp.projid -x \
                -c "repquota -birnN -$type" $SCRATCH_DEV |
index 01d5469..7655d85 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -49,7 +52,7 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fs xfs
 _supported_os IRIX Linux
 
-rm -f $seq.full
+rm -f $seqres.full
 
 _require_scratch
 _require_xfs_quota
@@ -59,8 +62,8 @@ _require_nobody
 _qmount_option uquota
 
 _scratch_mkfs_xfs | _filter_mkfs 2>$tmp.mkfs
-cat $tmp.mkfs >>$seq.full
-chmod a+w $seq.full     # arbitrary users will write here
+cat $tmp.mkfs >>$seqres.full
+chmod a+w $seqres.full     # arbitrary users will write here
 
 # keep the blocksize from mkfs ($dbsize)
 . $tmp.mkfs
@@ -94,7 +97,7 @@ xfs_quota -x \
 
 # cross check blks, softblks, hardblks <-> quota, xfs_db
 xfs_quota -c "quota -$type -birnN $id" $SCRATCH_DEV |
-                       tr -d '\n' | tr -s '[:space:]' | tee -a $seq.full |
+                       tr -d '\n' | tr -s '[:space:]' | tee -a $seqres.full |
        perl -ne 'if (m[^\s*'$SCRATCH_DEV'\s+(\d+)\s+(\d+)\s+(\d+)]) {
                print "used_blocks=", $1, "\n";
                print "soft_blocks=", $2, "\n";
@@ -102,14 +105,14 @@ xfs_quota -c "quota -$type -birnN $id" $SCRATCH_DEV |
                $next = 0;
        }' | LC_COLLATE=POSIX sort >$tmp.quota
 
-echo ===quota output >> $seq.full
-cat $tmp.quota >> $seq.full
+echo ===quota output >> $seqres.full
+cat $tmp.quota >> $seqres.full
 [ ! -s $tmp.quota ] && echo "warning: quota output file is empty"
 
 umount $SCRATCH_MNT
 
 # note - does (insitu) conversion from fs blocks to 1K blocks
-xfs_db -rc "dquot -$type $id" -c p $SCRATCH_DEV | tee -a $seq.full | perl -ne '
+xfs_db -rc "dquot -$type $id" -c p $SCRATCH_DEV | tee -a $seqres.full | perl -ne '
        if (/^diskdq.bcount = (\d+)$/) {
                 print "used_blocks=", $1 * '$dbsize' / 1024, "\n";
        }
@@ -120,8 +123,8 @@ xfs_db -rc "dquot -$type $id" -c p $SCRATCH_DEV | tee -a $seq.full | perl -ne '
                print "soft_blocks=", $1 * '$dbsize' / 1024, "\n";
        }' | LC_COLLATE=POSIX sort >$tmp.xfs_db
 
-echo ===xfs_db output >> $seq.full
-cat $tmp.xfs_db >> $seq.full
+echo ===xfs_db output >> $seqres.full
+cat $tmp.xfs_db >> $seqres.full
 [ ! -s $tmp.xfs_db ] && echo "warning: xfs_db output file is empty"
 
 echo Comparing out of xfs_quota and xfs_db
index 1ce6180..b92d6fe 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -46,8 +49,8 @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fs xfs
 _supported_os Linux IRIX
 
-cp /dev/null $seq.full
-chmod ugo+rwx $seq.full
+cp /dev/null $seqres.full
+chmod ugo+rwx $seqres.full
 
 _require_scratch
 _require_xfs_quota
@@ -98,7 +101,7 @@ _exercise()
        umount $SCRATCH_MNT 2>/dev/null
 }
 
-_scratch_mkfs_xfs >> $seq.full 2>&1 || _fail "mkfs failed!"
+_scratch_mkfs_xfs >> $seqres.full 2>&1 || _fail "mkfs failed!"
 
 _qmount_option "uquota,gquota"
 _qmount
index 965b43a..8c648c8 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index be65bfb..dfab653 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index faa4776..bc53579 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index dfce43b..8d4a1aa 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index a2a07c9..36ba942 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index f0d9870..9bcc9aa 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index fa98085..88cd8ff 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index cdaf524..46e4bac 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index c7e727c..4f2143d 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -66,14 +69,14 @@ while [ $i -le 9 ]; do
     _stable_fs
     sleep 2
 
-    echo "********* level $i ***********" >>$seq.full
-    date >>$seq.full
+    echo "********* level $i ***********" >>$seqres.full
+    date >>$seqres.full
     find $SCRATCH_MNT -exec $here/src/lstat64 {} \; | sed 's/(00.*)//' >$tmp.dates.$i
     if [ $i -gt 0 ]; then
        let level_1=$i-1
-       diff -c $tmp.dates.$level_1 $tmp.dates.$i >>$seq.full
+       diff -c $tmp.dates.$level_1 $tmp.dates.$i >>$seqres.full
     else
-       cat $tmp.dates.$i >>$seq.full
+       cat $tmp.dates.$i >>$seqres.full
     fi
 
     _do_dump_file -f $tmp.df.level$i -l $i
index 12f2ac9..d3efdac 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 7a68f79..130b685 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index baaed77..dd20b8a 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -46,14 +49,14 @@ _require_scratch
 
 # set up fs for 1K inodes
 isize=0
-_scratch_mkfs_xfs | _filter_mkfs >$seq.full 2>$tmp.mkfs
+_scratch_mkfs_xfs | _filter_mkfs >$seqres.full 2>$tmp.mkfs
 [ $? -eq 0 ] && source $tmp.mkfs
 if [ "$isize" -lt 1024 ]; then
-    _scratch_mkfs_xfs -i size=1024 >>$here/$seq.full \
+    _scratch_mkfs_xfs -i size=1024 >>$here/$seqres.full \
        || _notrun "Cannot mkfs for this test using MKFS_OPTIONS specified"
 fi
-_scratch_mount >>$here/$seq.full || _fail "mount failed"
-xfs_info $SCRATCH_MNT >>$here/$seq.full
+_scratch_mount >>$here/$seqres.full || _fail "mount failed"
+xfs_info $SCRATCH_MNT >>$here/$seqres.full
 cd $SCRATCH_MNT
 
 echo ""
index c135d1a..c4c37bc 100755 (executable)
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
-rm -f $seq.full
+rm -f $seqres.full
 
 here=`pwd`
 tmp=/tmp/$$
@@ -81,19 +84,19 @@ write_block()
     [ `$direct` ] && flags=-d
 
     echo "Writing $bytes bytes, offset is $words (direct=$direct)" | _filter_io
-    echo "Writing $bytes bytes at $location $words (direct=$direct)" >>$seq.full
+    echo "Writing $bytes bytes at $location $words (direct=$direct)" >>$seqres.full
     $XFS_IO_PROG -c "pwrite $offset 512" $flags $SCRATCH_MNT/$seq \
-       2>&1 | _filter_off $offset | tee -a $seq.full | _filter_pwrite
-    xfs_bmap -v $SCRATCH_MNT/$seq >>$seq.full
+       2>&1 | _filter_off $offset | tee -a $seqres.full | _filter_pwrite
+    xfs_bmap -v $SCRATCH_MNT/$seq >>$seqres.full
 
     echo "Reading $bytes bytes (direct=$direct)" | _filter_io
-    echo "Reading $bytes bytes at $location (direct=$direct)" >>$seq.full
+    echo "Reading $bytes bytes at $location (direct=$direct)" >>$seqres.full
     $XFS_IO_PROG -c "pread $offset $bytes" $flags $SCRATCH_MNT/$seq \
-       2>&1 | _filter_off $offset | tee -a $seq.full | _filter_pread
+       2>&1 | _filter_off $offset | tee -a $seqres.full | _filter_pread
 
-    $XFS_IO_PROG -c "pread -v $offset $bytes" $flags $SCRATCH_MNT/$seq >>$seq.full 2>&1
+    $XFS_IO_PROG -c "pread -v $offset $bytes" $flags $SCRATCH_MNT/$seq >>$seqres.full 2>&1
 
-    echo | tee -a $seq.full
+    echo | tee -a $seqres.full
 }
 
 # real QA test starts here
index 930a983..5c796a9 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 _cleanup()
@@ -49,7 +52,7 @@ _supported_os IRIX Linux
 
 _require_scratch
 
-rm -f $seq.full
+rm -f $seqres.full
 umount $SCRATCH_DEV >/dev/null 2>&1
 
 _scratch_mkfs_xfs >/dev/null   || _fail "mkfs failed"
index 3a5129f..bdc4dc2 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 901723e..a897e60 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 3243fe1..952d31e 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index f0ee819..316172c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -50,7 +53,7 @@ _cleanup()
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
 # prelim
-rm -f $seq.full $tmp.*
+rm -f $seqres.full $tmp.*
 _require_scratch
 _require_xfs_quota
 _require_v2log
index e21a793..d38fb0c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -48,7 +51,7 @@ _supported_fs xfs
 _supported_os IRIX Linux
 
 # prelim
-rm -f $seq.full $tmp.*
+rm -f $seqres.full $tmp.*
 _require_scratch
 _require_v2log 
 
index ba5743a..d4482f8 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 44123ad..c72d94e 100755 (executable)
@@ -26,6 +26,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -42,24 +45,24 @@ trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
 _supported_fs xfs
 _supported_os IRIX Linux
 
-rm -f $seq.full
+rm -f $seqres.full
 rm -f $tmp.log
 
 _require_scratch
 
 echo "mkfs"
-_scratch_mkfs_xfs >>$seq.full 2>&1 \
+_scratch_mkfs_xfs >>$seqres.full 2>&1 \
     || _fail "mkfs scratch failed"
 
 echo "mount"
-_scratch_mount >>$seq.full 2>&1 \
+_scratch_mount >>$seqres.full 2>&1 \
     || _fail "mount failed: $MOUNT_OPTIONS"
 
 echo "touch files"
 touch $SCRATCH_MNT/{0,1,2,3,4,5,6,7,8,9}{0,1,2,3,4,5,6,7,8,9}
 
 echo "godown"
-src/godown -v -f $SCRATCH_MNT >> $seq.full
+src/godown -v -f $SCRATCH_MNT >> $seqres.full
 
 echo "unmount"
 umount $SCRATCH_MNT
@@ -75,7 +78,7 @@ if false; then
 fi
 
 echo "mount with replay"
-_scratch_mount $mnt >>$seq.full 2>&1 \
+_scratch_mount $mnt >>$seqres.full 2>&1 \
     || _fail "mount failed: $mnt $MOUNT_OPTIONS"
 
 echo "ls SCRATCH_MNT"
index b59ad0a..b58780a 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -41,7 +44,7 @@ trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
 _supported_fs xfs
 _supported_os IRIX Linux
 
-rm -f $seq.full $tmp.*
+rm -f $seqres.full $tmp.*
 _require_scratch
 _require_v2log
 
@@ -83,7 +86,7 @@ for s in sync nosync ; do
 
        # mkfs the FS
        _echofull "mkfs"
-       _scratch_mkfs_xfs >>$seq.full 2>&1
+       _scratch_mkfs_xfs >>$seqres.full 2>&1
        if [ $? -ne 0 ] ; then 
            _echofull "mkfs failed: $MKFS_OPTIONS"
            continue
@@ -91,7 +94,7 @@ for s in sync nosync ; do
 
        # mount the FS
        _echofull "mount"
-       if ! _scratch_mount >>$seq.full 2>&1; then
+       if ! _scratch_mount >>$seqres.full 2>&1; then
            _echofull "mount failed: $MOUNT_OPTIONS"
            continue
        fi
@@ -116,17 +119,17 @@ for s in sync nosync ; do
        ls $SCRATCH_MNT
 
        _echofull "godown"
-       src/godown -v -f $SCRATCH_MNT >> $seq.full
+       src/godown -v -f $SCRATCH_MNT >> $seqres.full
 
        _echofull "unmount"
-       umount $SCRATCH_DEV >>$seq.full 2>&1 \
+       umount $SCRATCH_DEV >>$seqres.full 2>&1 \
            || _fail "umount failed"
 
        _echofull "logprint after going down..."
        _print_logstate
 
        _echofull "mount with replay"
-       _scratch_mount >>$seq.full 2>&1 \
+       _scratch_mount >>$seqres.full 2>&1 \
            || _fail "mount failed: $MOUNT_OPTIONS"
 
        # check on what FS looks like after log recovery
index 3cb6990..43c23f0 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -46,7 +49,7 @@ _do_meta()
            -f rename=30 -f stat=30 -f unlink=30 -f truncate=20"
     _echofull "calling fsstress $param -m8 -n $count"
     FSSTRESS_ARGS=`_scale_fsstress_args $param $FSSTRESS_AVOID -m 8 -n $count -d $out`
-    if ! $FSSTRESS_PROG $FSSTRESS_ARGS >>$seq.full 2>&1
+    if ! $FSSTRESS_PROG $FSSTRESS_ARGS >>$seqres.full 2>&1
     then
        _echofull "fsstress failed"
     fi
@@ -56,7 +59,7 @@ _do_meta()
 _supported_fs xfs
 _supported_os IRIX Linux
 
-rm -f $seq.full $tmp.*
+rm -f $seqres.full $tmp.*
 _require_scratch
 _require_v2log 
 _require_xfs_quota
@@ -91,7 +94,7 @@ do
 
     # mkfs the FS
     _echofull "mkfs"
-    _scratch_mkfs_xfs >>$seq.full 2>&1
+    _scratch_mkfs_xfs >>$seqres.full 2>&1
     if [ $? -ne 0 ] ; then 
        _echofull "mkfs failed: $MKFS_OPTIONS"
        continue
@@ -99,7 +102,7 @@ do
 
     # mount the FS
     _echofull "mount"
-    if ! _scratch_mount -o uquota >>$seq.full 2>&1; then
+    if ! _scratch_mount -o uquota >>$seqres.full 2>&1; then
        _echofull "mount failed: $MOUNT_OPTIONS"
        continue
     fi
@@ -112,20 +115,20 @@ do
     ls -RF $SCRATCH_MNT >$tmp.ls1
 
     _echofull "godown"
-    src/godown -v -f $SCRATCH_MNT >> $seq.full
+    src/godown -v -f $SCRATCH_MNT >> $seqres.full
 
     _echofull "unmount"
-    umount $SCRATCH_DEV >>$seq.full 2>&1 \
+    umount $SCRATCH_DEV >>$seqres.full 2>&1 \
        || _fail "umount failed"
 
     _echofull "logprint after going down..."
     _print_logstate
 
     _full "logprint headers"
-    _scratch_xfs_logprint -n >>$seq.full 2>&1
+    _scratch_xfs_logprint -n >>$seqres.full 2>&1
 
     _echofull "mount with replay"
-    _scratch_mount -o uquota >>$seq.full 2>&1 \
+    _scratch_mount -o uquota >>$seqres.full 2>&1 \
        || _fail "mount failed: $MOUNT_OPTIONS"
 
     # check on what FS looks like after log recovery
index 8ce50c0..4b006d4 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 2f849f3..76aa5c1 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 4f4cf34..04b096c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 9de4476..f31a88a 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index d06bd59..9bb6b91 100755 (executable)
@@ -24,6 +24,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -63,7 +66,7 @@ _cleanup()
 #
 _mkfs_filter()
 {
-   tee -a $seq.full | \
+   tee -a $seqres.full | \
    sed \
        -e 's/extsz=[0-9][0-9]*[ ]*/extsz=N, /' \
        -e 's/blocks=[0-9][0-9]*/blocks=N/' \
@@ -89,7 +92,7 @@ _mkfs_filter()
 }
 
 # real QA test starts here
-rm -f $seq.full
+rm -f $seqres.full
 
 # Modify as appropriate.
 _supported_fs xfs
index 02c3f9d..0753f8a 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 59db760..3af52c7 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -37,7 +40,7 @@ trap "rm -f $tmp.*; exit \$status" 0 1 2 3 15
 _create_scratch()
 {
        echo "*** mkfs"
-       _scratch_mkfs_xfs $@ | tee -a $seq.full | _filter_mkfs 2>$tmp.mkfs
+       _scratch_mkfs_xfs $@ | tee -a $seqres.full | _filter_mkfs 2>$tmp.mkfs
        . $tmp.mkfs
 
        echo "*** mount"
@@ -64,13 +67,13 @@ _stress_scratch()
        # -w ensures that the only ops are ones which cause write I/O
        FSSTRESS_ARGS=`_scale_fsstress_args -d $SCRATCH_MNT -w -p $procs \
            -n $nops $FSSTRESS_AVOID`
-       $FSSTRESS_PROG $FSSTRESS_ARGS >> $seq.full &
+       $FSSTRESS_PROG $FSSTRESS_ARGS >> $seqres.full &
 }
 
 # real QA test starts here
 _supported_fs xfs
 _require_scratch
-_scratch_mkfs_xfs | tee -a $seq.full | _filter_mkfs 2>$tmp.mkfs
+_scratch_mkfs_xfs | tee -a $seqres.full | _filter_mkfs 2>$tmp.mkfs
 . $tmp.mkfs    # extract blocksize and data size for scratch device
 
 endsize=`expr 550 \* 1048576`  # stop after growing this big
@@ -95,19 +98,19 @@ _fill_scratch $fillsize
 #
 while [ $size -le $endsize ]; do
        echo "*** stressing a ${size} byte filesystem"
-       echo "*** stressing a ${sizeb} block filesystem" >> $seq.full
+       echo "*** stressing a ${sizeb} block filesystem" >> $seqres.full
        _stress_scratch
        sleep 1
        size=`expr $size + $incsize`
        sizeb=`expr $size / $dbsize`    # in data blocks
        echo "*** growing to a ${size} byte filesystem"
-       echo "*** growing to a ${sizeb} block filesystem" >> $seq.full
+       echo "*** growing to a ${sizeb} block filesystem" >> $seqres.full
        xfs_growfs -D ${sizeb} $SCRATCH_MNT \
-               | tee -a $seq.full | _filter_mkfs 2>$tmp.growfs
+               | tee -a $seqres.full | _filter_mkfs 2>$tmp.growfs
        . $tmp.growfs
        [ `expr $size % $modsize` -eq 0 ] && wait       # every 4th iteration
-       echo AGCOUNT=$agcount | tee -a $seq.full
-       echo && echo >> $seq.full
+       echo AGCOUNT=$agcount | tee -a $seqres.full
+       echo && echo >> $seqres.full
 done
 wait   # stop for any remaining stress processes
 
index e8f1d45..58d753b 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -44,7 +47,7 @@ _require_xfs_quota
 
 # real QA test starts here
 _scratch_mkfs_xfs | _filter_mkfs 2>$tmp.mkfs
-cat $tmp.mkfs >$seq.full
+cat $tmp.mkfs >$seqres.full
 . $tmp.mkfs
 
 # setup a default run
@@ -115,7 +118,7 @@ s/Inode: \#\d+ \(\d+ blocks, \d+ extents\)/Inode: #[INO] (X blocks, Y extents)/;
 test_quot()
 {
        echo "checking quot command (type=$type)"  # not deterministic on blks
-       xfs_quota -x -c "quot -n -$type" $SCRATCH_MNT >>$seq.full 2>&1
+       xfs_quota -x -c "quot -n -$type" $SCRATCH_MNT >>$seqres.full 2>&1
 }
 
 test_report()
index 2c98b57..7abee5e 100755 (executable)
@@ -25,6 +25,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -56,7 +59,7 @@ _require_xfs_quota
 
 # real QA test starts here
 _scratch_mkfs_xfs | _filter_mkfs 2>$tmp.mkfs
-cat $tmp.mkfs >$seq.full
+cat $tmp.mkfs >$seqres.full
 . $tmp.mkfs
 
 # setup a default run
@@ -72,7 +75,7 @@ _require_prjquota $SCRATCH_DEV
 echo "### create projects file"
 rm -f $tmp.projects
 target=$SCRATCH_MNT/project
-echo "6:$target" | tee -a $seq.full > $tmp.projects
+echo "6:$target" | tee -a $seqres.full > $tmp.projects
 
 echo "### populate filesystem"
 mkdir $target          || exit
index 6b656e6..9f23150 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -57,15 +60,15 @@ test_files()
 test_accounting()
 {
        echo "### some controlled buffered, direct and mmapd IO (type=$type)"
-       echo "--- initiating parallel IO..." >>$seq.full
+       echo "--- initiating parallel IO..." >>$seqres.full
        $XFS_IO_PROG -c 'pwrite -b 1m 0 16m' -c 'fsync' \
-                                       $SCRATCH_MNT/buffer >>$seq.full 2>&1 &
+                                       $SCRATCH_MNT/buffer >>$seqres.full 2>&1 &
        $XFS_IO_PROG -c 'pwrite -b 1m 0 16m' -d \
-                                       $SCRATCH_MNT/direct >>$seq.full 2>&1 &
+                                       $SCRATCH_MNT/direct >>$seqres.full 2>&1 &
        $XFS_IO_PROG -c 't 16m' -c 'mm -rw 0 16m' -c 'mw 0 16m' -c 'ms -s' \
-                                       $SCRATCH_MNT/mmap   >>$seq.full 2>&1 &
+                                       $SCRATCH_MNT/mmap   >>$seqres.full 2>&1 &
        wait
-       echo "--- completed parallel IO ($type)" >>$seq.full
+       echo "--- completed parallel IO ($type)" >>$seqres.full
 
        for file in $SCRATCH_MNT/{buffer,direct,mmap}; do
                $here/src/lstat64 $file | head -3 | _filter_scratch
@@ -80,10 +83,10 @@ _qmount
 _require_prjquota $SCRATCH_DEV
 
 # real QA test starts here
-rm -f $tmp.projects $seq.full
+rm -f $tmp.projects $seqres.full
 umount $SCRATCH_DEV 2>/dev/null
 _scratch_mkfs_xfs | _filter_mkfs 2>$tmp.mkfs
-cat $tmp.mkfs >>$seq.full
+cat $tmp.mkfs >>$seqres.full
 _scratch_mount
 
 uid=1
index 56364f4..0a115b7 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
@@ -102,7 +105,7 @@ fi
 umount $SCRATCH_DEV
 
 _scratch_mkfs_xfs -dsize=160m,agcount=4 $faststart | _filter_mkfs 2>$tmp.mkfs
-cat $tmp.mkfs >>$seq.full
+cat $tmp.mkfs >>$seqres.full
 _scratch_mount
 
 populate
index 8749afa..52c782c 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index 8f4c142..94fd93f 100755 (executable)
@@ -23,6 +23,9 @@
 #
 
 seq=`basename $0`
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
+seqres=$RESULT_DIR/$seq
 echo "QA output created by $seq"
 
 here=`pwd`
index a4ba98d..61dd781 100755 (executable)
+++ b/