2 # FS QA Test No. xfs/014
4 # Test the behavior of XFS dynamic speculative preallocation at ENOSPC and
5 # EDQUOT conditions. Speculative preallocation allocates post-EOF space to files
6 # as they are extended. This test creates conditions where an fs is near a space
7 # limit with lingering, relatively significant preallocations and verifies that
8 # new writers reclaim said preallocations rather than prematurely fail with
11 #-----------------------------------------------------------------------
12 # Copyright (c) 2014 Red Hat, Inc. All Rights Reserved.
14 # This program is free software; you can redistribute it and/or
15 # modify it under the terms of the GNU General Public License as
16 # published by the Free Software Foundation.
18 # This program is distributed in the hope that it would be useful,
19 # but WITHOUT ANY WARRANTY; without even the implied warranty of
20 # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
21 # GNU General Public License for more details.
23 # You should have received a copy of the GNU General Public License
24 # along with this program; if not, write the Free Software Foundation,
25 # Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
27 #-----------------------------------------------------------------------
31 seqres=$RESULT_DIR/$seq
32 echo "QA output created by $seq"
36 status=1 # failure is the default!
38 # get standard environment, filters and checks
46 umount $LOOP_MNT 2>/dev/null
47 umount $SCRATCH_MNT 2>/dev/null
50 trap "_cleanup; exit \$status" 0 1 2 3 15
52 # Create a file using a repeated open, extending write and close pattern. This
53 # causes the preallocation to persist after the file is closed. Preallocation
54 # will not be reclaimed unless the inode is evicted or we hit an allocation
62 # a few file extending open-write-close cycles should be enough to
63 # trigger the fs to retain preallocation. write 256k in 32k intervals to
65 for i in $(seq 0 32768 262144); do
66 $XFS_IO_PROG -f -c "pwrite $i 32k" $file >> $seqres.full
69 # write a 4k aligned amount of data to keep the calculations simple
70 $XFS_IO_PROG -c "pwrite 0 128m" $file >> $seqres.full
72 size=`stat -c "%s" $file`
73 blocks=`stat -c "%b" $file`
74 blocksize=`stat -c "%B" $file`
76 prealloc_size=$((blocks * blocksize - size))
77 if [ $prealloc_size -eq 0 ]; then
78 echo "Warning: No speculative preallocation for $file." \
79 "Check use of the allocsize= mount option."
82 # keep a running total of how much preallocation we've created
83 TOTAL_PREALLOC=$((TOTAL_PREALLOC + prealloc_size))
90 # allocate all but 10MB of available space
91 freesp=`$DF_PROG -m $dir | $AWK_PROG '/^\// { print $5 - 10 }'`
92 $XFS_IO_PROG -f -c "falloc 0 ${freesp}M" $dir/spc
95 # Create several files with preallocation and consume the remaining free space
96 # via fallocate to the put the fs at ENOSPC. Create a set of background writers
97 # to write into ENOSPC and cause the preallocation to be reclaimed and
98 # reallocated to the new writers.
106 for i in $(seq 0 3); do
107 _spec_prealloc_file $dir/pre$i
110 _consume_free_space $dir
112 # consume 1/2 of the current preallocation across the set of 4 writers
113 write_size=$((TOTAL_PREALLOC / 2 / 4))
114 for i in $(seq 0 3); do
115 $XFS_IO_PROG -f -c "pwrite 0 $write_size" $dir/file.$i \
122 # Create preallocations accounted by both user and group quotas. Set the
123 # associated quota hard limits to put them at EDQUOT. Verify that a new writer
124 # reclaims the preallocated space and proceeds without error.
132 _spec_prealloc_file $dir/user
133 chown $qa_user $dir/user
135 _spec_prealloc_file $dir/group
136 chgrp $qa_group $dir/group
138 # writing to a file under both quotas means both will be reclaimed on
141 chown $qa_user $dir/file
142 chgrp $qa_group $dir/file
144 # put both quotas at EDQUOT
145 blks=`$XFS_QUOTA_PROG -xc "quota -u $qa_user" $dir | \
146 tail -n 1 | awk '{ print $2 }'`
147 $XFS_QUOTA_PROG -xc "limit -u bhard=${blks}k $qa_user" $dir
148 blks=`$XFS_QUOTA_PROG -xc "quota -g $qa_grup" $dir | \
149 tail -n 1 | awk '{ print $2 }'`
150 $XFS_QUOTA_PROG -xc "limit -g bhard=${blks}k $qa_group" $dir
152 # each quota has a single file worth of preallocation to reclaim. leave
153 # some wiggle room and write to 1/3 the total.
154 write_size=$((TOTAL_PREALLOC / 3))
155 $XFS_IO_PROG -c "pwrite 0 $write_size" $dir/file >> $seqres.full
158 # real QA test starts here
163 _require_xfs_io_command "falloc"
171 echo "Silence is golden."
173 _scratch_mkfs_xfs >> $seqres.full 2>&1
176 # make sure the background eofblocks scanner doesn't interfere
177 orig_sp_time=`cat /proc/sys/fs/xfs/speculative_prealloc_lifetime`
178 echo 9999 > /proc/sys/fs/xfs/speculative_prealloc_lifetime
180 LOOP_FILE=$SCRATCH_MNT/$seq.fs
181 LOOP_MNT=$SCRATCH_MNT/$seq.mnt
183 $MKFS_XFS_PROG -d "file=1,name=$LOOP_FILE,size=10g" >> $seqres.full 2>&1
186 mount -t xfs -o loop,uquota,gquota $LOOP_FILE $LOOP_MNT || \
187 _fail "Failed to mount loop fs."
189 _test_enospc $LOOP_MNT
190 _test_edquot $LOOP_MNT
194 echo $orig_sp_time > /proc/sys/fs/xfs/speculative_prealloc_lifetime