xfs: skip tests that rely on allocation behaviors of the data device
[xfstests-dev.git] / tests / xfs / 444
1 #! /bin/bash
2 # SPDX-License-Identifier: GPL-2.0
3 # Copyright (c) 2018 Oracle, Inc.
4 #
5 # FS QA Test No. 444
6 #
7 # Make sure XFS can fix a v5 AGFL that wraps over the last block.
8 # Refer to commit 96f859d52bcb ("libxfs: pack the agfl header structure so
9 # XFS_AGFL_SIZE is correct") for details on the original on-disk format error
10 # and the patch "xfs: detect agfl count corruption and reset agfl") for details
11 # about the fix.
12 #
13 seq=`basename $0`
14 seqres=$RESULT_DIR/$seq
15 echo "QA output created by $seq"
16
17 here=`pwd`
18 tmp=/tmp/$$
19 status=1
20 trap "_cleanup; rm -f $tmp.*; exit \$status" 0 1 2 3 15
21
22 _cleanup()
23 {
24         cd /
25         rm -f $tmp.*
26 }
27
28 rm -f $seqres.full
29
30 # get standard environment, filters and checks
31 . ./common/rc
32 . ./common/filter
33
34 # real QA test starts here
35 _supported_fs xfs
36 _supported_os Linux
37
38 _require_check_dmesg
39 _require_scratch
40 _require_test_program "punch-alternating"
41 _require_xfs_io_command "falloc"
42 _require_xfs_db_write_array
43 _require_no_rtinherit
44
45 # This is only a v5 filesystem problem
46 _require_scratch_xfs_crc
47
48 mount_loop() {
49         if ! _try_scratch_mount >> $seqres.full 2>&1; then
50                 echo "scratch mount failed" >> $seqres.full
51                 return
52         fi
53
54         # Trigger agfl fixing by fragmenting free space enough to cause
55         # a bnobt split
56         blksz=$(_get_file_block_size ${SCRATCH_MNT})
57         bno_maxrecs=$(( blksz / 8 ))
58         filesz=$((bno_maxrecs * 3 * blksz))
59         rm -rf $SCRATCH_MNT/a
60         $XFS_IO_PROG -f -c "falloc 0 $filesz" $SCRATCH_MNT/a >> $seqres.full 2>&1
61         test -e $SCRATCH_MNT/a && $here/src/punch-alternating $SCRATCH_MNT/a
62         rm -rf $SCRATCH_MNT/a
63
64         _scratch_unmount 2>&1 | _filter_scratch
65 }
66
67 dump_ag0() {
68         _scratch_xfs_db -c 'sb 0' -c 'p' -c 'agf 0' -c 'p' -c 'agfl 0' -c 'p'
69 }
70
71 runtest() {
72         cmd="$1"
73
74         # Format filesystem
75         echo "TEST $cmd" | tee /dev/ttyprintk
76         echo "TEST $cmd" >> $seqres.full
77         _scratch_mkfs >> $seqres.full
78
79         # Record what was here before
80         echo "FS BEFORE" >> $seqres.full
81         dump_ag0 > $tmp.before
82         cat $tmp.before >> $seqres.full
83
84         sectsize=$(_scratch_xfs_get_metadata_field "sectsize" "sb 0")
85         flfirst=$(_scratch_xfs_get_metadata_field "flfirst" "agf 0")
86         fllast=$(_scratch_xfs_get_metadata_field "fllast" "agf 0")
87         flcount=$(_scratch_xfs_get_metadata_field "flcount" "agf 0")
88
89         # Due to a padding bug in the original v5 struct xfs_agfl,
90         # XFS_AGFL_SIZE could be 36 on 32-bit or 40 on 64-bit.  On a system
91         # with 512b sectors, this means that the AGFL length could be
92         # ((512 - 36) / 4) = 119 entries on 32-bit or ((512 - 40) / 4) = 118
93         # entries on 64-bit.
94         #
95         # We now have code to figure out if the AGFL list wraps incorrectly
96         # according to the kernel's agfl size and fix it by resetting the agfl
97         # to zero length.  Mutate ag 0's agfl to be in various configurations
98         # and see if we can trigger the reset.
99         #
100         # Don't hardcode the numbers, calculate them.
101
102         # Have to have at least three agfl items to test full wrap
103         test "$flcount" -ge 3 || _notrun "insufficient agfl flcount"
104
105         # mkfs should be able to make us a nice neat flfirst < fllast setup
106         test "$flfirst" -lt "$fllast" || _notrun "fresh agfl already wrapped?"
107
108         bad_agfl_size=$(( (sectsize - 40) / 4 ))
109         good_agfl_size=$(( (sectsize - 36) / 4 ))
110         agfl_size=
111         case "$1" in
112         "fix_end")      # fllast points to the end w/ 40-byte padding
113                 new_flfirst=$(( bad_agfl_size - flcount ))
114                 agfl_size=$bad_agfl_size;;
115         "fix_start")    # flfirst points to the end w/ 40-byte padding
116                 new_flfirst=$(( bad_agfl_size - 1))
117                 agfl_size=$bad_agfl_size;;
118         "fix_wrap")     # list wraps around end w/ 40-byte padding
119                 new_flfirst=$(( bad_agfl_size - (flcount / 2) ))
120                 agfl_size=$bad_agfl_size;;
121         "start_zero")   # flfirst points to the start
122                 new_flfirst=0
123                 agfl_size=$good_agfl_size;;
124         "good_end")     # fllast points to the end w/ 36-byte padding
125                 new_flfirst=$(( good_agfl_size - flcount ))
126                 agfl_size=$good_agfl_size;;
127         "good_start")   # flfirst points to the end w/ 36-byte padding
128                 new_flfirst=$(( good_agfl_size - 1 ))
129                 agfl_size=$good_agfl_size;;
130         "good_wrap")    # list wraps around end w/ 36-byte padding
131                 new_flfirst=$(( good_agfl_size - (flcount / 2) ))
132                 agfl_size=$good_agfl_size;;
133         "bad_start")    # flfirst points off the end
134                 new_flfirst=$good_agfl_size
135                 agfl_size=$good_agfl_size;;
136         "no_move")      # whatever mkfs formats (flfirst points to start)
137                 new_flfirst=$flfirst
138                 agfl_size=$good_agfl_size;;
139         "simple_move")  # move list arbitrarily
140                 new_flfirst=$((fllast + 1))
141                 agfl_size=$good_agfl_size;;
142         *)
143                 _fail "Internal test error";;
144         esac
145         new_fllast=$(( (new_flfirst + flcount - 1) % agfl_size ))
146
147         # Log what we're doing...
148         cat >> $seqres.full << ENDL
149 sector size: $sectsize
150 bad_agfl_size: $bad_agfl_size [0 - $((bad_agfl_size - 1))]
151 good_agfl_size: $good_agfl_size [0 - $((good_agfl_size - 1))]
152 agfl_size: $agfl_size
153 flfirst: $flfirst
154 fllast: $fllast
155 flcount: $flcount
156 new_flfirst: $new_flfirst
157 new_fllast: $new_fllast
158 ENDL
159
160         # Remap the agfl blocks
161         echo "$((good_agfl_size - 1)) 0xffffffff" > $tmp.remap
162         seq "$flfirst" "$fllast" | while read f; do
163                 list_pos=$((f - flfirst))
164                 dest_pos=$(( (new_flfirst + list_pos) % agfl_size ))
165                 bno=$(_scratch_xfs_get_metadata_field "bno[$f]" "agfl 0")
166                 echo "$dest_pos $bno" >> $tmp.remap
167         done
168
169         cat $tmp.remap | while read dest_pos bno junk; do
170                 _scratch_xfs_set_metadata_field "bno[$dest_pos]" "$bno" \
171                                 "agfl 0" >> $seqres.full
172         done
173
174         # Set new flfirst/fllast
175         _scratch_xfs_set_metadata_field "fllast" "$new_fllast" \
176                         "agf 0" >> $seqres.full
177         _scratch_xfs_set_metadata_field "flfirst" "$new_flfirst" \
178                         "agf 0" >> $seqres.full
179
180         echo "FS AFTER" >> $seqres.full
181         dump_ag0 > $tmp.corrupt 2> /dev/null
182         diff -u $tmp.before $tmp.corrupt >> $seqres.full
183
184         # Mount and see what happens
185         mount_loop
186
187         # Did we end up with a non-wrapped list?
188         flfirst=$(_scratch_xfs_get_metadata_field "flfirst" "agf 0" 2>/dev/null)
189         fllast=$(_scratch_xfs_get_metadata_field "fllast" "agf 0" 2>/dev/null)
190         echo "flfirst=${flfirst} fllast=${fllast}" >> $seqres.full
191         if [ "${flfirst}" -ge "$((good_agfl_size - 1))" ]; then
192                 echo "ASSERT flfirst < good_agfl_size - 1" | tee -a $seqres.full
193         fi
194         if [ "${fllast}" -ge "$((good_agfl_size - 1))" ]; then
195                 echo "ASSERT fllast < good_agfl_size - 1" | tee -a $seqres.full
196         fi
197         if [ "${flfirst}" -ge "${fllast}" ]; then
198                 echo "ASSERT flfirst < fllast" | tee -a $seqres.full
199         fi
200
201         echo "FS MOUNTLOOP" >> $seqres.full
202         dump_ag0 > $tmp.mountloop 2> /dev/null
203         diff -u $tmp.corrupt $tmp.mountloop >> $seqres.full
204
205         # Let's see what repair thinks
206         echo "REPAIR" >> $seqres.full
207         _scratch_xfs_repair >> $seqres.full 2>&1
208
209         echo "FS REPAIR" >> $seqres.full
210         dump_ag0 > $tmp.repair 2> /dev/null
211         diff -u $tmp.mountloop $tmp.repair >> $seqres.full
212
213         # Exercise the filesystem again to make sure there aren't any lasting
214         # ill effects from either the agfl reset or the recommended subsequent
215         # repair run.
216         mount_loop
217
218         echo "FS REMOUNT" >> $seqres.full
219         dump_ag0 > $tmp.remount 2> /dev/null
220         diff -u $tmp.repair $tmp.remount >> $seqres.full
221 }
222
223 runtest fix_end
224 runtest fix_start
225 runtest fix_wrap
226 runtest start_zero
227 runtest good_end
228 runtest good_start
229 runtest good_wrap
230 runtest bad_start
231 runtest no_move
232 runtest simple_move
233
234 # Did we get the kernel warning too?
235 warn_str='WARNING: Reset corrupted AGFL'
236 _check_dmesg_for "${warn_str}" || echo "Missing dmesg string \"${warn_str}\"."
237
238 # Now run the regular dmesg check, filtering out the agfl warning
239 filter_agfl_reset_printk() {
240         grep -v "${warn_str}"
241 }
242 _check_dmesg filter_agfl_reset_printk
243
244 status=0
245 exit