tests/xfs/013

   1 #!/bin/bash
   2 # FS QA Test No. xfs/013
   3 #
   4 # Exercise the free inode btree (finobt). XFS allocates physical inodes in
   5 # chunks of 64. Inode records with at least one free inode are stored in the
   6 # finobt to optimize free inode lookup. This test runs a workload that creates
   7 # and modifies a sparsely allocated set of inodes in combination with an
   8 # fsstress workload.
   9 #
  10 #-----------------------------------------------------------------------
  11 # Copyright (c) 2014 Red Hat, Inc.  All Rights Reserved.
  12 #
  13 # This program is free software; you can redistribute it and/or
  14 # modify it under the terms of the GNU General Public License as
  15 # published by the Free Software Foundation.
  16 #
  17 # This program is distributed in the hope that it would be useful,
  18 # but WITHOUT ANY WARRANTY; without even the implied warranty of
  19 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  20 # GNU General Public License for more details.
  21 #
  22 # You should have received a copy of the GNU General Public License
  23 # along with this program; if not, write the Free Software Foundation,
  24 # Inc.,  51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
  25 #
  26 #-----------------------------------------------------------------------
  27 #
  28
  29 seq=`basename $0`
  30 seqres=$RESULT_DIR/$seq
  31 echo "QA output created by $seq"
  32
  33 here=`pwd`
  34 tmp=/tmp/$$
  35 status=1        # failure is the default!
  36
  37 # get standard environment, filters and checks
  38 . ./common/rc
  39 . ./common/filter
  40
  41 _cleanup()
  42 {
  43         $KILLALL_PROG -9 fsstress 2>/dev/null
  44         wait
  45         cd /
  46         _scratch_unmount 2>/dev/null
  47         rm -f $tmp.*
  48 }
  49 trap "_cleanup; exit \$status" 0 1 2 3 15
  50
  51 _create()
  52 {
  53         dir=$1
  54         count=$2
  55
  56         mkdir -p $dir
  57         for i in $(seq 0 $count)
  58         do
  59                 touch $dir/$i
  60         done
  61 }
  62
  63 _rand_replace()
  64 {
  65         dir=$1
  66         count=$2
  67
  68         # replace 5% of the dataset
  69         for i in $(seq 0 $((count / 20)))
  70         do
  71                 file=$((RANDOM % count))
  72                 rm -f $dir/$file
  73                 touch $dir/$file
  74         done
  75 }
  76
  77 _cleaner()
  78 {
  79         dir=$1
  80         iters=$2
  81         mindirs=$3
  82
  83         iters=$((iters - mindirs))
  84
  85         for i in $(seq 1 $iters)
  86         do
  87                 need=$dir/dir$((i + mindirs))
  88                 while [ ! -e $need ]
  89                 do
  90                         sleep 3
  91                         if ! pgrep fsstress > /dev/null 2>&1; then
  92                                 echo "fsstress died?"
  93                                 return
  94                         fi
  95                 done
  96
  97                 rm -rf $dir/dir$i
  98         done
  99 }
 100
 101 # real QA test starts here
 102 _supported_fs xfs
 103 _supported_os Linux
 104
 105 _require_scratch
 106 _require_xfs_mkfs_finobt
 107 _require_xfs_finobt
 108 _require_command "$KILLALL_PROG" killall
 109
 110 rm -f $seqres.full
 111
 112 _scratch_mkfs_xfs "-m crc=1,finobt=1 -d agcount=2" | \
 113         _filter_mkfs 2>> $seqres.full
 114 _scratch_mount
 115
 116 COUNT=20000     # number of files per directory
 117 LOOPS=15        # last loop iteration
 118 MINDIRS=2       # number of dirs for the cleaner to leave trailing behind the
 119                 # most recent (no less than 2 to prevent an rm from trampling a
 120                 # clone)
 121
 122 # create initial directory
 123 _create $SCRATCH_MNT/dir1 $COUNT
 124
 125 # start background cleaner to remove old directories as new ones are created
 126 _cleaner $SCRATCH_MNT $LOOPS $MINDIRS &
 127
 128 # start a background stress workload on the fs
 129 $FSSTRESS_PROG -d $SCRATCH_MNT/fsstress -n 9999999 -p 2 -S t \
 130         >> $seqres.full 2>&1 &
 131
 132 # Each cycle clones the current directory and makes a random file replacement
 133 # pass on the new directory. The directory is copied to the next using hard
 134 # links. The replacement pass then randomly removes and replaces ~5% of the
 135 # content in the directory. Files replaced as such are effectively marked to be
 136 # freed by the background cleaner as it moves forward and removes all of the
 137 # previous hard links to the inode. Over several iterations, this workload
 138 # creates a sparsely located set of a free inodes across the set and uses the
 139 # finobt to allocate new inodes for replacement.
 140
 141 for i in $(seq 1 $LOOPS)
 142 do
 143         # hard link the content of the current directory to the next
 144         cp -Rl $SCRATCH_MNT/dir$i $SCRATCH_MNT/dir$((i+1))
 145
 146         # do a random replacement of files in the new directory
 147         _rand_replace $SCRATCH_MNT/dir$((i+1)) $COUNT
 148 done
 149
 150 $KILLALL_PROG fsstress
 151 wait
 152
 153 # clean out the competing fsstress allocations, then everything else
 154 rm -rf $SCRATCH_MNT/fsstress
 155 rm -rf $SCRATCH_MNT/dir*
 156
 157 _scratch_unmount
 158
 159 status=0
 160 exit