d70964f4766133649ddf13e9947f2eafd60a7b94
[xfstests-dev.git] / common / fuzzy
1 ##/bin/bash
2
3 # Routines for fuzzing and scrubbing a filesystem.
4 #
5 #-----------------------------------------------------------------------
6 #  Copyright (c) 2017 Oracle.  All Rights Reserved.
7 #  This program is free software; you can redistribute it and/or modify
8 #  it under the terms of the GNU General Public License as published by
9 #  the Free Software Foundation; either version 2 of the License, or
10 #  (at your option) any later version.
11 #
12 #  This program is distributed in the hope that it will be useful,
13 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
14 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
15 #  GNU General Public License for more details.
16 #
17 #  You should have received a copy of the GNU General Public License
18 #  along with this program; if not, write to the Free Software
19 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
20 #  USA
21 #-----------------------------------------------------------------------
22
23 # Modify various files after a fuzzing operation
24 _scratch_fuzz_modify() {
25         nr="$1"
26
27         test -z "${nr}" && nr=50000
28         echo "+++ touch ${nr} files"
29         blk_sz=$(stat -f -c '%s' ${SCRATCH_MNT})
30         $XFS_IO_PROG -f -c "pwrite -S 0x63 0 ${blk_sz}" "/tmp/afile" > /dev/null
31         date="$(date)"
32         find "${SCRATCH_MNT}/" -type f 2> /dev/null | head -n "${nr}" | while read f; do
33                 setfattr -n "user.date" -v "${date}" "$f"
34                 cat "/tmp/afile" >> "$f"
35                 mv "$f" "$f.longer"
36         done
37         sync
38         rm -rf "/tmp/afile"
39
40         echo "+++ create files"
41         mkdir -p "${SCRATCH_MNT}/test.moo"
42         $XFS_IO_PROG -f -c 'pwrite -S 0x80 0 65536' "${SCRATCH_MNT}/test.moo/urk" > /dev/null
43         sync
44
45         echo "+++ remove files"
46         rm -rf "${SCRATCH_MNT}/test.moo"
47 }
48
49 # Try to access files after fuzzing
50 _scratch_fuzz_test() {
51         echo "+++ ls -laR" >> $seqres.full
52         ls -laR "${SCRATCH_MNT}/test.1/" >/dev/null 2>&1
53
54         echo "+++ cat files" >> $seqres.full
55         (find "${SCRATCH_MNT}/test.1/" -type f -size -1048576k -print0 | xargs -0 cat) >/dev/null 2>&1
56 }
57
58 # Do we have an online scrub program?
59 _require_scrub() {
60         case "${FSTYP}" in
61         "xfs")
62                 test -x "$XFS_SCRUB_PROG" || _notrun "xfs_scrub not found"
63                 ;;
64         *)
65                 _notrun "No online scrub program for ${FSTYP}."
66                 ;;
67         esac
68 }
69
70 # Scrub the scratch filesystem metadata (online)
71 _scratch_scrub() {
72         case "${FSTYP}" in
73         "xfs")
74                 $XFS_SCRUB_PROG -d -T -v "$@" $SCRATCH_MNT
75                 ;;
76         *)
77                 _fail "No online scrub program for ${FSTYP}."
78                 ;;
79         esac
80 }
81
82 # Filter out any keys with an array index >= 10, collapse any array range
83 # ("[1-195]") to the first item, and ignore padding fields.
84 __filter_xfs_db_keys() {
85         sed -e '/\([a-z]*\)\[\([0-9][0-9]\+\)\].*/d' \
86             -e 's/\([a-zA-Z0-9_]*\)\[\([0-9]*\)-[0-9]*\]/\1[\2]/g' \
87             -e '/pad/d'
88 }
89
90 # Filter the xfs_db print command's field debug information
91 # into field name and type.
92 __filter_xfs_db_print_fields() {
93         filter="$1"
94         if [ -z "${filter}" ] || [ "${filter}" = "nofilter" ]; then
95                 filter='^'
96         fi
97         grep ' = ' | while read key equals value; do
98                 fuzzkey="$(echo "${key}" | __filter_xfs_db_keys)"
99                 if [ -z "${fuzzkey}" ]; then
100                         continue
101                 elif [[ "${value}" == "["* ]]; then
102                         echo "${value}" | sed -e 's/^.//g' -e 's/.$//g' -e 's/,/\n/g' | while read subfield; do
103                                 echo "${fuzzkey}.${subfield}"
104                         done | __filter_xfs_db_keys
105                 else
106                         echo "${fuzzkey}"
107                 fi
108         done | egrep "${filter}"
109 }
110
111 # Navigate to some part of the filesystem and print the field info.
112 # The first argument is an egrep filter for the fields
113 # The rest of the arguments are xfs_db commands to locate the metadata.
114 _scratch_xfs_list_metadata_fields() {
115         filter="$1"
116         shift
117         if [ -n "${SCRATCH_XFS_LIST_METADATA_FIELDS}" ]; then
118                 echo "${SCRATCH_XFS_LIST_METADATA_FIELDS}" | tr '[ ,]' '[\n\n]'
119                 return;
120         fi
121
122         local cmds=()
123         for arg in "$@"; do
124                 cmds+=("-c" "${arg}")
125         done
126         _scratch_xfs_db "${cmds[@]}" -c print | __filter_xfs_db_print_fields "${filter}"
127 }
128
129 # Get a metadata field
130 # The first arg is the field name
131 # The rest of the arguments are xfs_db commands to find the metadata.
132 _scratch_xfs_get_metadata_field() {
133         key="$1"
134         shift
135
136         grep_key="$(echo "${key}" | tr '[]()' '....')"
137         local cmds=()
138         for arg in "$@"; do
139                 cmds+=("-c" "${arg}")
140         done
141         _scratch_xfs_db "${cmds[@]}" -c "print ${key}" | grep "^${grep_key}" | \
142                 sed -e 's/^.* = //g'
143 }
144
145 # Set a metadata field
146 # The first arg is the field name
147 # The second arg is the new value
148 # The rest of the arguments are xfs_db commands to find the metadata.
149 _scratch_xfs_set_metadata_field() {
150         key="$1"
151         value="$2"
152         shift; shift
153
154         local cmds=()
155         for arg in "$@"; do
156                 cmds+=("-c" "${arg}")
157         done
158         _scratch_xfs_db -x "${cmds[@]}" -c "write -d ${key} ${value}"
159         echo
160 }
161
162 # Fuzz a metadata field
163 # The first arg is the field name
164 # The second arg is the xfs_db fuzz verb
165 # The rest of the arguments are xfs_db commands to find the metadata.
166 _scratch_xfs_fuzz_metadata_field() {
167         key="$1"
168         value="$2"
169         shift; shift
170
171         if [[ "${key}" == *crc ]]; then
172                 fuzz_arg="-c"
173         else
174                 fuzz_arg="-d"
175         fi
176         oldval="$(_scratch_xfs_get_metadata_field "${key}" "$@")"
177
178         local cmds=()
179         for arg in "$@"; do
180                 cmds+=("-c" "${arg}")
181         done
182         while true; do
183                 _scratch_xfs_db -x "${cmds[@]}" -c "fuzz ${fuzz_arg} ${key} ${value}"
184                 echo
185                 newval="$(_scratch_xfs_get_metadata_field "${key}" "$@" 2> /dev/null)"
186                 if [ "${key}" != "random" ] || [ "${oldval}" != "${newval}" ]; then
187                         break;
188                 fi
189         done
190         if [ "${oldval}" = "${newval}" ]; then
191                 echo "Field ${key} already set to ${newval}, skipping test."
192                 return 1
193         fi
194         return 0
195 }
196
197 # Try to forcibly unmount the scratch fs
198 __scratch_xfs_fuzz_unmount()
199 {
200         while _scratch_unmount 2>/dev/null; do sleep 0.2; done
201 }
202
203 # Restore metadata to scratch device prior to field-fuzzing.
204 __scratch_xfs_fuzz_mdrestore()
205 {
206         test -e "${POPULATE_METADUMP}" || _fail "Need to set POPULATE_METADUMP"
207
208         __scratch_xfs_fuzz_unmount
209         xfs_mdrestore "${POPULATE_METADUMP}" "${SCRATCH_DEV}"
210 }
211
212 __fuzz_notify() {
213         echo "$@"
214         test -w /dev/ttyprintk && echo "$@" >> /dev/ttyprintk
215 }
216
217 # Fuzz one field of some piece of metadata.
218 # First arg is the field name
219 # Second arg is the fuzz verb (ones, zeroes, random, add, sub...)
220 # Third arg is the repair mode (online, offline, both)
221 __scratch_xfs_fuzz_field_test() {
222         field="$1"
223         fuzzverb="$2"
224         repair="$3"
225         shift; shift; shift
226
227         # Set the new field value
228         __fuzz_notify "+ Fuzz ${field} = ${fuzzverb}"
229         echo "========================"
230         _scratch_xfs_fuzz_metadata_field "${field}" ${fuzzverb} "$@"
231         res=$?
232         test $res -ne 0 && return
233
234         # Try to catch the error with scrub
235         echo "+ Try to catch the error"
236         _scratch_mount 2>&1
237         res=$?
238         if [ $res -eq 0 ]; then
239                 # Try an online scrub unless we're fuzzing ag 0's sb,
240                 # which scrub doesn't know how to fix.
241                 echo "++ Online scrub"
242                 if [ "$1" != "sb 0" ]; then
243                         _scratch_scrub -n -a 1 -e continue 2>&1
244                         res=$?
245                         test $res -eq 0 && \
246                                 (>&2 echo "scrub didn't fail with ${field} = ${fuzzverb}.")
247                 fi
248
249                 # Try fixing the filesystem online?!
250                 if [ "${repair}" = "online" ] || [ "${repair}" = "both" ]; then
251                         __fuzz_notify "++ Try to repair filesystem online"
252                         _scratch_scrub -y 2>&1
253                         res=$?
254                         test $res -ne 0 && \
255                                 (>&2 echo "online repair failed ($res) with ${field} = ${fuzzverb}.")
256                 fi
257
258                 __scratch_xfs_fuzz_unmount
259         elif [ "${repair}" = "online" ] || [ "${repair}" = "both" ]; then
260                 (>&2 echo "mount failed ($res) with ${field} = ${fuzzverb}.")
261         fi
262
263         # Repair the filesystem offline?
264         if [ "${repair}" = "offline" ] || [ "${repair}" = "both" ]; then
265                 echo "+ Try to repair the filesystem offline"
266                 _repair_scratch_fs 2>&1
267                 res=$?
268                 test $res -ne 0 && \
269                         (>&2 echo "offline repair failed ($res) with ${field} = ${fuzzverb}.")
270         fi
271
272         # See if repair finds a clean fs
273         echo "+ Make sure error is gone (offline)"
274         _scratch_xfs_repair -n 2>&1
275         res=$?
276         test $res -ne 0 && \
277                 (>&2 echo "offline re-scrub ($res) with ${field} = ${fuzzverb}.")
278
279         # See if scrub finds a clean fs
280         echo "+ Make sure error is gone (online)"
281         _scratch_mount 2>&1
282         res=$?
283         if [ $res -eq 0 ]; then
284                 # Try an online scrub unless we're fuzzing ag 0's sb,
285                 # which scrub doesn't know how to fix.
286                 echo "++ Online scrub"
287                 if [ "$1" != "sb 0" ]; then
288                         _scratch_scrub -n -e continue 2>&1
289                         res=$?
290                         test $res -ne 0 && \
291                                 (>&2 echo "online re-scrub ($res) with ${field} = ${fuzzverb}.")
292                 fi
293
294                 # Try modifying the filesystem again!
295                 __fuzz_notify "++ Try to write filesystem again"
296                 _scratch_fuzz_modify 100 2>&1
297                 __scratch_xfs_fuzz_unmount
298         else
299                 (>&2 echo "re-mount failed ($res) with ${field} = ${fuzzverb}.")
300         fi
301
302         # See if repair finds a clean fs
303         echo "+ Re-check the filesystem (offline)"
304         _scratch_xfs_repair -n 2>&1
305         res=$?
306         test $res -ne 0 && \
307                 (>&2 echo "re-repair failed ($res) with ${field} = ${fuzzverb}.")
308 }
309
310 # Make sure we have all the pieces we need for field fuzzing
311 _require_scratch_xfs_fuzz_fields()
312 {
313         _require_scratch_nocheck
314         _require_scrub
315         _require_populate_commands
316         _scratch_mkfs_xfs >/dev/null 2>&1
317         _require_xfs_db_command "fuzz"
318 }
319
320 # Grab the list of available fuzzing verbs
321 _scratch_xfs_list_fuzz_verbs() {
322         if [ -n "${SCRATCH_XFS_LIST_FUZZ_VERBS}" ]; then
323                 echo "${SCRATCH_XFS_LIST_FUZZ_VERBS}" | tr '[ ,]' '[\n\n]'
324                 return;
325         fi
326         _scratch_xfs_db -x -c 'sb 0' -c 'fuzz' | grep '^Fuzz commands:' | \
327                 sed -e 's/[,.]//g' -e 's/Fuzz commands: //g' -e 's/ /\n/g'
328 }
329
330 # Fuzz some of the fields of some piece of metadata
331 # The first argument is an egrep filter for the field names
332 # The second argument is the repair mode (online, offline, both)
333 # The rest of the arguments are xfs_db commands to locate the metadata.
334 #
335 # Users can specify the fuzz verbs via SCRATCH_XFS_LIST_FUZZ_VERBS
336 # They can specify the fields via SCRATCH_XFS_LIST_METADATA_FIELDS
337 _scratch_xfs_fuzz_metadata() {
338         filter="$1"
339         repair="$2"
340         shift; shift
341
342         fields="$(_scratch_xfs_list_metadata_fields "${filter}" "$@")"
343         verbs="$(_scratch_xfs_list_fuzz_verbs)"
344         echo "Fields we propose to fuzz under: $@"
345         echo $(echo "${fields}")
346         echo "Verbs we propose to fuzz with:"
347         echo $(echo "${verbs}")
348
349         echo "${fields}" | while read field; do
350                 echo "${verbs}" | while read fuzzverb; do
351                         __scratch_xfs_fuzz_mdrestore
352                         __scratch_xfs_fuzz_field_test "${field}" "${fuzzverb}" "${repair}" "$@"
353                 done
354         done
355 }