tests/xfs/071

   1 #! /bin/bash
   2 # SPDX-License-Identifier: GPL-2.0
   3 # Copyright (c) 2000-2003 Silicon Graphics, Inc.  All Rights Reserved.
   4 #
   5 # FS QA Test No. 071
   6 #
   7 # Exercise IO at large file offsets.
   8 seqfull=$0
   9 seq=`basename $0`
  10 seqres=$RESULT_DIR/$seq
  11 echo "QA output created by $seq"
  12 rm -f $seqres.full
  13
  14 here=`pwd`
  15 tmp=/tmp/$$
  16 status=1        # failure is the default!
  17
  18 _cleanup()
  19 {
  20     cd /
  21     rm -f $tmp.*
  22     _scratch_unmount 2>/dev/null
  23 }
  24 trap "_cleanup; exit \$status" 0 1 2 3 15
  25
  26 # get standard environment, filters and checks
  27 . ./common/rc
  28 . ./common/filter
  29
  30 bitsperlong=`$here/src/feature -w`
  31 # link correct .out file
  32 rm -f $seqfull.out
  33 if [ "$bitsperlong" -eq 32 ]; then
  34         ln -s $seq.out.32 $seqfull.out
  35 else
  36         ln -s $seq.out.64 $seqfull.out
  37 fi
  38
  39 _filter_io()
  40 {
  41     sed -e "s/$dbsize/1FSB/g" -e '/.* ops; /d'
  42 }
  43
  44 _filter_off()
  45 {
  46     sed -e "s/$1/<OFFSET>/g" | _filter_io
  47 }
  48
  49 _filter_pwrite()
  50 {
  51         sed -e "s/pwrite.*: Invalid argument/pwrite: File too large/g"
  52 }
  53
  54 _filter_pread()
  55 {
  56         sed -e "s/pread.*: Invalid argument/read 0\/$bytes bytes at offset <OFFSET>/g" | _filter_io
  57 }
  58
  59 write_block()
  60 {
  61     location=$1
  62     words=$2
  63     offset=$3
  64     bytes=$4
  65     direct=$5
  66
  67     [ `$direct` ] && flags=-d
  68
  69     echo "Writing $bytes bytes, offset is $words (direct=$direct)" | _filter_io
  70     echo "Writing $bytes bytes at $location $words (direct=$direct)" >>$seqres.full
  71     $XFS_IO_PROG -c "pwrite $offset 512" $flags $SCRATCH_MNT/$seq \
  72         2>&1 | _filter_off $offset | tee -a $seqres.full | _filter_pwrite
  73     xfs_bmap -v $SCRATCH_MNT/$seq >>$seqres.full
  74
  75     echo "Reading $bytes bytes (direct=$direct)" | _filter_io
  76     echo "Reading $bytes bytes at $location (direct=$direct)" >>$seqres.full
  77     $XFS_IO_PROG -c "pread $offset $bytes" $flags $SCRATCH_MNT/$seq \
  78         2>&1 | _filter_off $offset | tee -a $seqres.full | _filter_pread
  79
  80     $XFS_IO_PROG -c "pread -v $offset $bytes" $flags $SCRATCH_MNT/$seq >>$seqres.full 2>&1
  81
  82     echo | tee -a $seqres.full
  83 }
  84
  85 # real QA test starts here
  86 _supported_fs xfs
  87
  88 [ -n "$XFS_IO_PROG" ] || _notrun "xfs_io executable not found"
  89
  90 _require_scratch
  91 _scratch_mkfs_xfs | _filter_mkfs 2>$tmp.mkfs
  92 . $tmp.mkfs
  93 echo
  94 _scratch_mount
  95
  96 # Okay... filesize limit depends on blocksize, bits per long and
  97 # also if large block device patch is enabled (can't dynamically
  98 # check that, so use env var USE_LBD_PATCH to override default).
  99 #
 100 # Note:
 101 # We check from 1Tb below our guessed limit to 1Tb above it, and
 102 # see what happens for each 1Tb increment along the way (first
 103 # half should succeed, second half should fail to create a file).
 104 # So, number calculated here is not the actual limit, its a ways
 105 # above that, hopefully.
 106
 107 if [ "$bitsperlong" -eq 32 ]; then
 108     upperbound=`expr $dbsize / 512`
 109     # which is 8(TB) for 4K, 4(TB) for 2k, ... etc.
 110     [ "$USE_LBD_PATCH" = yes ] && upperbound=16
 111     # limited by page cache index when LBD patch onboard.
 112 else
 113     upperbound=`echo 8 \* 1024 \* 1024 | bc`
 114     # 8 exabytes (working in TBs below)
 115 fi
 116
 117 # Step from (upperbound-1)(Tb) through (upperbound+1(Tb), &
 118 # seeks/writes/reads on each boundary (using holey files) -
 119 # 1byte back from the boundary, and 1FSB back from the same
 120 # boundary (and stash xfs_bmap output), before moving onto
 121 # each new test point.
 122
 123 $XFS_IO_PROG -c "truncate 0" -f $SCRATCH_MNT/$seq
 124
 125 oneTB=`echo 1024 \* 1024 \* 1024 \* 1024 | bc`
 126 count=`expr $upperbound - 1`
 127 upperbound=`expr $upperbound + 1`
 128
 129 while [ $count -le $upperbound ]
 130 do
 131     # buffered IO
 132     offset=`echo $oneTB \* $count | bc`
 133     write_block $count "+0" $offset 512 false
 134     offset=`echo $oneTB \* $count \- 1 | bc`
 135     write_block $count "minus 1 byte" $offset 512 false
 136     offset=`echo $oneTB \* $count \- $dbsize | bc`
 137     write_block $count "minus 1FSB" $offset 512 false
 138     write_block $count "minus 1FSB" $offset 1 false
 139
 140     # direct IO
 141     offset=`echo $oneTB \* $count | bc`
 142     write_block $count "+0" $offset $dbsize true
 143     offset=`echo $oneTB \* $count \- 1 | bc`
 144     write_block $count "minus 1FSB" $offset $dbsize true
 145
 146     echo === Iterating, `expr $upperbound - $count` remains
 147     echo
 148     echo
 149     let count=$count+1
 150 done
 151
 152 # success, all done
 153 status=0
 154 exit