common/fuzzy: if the fuzz verb is random, keep fuzzing until we get a new value
[xfstests-dev.git] / common / reflink
1 ##/bin/bash
2 # Routines for reflinking, deduping, and comparing parts of files.
3 #-----------------------------------------------------------------------
4 #  Copyright (c) 2015 Oracle.  All Rights Reserved.
5 #  This program is free software; you can redistribute it and/or modify
6 #  it under the terms of the GNU General Public License as published by
7 #  the Free Software Foundation; either version 2 of the License, or
8 #  (at your option) any later version.
9 #
10 #  This program is distributed in the hope that it will be useful,
11 #  but WITHOUT ANY WARRANTY; without even the implied warranty of
12 #  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
13 #  GNU General Public License for more details.
14 #
15 #  You should have received a copy of the GNU General Public License
16 #  along with this program; if not, write to the Free Software
17 #  Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307
18 #  USA
19 #
20 #  Contact information: Oracle Corporation, 500 Oracle Parkway,
21 #  Redwood Shores, CA 94065, USA, or: http://www.oracle.com/
22 #-----------------------------------------------------------------------
23
24 # Check that cp has a reflink argument
25 _require_cp_reflink()
26 {
27        cp --help | grep -q reflink || \
28                _notrun "This test requires a cp with --reflink support."
29 }
30
31 # Can we reflink between arbitrary file sets?
32 # i.e. if we reflink a->b and c->d, can we later share
33 # blocks between b & c?
34 _require_arbitrary_fileset_reflink()
35 {
36         test "$FSTYP" = "ocfs2" && \
37                 _notrun "reflink between arbitrary file groups not supported in $FSTYP"
38 }
39
40 # Given 2 files, verify that they have the same mapping but different
41 # inodes - i.e. an undisturbed reflink
42 # Silent if so, make noise if not
43 _verify_reflink()
44 {
45        # not a hard link or symlink?
46        cmp -s  <(stat -c '%i' $1) <(stat -c '%i' $2) \
47                && echo "$1 and $2 are not reflinks: same inode number"
48
49        # same mapping?
50        diff -u <($XFS_IO_PROG -c "fiemap" $1 | grep -v $1) \
51                <($XFS_IO_PROG -c "fiemap" $2 | grep -v $2) \
52                || echo "$1 and $2 are not reflinks: different extents"
53 }
54
55 # New reflink/dedupe helpers
56
57 # this test requires the test fs support reflink...
58 _require_test_reflink()
59 {
60         _require_test
61         _require_xfs_io_command "reflink"
62
63         rm -rf "$TEST_DIR/file1" "$TEST_DIR/file2"
64         $XFS_IO_PROG -f -c "pwrite -S 0x61 0 65536" "$TEST_DIR/file1" > /dev/null
65         $XFS_IO_PROG -f -c "reflink $TEST_DIR/file1 0 0 65536" "$TEST_DIR/file2" > /dev/null
66         if [ ! -s "$TEST_DIR/file2" ]; then
67                 rm -rf "$TEST_DIR/file1" "$TEST_DIR/file2"
68                 _notrun "Reflink not supported by test filesystem type: $FSTYP"
69         fi
70         rm -rf "$TEST_DIR/file1" "$TEST_DIR/file2"
71 }
72
73 # this test requires the scratch fs support reflink...
74 _require_scratch_reflink()
75 {
76         _require_scratch
77         _require_xfs_io_command "reflink"
78
79         _scratch_mkfs > /dev/null
80         _scratch_mount
81         $XFS_IO_PROG -f -c "pwrite -S 0x61 0 65536" "$SCRATCH_MNT/file1" > /dev/null
82         $XFS_IO_PROG -f -c "reflink $SCRATCH_MNT/file1 0 0 65536" "$SCRATCH_MNT/file2" > /dev/null
83         if [ ! -s "$SCRATCH_MNT/file2" ]; then
84                 _scratch_unmount
85                 _notrun "Reflink not supported by scratch filesystem type: $FSTYP"
86         fi
87         _scratch_unmount
88 }
89
90 # this test requires scratch fs to report explicit SHARED flag
91 # e.g.
92 #   0         4K         8K
93 #    / File1: Extent 0  \
94 #   /                    \
95 #   |<- On disk Extent-->|
96 #   |        /
97 #   | File2 /
98 #     Extent: 0
99 # Fs supports explicit SHARED extent reporting should report fiemap like:
100 # File1: 2 extents
101 # Extent 0-4K: SHARED
102 # Extent 4-8K:
103 # File2: 1 extents
104 # Extent 0-4K: SHARED
105 #
106 # Fs doesn't support explicit reporting will report fiemap like:
107 # File1: 1 extent
108 # Extent 0-8K: SHARED
109 # File2: 1 extent
110 # Extent 0-4K: SHARED
111 _require_scratch_explicit_shared_extents()
112 {
113         _require_scratch
114         _require_xfs_io_command "fiemap"
115         _require_scratch_reflink
116         _require_xfs_io_command "reflink"
117         local nr_extents
118
119         _scratch_mkfs > /dev/null
120         _scratch_mount
121
122         _pwrite_byte 0x61 0 128k $SCRATCH_MNT/file1 >/dev/null
123         _reflink_range $SCRATCH_MNT/file1 0 $SCRATCH_MNT/file2 0 64k >/dev/null
124
125         _scratch_cycle_mount
126
127         nr_extents=$(_count_extents $SCRATCH_MNT/file1)
128         if [ $nr_extents -eq 1 ]; then
129                 _notrun "Explicit SHARED flag reporting not support by filesystem type: $FSTYP"
130         fi
131         _scratch_unmount
132 }
133
134 # this test requires the test fs support dedupe...
135 _require_test_dedupe()
136 {
137         _require_test
138         _require_xfs_io_command "dedupe"
139
140         rm -rf "$TEST_DIR/file1" "$TEST_DIR/file2"
141         $XFS_IO_PROG -f -c "pwrite -S 0x61 0 65536" "$TEST_DIR/file1" > /dev/null
142         $XFS_IO_PROG -f -c "pwrite -S 0x61 0 65536" "$TEST_DIR/file2" > /dev/null
143         testio="$($XFS_IO_PROG -f -c "dedupe $TEST_DIR/file1 0 0 65536" "$TEST_DIR/file2" 2>&1)"
144         echo $testio | grep -q "Operation not supported" && \
145                 _notrun "Dedupe not supported by test filesystem type: $FSTYP"
146         echo $testio | grep -q "Inappropriate ioctl for device" && \
147                 _notrun "Dedupe not supported by test filesystem type: $FSTYP"
148         echo $testio | grep -q "Invalid argument" && \
149                 _notrun "Dedupe not supported by test filesystem type: $FSTYP"
150         rm -rf "$TEST_DIR/file1" "$TEST_DIR/file2"
151 }
152
153 # this test requires the scratch fs support dedupe...
154 _require_scratch_dedupe()
155 {
156         _require_scratch
157         _require_xfs_io_command "dedupe"
158
159         _scratch_mkfs > /dev/null
160         _scratch_mount
161         $XFS_IO_PROG -f -c "pwrite -S 0x61 0 65536" "$SCRATCH_MNT/file1" > /dev/null
162         $XFS_IO_PROG -f -c "pwrite -S 0x61 0 65536" "$SCRATCH_MNT/file2" > /dev/null
163         testio="$($XFS_IO_PROG -f -c "dedupe $SCRATCH_MNT/file1 0 0 65536" "$SCRATCH_MNT/file2" 2>&1)"
164         echo $testio | grep -q "Operation not supported" && \
165                 _notrun "Dedupe not supported by test filesystem type: $FSTYP"
166         echo $testio | grep -q "Inappropriate ioctl for device" && \
167                 _notrun "Dedupe not supported by test filesystem type: $FSTYP"
168         echo $testio | grep -q "Invalid argument" && \
169                 _notrun "Dedupe not supported by test filesystem type: $FSTYP"
170         _scratch_unmount
171 }
172
173 # Prints a range of a file as a hex dump
174 _read_range() {
175         file="$1"
176         offset="$2"
177         len="$3"
178         xfs_io_args="$4"
179
180         $XFS_IO_PROG $xfs_io_args -f -c "pread -q -v $offset $len" "$file" | cut -d ' ' -f '3-18'
181 }
182
183 # Compare ranges of two files
184 _compare_range() {
185         file1="$1"
186         offset1="$2"
187         file2="$3"
188         offset2="$4"
189         len="$5"
190
191         cmp -s <(_read_range "$file1" "$offset1" "$len") \
192                <(_read_range "$file2" "$offset2" "$len")
193 }
194
195 # Prints the md5 checksum of a hexdump of a part of a given file
196 _md5_range_checksum() {
197         file="$1"
198         offset="$2"
199         len="$3"
200
201         md5sum <(_read_range "$file" "$offset" "$len") | cut -d ' ' -f 1
202 }
203
204 # Reflink some file1 into file2 via cp
205 _cp_reflink() {
206         file1="$1"
207         file2="$2"
208
209         cp --reflink=always -p -f "$file1" "$file2"
210 }
211
212 # Reflink some file1 into file2
213 _reflink() {
214         file1="$1"
215         file2="$2"
216
217         $XFS_IO_PROG -f -c "reflink $file1" "$file2"
218 }
219
220 # Reflink some part of file1 into another part of file2
221 _reflink_range() {
222         file1="$1"
223         offset1="$2"
224         file2="$3"
225         offset2="$4"
226         len="$5"
227         xfs_io_args="$6"
228
229         $XFS_IO_PROG $xfs_io_args -f -c "reflink $file1 $offset1 $offset2 $len" "$file2"
230 }
231
232 # Dedupe some part of file1 into another part of file2
233 _dedupe_range() {
234         file1="$1"
235         offset1="$2"
236         file2="$3"
237         offset2="$4"
238         len="$5"
239         xfs_io_args="$6"
240
241         $XFS_IO_PROG $xfs_io_args -f -c "dedupe $file1 $offset1 $offset2 $len" "$file2"
242 }
243
244 # Unify xfs_io dedupe ioctl error message prefix
245 _filter_dedupe_error()
246 {
247         sed -e 's/^dedupe:/XFS_IOC_FILE_EXTENT_SAME:/g'
248 }
249
250 # Create a file of interleaved unwritten and reflinked blocks
251 _weave_reflink_unwritten() {
252         blksz=$1
253         nr=$2
254         sfile=$3
255         dfile=$4
256
257         _pwrite_byte 0x61 0 $((blksz * nr)) $sfile
258         $XFS_IO_PROG -f -c "falloc 0 $((blksz * nr))" $dfile
259         _pwrite_byte 0x00 0 $((blksz * nr)) $dfile.chk
260         seq 0 2 $((nr - 1)) | while read i; do
261                 _reflink_range $sfile $((blksz * i)) $dfile $((blksz * i)) $blksz
262                 _pwrite_byte 0x61 $((blksz * i)) $blksz $dfile.chk
263         done
264 }
265
266 # Create a file of interleaved holes and reflinked blocks
267 _weave_reflink_holes() {
268         blksz=$1
269         nr=$2
270         sfile=$3
271         dfile=$4
272
273         _pwrite_byte 0x61 0 $((blksz * nr)) $sfile
274         $XFS_IO_PROG -f -c "truncate $((blksz * nr))" $dfile
275         _pwrite_byte 0x00 0 $((blksz * nr)) $dfile.chk
276         seq 0 2 $((nr - 1)) | while read i; do
277                 _reflink_range $sfile $((blksz * i)) $dfile $((blksz * i)) $blksz
278                 _pwrite_byte 0x61 $((blksz * i)) $blksz $dfile.chk
279         done
280 }
281
282 # For a file created with _weave_reflink_holes, fill the holes with delalloc
283 # extents
284 _weave_reflink_holes_delalloc() {
285         blksz=$1
286         nr=$2
287         dfile=$3
288
289         seq 1 2 $((nr - 1)) | while read i; do
290                 _pwrite_byte 0x62 $((blksz * i)) $blksz $dfile
291                 _pwrite_byte 0x62 $((blksz * i)) $blksz $dfile.chk
292         done
293 }
294
295 # Create a file of interleaved regular blocks and reflinked blocks
296 _weave_reflink_regular() {
297         blksz=$1
298         nr=$2
299         sfile=$3
300         dfile=$4
301
302         _pwrite_byte 0x61 0 $((blksz * nr)) $sfile
303         _pwrite_byte 0x62 0 $((blksz * nr)) $dfile
304         _pwrite_byte 0x62 0 $((blksz * nr)) $dfile.chk
305         seq 0 2 $((nr - 1)) | while read i; do
306                 _reflink_range $sfile $((blksz * i)) $dfile $((blksz * i)) $blksz
307                 _pwrite_byte 0x61 $((blksz * i)) $blksz $dfile.chk
308         done
309 }
310
311 # Create a file of interleaved holes, unwritten blocks, regular blocks, and
312 # reflinked blocks
313 _weave_reflink_rainbow() {
314         blksz=$1
315         nr=$2
316         sfile=$3
317         dfile=$4
318
319         _pwrite_byte 0x61 0 $((blksz * nr)) $sfile
320         $XFS_IO_PROG -f -c "truncate $((blksz * nr))" $dfile
321         _pwrite_byte 0x00 0 $((blksz * nr)) $dfile.chk
322         # 0 blocks are reflinked
323         seq 0 5 $((nr - 1)) | while read i; do
324                 _reflink_range $sfile $((blksz * i)) $dfile $((blksz * i)) $blksz
325                 _pwrite_byte 0x61 $((blksz * i)) $blksz $dfile.chk
326         done
327         # 1 blocks are unwritten
328         seq 1 5 $((nr - 1)) | while read i; do
329                 $XFS_IO_PROG -f -c "falloc $((blksz * i)) $blksz" $dfile
330                 _pwrite_byte 0x00 $((blksz * i)) $blksz $dfile.chk
331         done
332         # 2 blocks are holes
333         seq 2 5 $((nr - 1)) | while read i; do
334                 _pwrite_byte 0x00 $((blksz * i)) $blksz $dfile.chk
335         done
336         # 3 blocks are regular
337         seq 3 5 $((nr - 1)) | while read i; do
338                 _pwrite_byte 0x71 $((blksz * i)) $blksz $dfile
339                 _pwrite_byte 0x71 $((blksz * i)) $blksz $dfile.chk
340         done
341         # 4 blocks will be delalloc later
342 }
343
344 # For a file created with _weave_reflink_rainbow, fill the holes with delalloc
345 # extents
346 _weave_reflink_rainbow_delalloc() {
347         blksz=$1
348         nr=$2
349         dfile=$3
350
351         # 4 blocks are delalloc (do later)
352         seq 4 5 $((nr - 1)) | while read i; do
353                 _pwrite_byte 0x62 $((blksz * i)) $blksz $dfile
354                 _pwrite_byte 0x62 $((blksz * i)) $blksz $dfile.chk
355         done
356 }
357
358 # Make the source file have interleaved regular blocks and reflinked blocks
359 _sweave_reflink_regular() {
360         blksz=$1
361         nr=$2
362         sfile=$3
363         dfile=$4
364
365         _pwrite_byte 0x61 0 $((blksz * nr)) $sfile
366         _pwrite_byte 0x62 0 $((blksz * nr)) $dfile
367         _pwrite_byte 0x61 0 $((blksz * nr)) $sfile.chk
368         seq 1 2 $((nr - 1)) | while read i; do
369                 _reflink_range $sfile $((blksz * i)) $dfile $((blksz * i)) $blksz
370         done
371 }
372
373 # Make the source file have interleaved unwritten blocks and reflinked blocks
374 _sweave_reflink_unwritten() {
375         blksz=$1
376         nr=$2
377         sfile=$3
378         dfile=$4
379
380         $XFS_IO_PROG -f -c "falloc 0 $((blksz * nr))" $sfile
381         _pwrite_byte 0x00 0 $((blksz * nr)) $sfile.chk
382         _pwrite_byte 0x62 0 $((blksz * nr)) $dfile
383         seq 1 2 $((nr - 1)) | while read i; do
384                 _pwrite_byte 0x61 $((blksz * i)) $blksz $sfile
385                 _pwrite_byte 0x61 $((blksz * i)) $blksz $sfile.chk
386         done
387         seq 1 2 $((nr - 1)) | while read i; do
388                 _reflink_range $sfile $((blksz * i)) $dfile $((blksz * i)) $blksz
389         done
390 }
391
392 # Make the source file have interleaved holes and reflinked blocks
393 _sweave_reflink_holes() {
394         blksz=$1
395         nr=$2
396         sfile=$3
397         dfile=$4
398
399         $XFS_IO_PROG -f -c "truncate $((blksz * nr))" $sfile
400         _pwrite_byte 0x00 0 $((blksz * nr)) $sfile.chk
401         _pwrite_byte 0x62 0 $((blksz * nr)) $dfile
402         seq 1 2 $((nr - 1)) | while read i; do
403                 _pwrite_byte 0x61 $((blksz * i)) $blksz $sfile
404                 _pwrite_byte 0x61 $((blksz * i)) $blksz $sfile.chk
405         done
406         seq 1 2 $((nr - 1)) | while read i; do
407                 _reflink_range $sfile $((blksz * i)) $dfile $((blksz * i)) $blksz
408         done
409 }
410
411 # For a file created with _sweave_reflink_holes, fill the holes with delalloc
412 # extents
413 _sweave_reflink_holes_delalloc() {
414         blksz=$1
415         nr=$2
416         sfile=$3
417
418         seq 0 2 $((nr - 1)) | while read i; do
419                 _pwrite_byte 0x64 $((blksz * i)) $blksz $sfile
420                 _pwrite_byte 0x64 $((blksz * i)) $blksz $sfile.chk
421         done
422 }