btrfs-progs: tests: truncate test image to 0 first
[platform/upstream/btrfs-progs.git] / tests / common
1 #!/bin/bash
2 #
3 # Common routines for all tests
4 #
5
6 # assert that argument is not empty and is an existing path (file or directory)
7 _assert_path()
8 {
9         local path
10
11         path="$1"
12         if [ -z "$path" ]; then
13                 echo "ASSERTION FAIL: $path is not valid"
14                 exit 1
15         fi
16
17         if [ -f "$path" -o -d "$path" -o -b "$path" ]; then
18                 return 0
19         fi
20         echo "ASSERTION FAIL: $path is not valid"
21         exit 1
22 }
23
24 # $1: this string gets matched to files, absolute or relative path, or a
25 # systemwide command available via $PATH
26 _is_file_or_command()
27 {
28         local msg
29
30         msg="$1"
31         if [ -z "$msg" ]; then
32                 return 1
33         fi
34
35         if [ -f "$msg" -o -d "$msg" -o -b "$msg" ]; then
36                 return 0
37         fi
38         msg=$(type -p -- "$msg")
39         if [ -f "$msg" ]; then
40                 return 0
41         fi
42         return 1
43 }
44
45 _fail()
46 {
47         echo "$*" | tee -a "$RESULTS"
48         exit 1
49 }
50
51 # log a message to the results file
52 _log()
53 {
54         echo "$*" | tee -a "$RESULTS"
55 }
56
57 _not_run()
58 {
59         echo "    [NOTRUN] $*"
60         exit 0
61 }
62
63 # debugging helper
64 _dump_args()
65 {
66         local i
67
68         i=1
69         echo "DUMP args for ${FUNCNAME[1]}:"
70         while [ $# -gt 0 ]; do
71                 echo "ARG[$i]: $1"
72                 i=$(($i+1))
73                 shift
74         done
75 }
76
77 # read arguments, look if we're calling btrfs and if there's a known
78 # subcommand, return argument index to insert, taking root helper into
79 # consideration, returns 2 for unknown subcommand
80 _get_spec_ins()
81 {
82         if [ "$1" = 'root_helper' ]; then
83                 if [[ $2 =~ /btrfs$ ]]; then
84                         echo -n 4
85                         return
86                 fi
87         else
88                 if [[ $1 =~ /btrfs$ ]]; then
89                         echo -n 3
90                         return
91                 fi
92         fi
93         echo -n 2
94 }
95
96 # return command-specific arguments if enabled
97 _cmd_spec()
98 {
99         if [ "$TEST_ENABLE_OVERRIDE" = 'true' ]; then
100                 # if defined via common.local, use it, otherwise pass make
101                 # arguments
102                 if [ "$(type -t _skip_spec)" = 'function' ]; then
103                         if _skip_spec "$@"; then
104                                 return
105                         fi
106                 fi
107                 case "$1" in
108                         check) echo -n "$TEST_ARGS_CHECK" ;;
109                 esac
110         fi
111 }
112
113 # Argument passing magic:
114 # the command passed to run_* helpers is inspected, if there's 'btrfs command'
115 # found and there are defined additional arguments, they're inserted just after
116 # the command name, ie. any arguments in the test could override them.
117 #
118 # The root helper is recognized.  Unrecognized subcommands or external tools
119 # are not affected.
120
121 run_check()
122 {
123         local spec
124         local ins
125         local cmd
126
127         ins=$(_get_spec_ins "$@")
128         spec=$(($ins-1))
129         cmd=$(eval echo "\${$spec}")
130         spec=$(_cmd_spec "${@:$spec}")
131         set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
132         echo "############### $@" >> "$RESULTS" 2>&1
133         if [[ $TEST_LOG =~ tty ]]; then echo "CMD: $@" > /dev/tty; fi
134         if [ "$1" = 'root_helper' ]; then
135                 "$@" >> "$RESULTS" 2>&1 || _fail "failed: $@"
136         else
137                 $INSTRUMENT "$@" >> "$RESULTS" 2>&1 || _fail "failed: $@"
138         fi
139 }
140
141 # same as run_check but the stderr+stdout output is duplicated on stdout and
142 # can be processed further
143 run_check_stdout()
144 {
145         local spec
146         local ins
147         local cmd
148
149         ins=$(_get_spec_ins "$@")
150         spec=$(($ins-1))
151         cmd=$(eval echo "\${$spec}")
152         spec=$(_cmd_spec "${@:$spec}")
153         set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
154         echo "############### $@" >> "$RESULTS" 2>&1
155         if [[ $TEST_LOG =~ tty ]]; then echo "CMD(stdout): $@" > /dev/tty; fi
156         if [ "$1" = 'root_helper' ]; then
157                 "$@" 2>&1 | tee -a "$RESULTS"
158         else
159                 $INSTRUMENT "$@" 2>&1 | tee -a "$RESULTS"
160         fi
161         if [ ${PIPESTATUS[0]} -ne 0 ]; then
162                 _fail "failed: $@"
163         fi
164 }
165
166 # same as run_check but does not fail the test if it's handled gracefully by
167 # the tool, unexpected failure like segfault or abor will exit forcibly
168 # output is logged
169 run_mayfail()
170 {
171         local spec
172         local ins
173         local cmd
174         local ret
175
176         ins=$(_get_spec_ins "$@")
177         spec=$(($ins-1))
178         cmd=$(eval echo "\${$spec}")
179         spec=$(_cmd_spec "${@:$spec}")
180         set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
181         echo "############### $@" >> "$RESULTS" 2>&1
182         if [[ $TEST_LOG =~ tty ]]; then echo "CMD(mayfail): $@" > /dev/tty; fi
183         if [ "$1" = 'root_helper' ]; then
184                 "$@" >> "$RESULTS" 2>&1
185         else
186                 $INSTRUMENT "$@" >> "$RESULTS" 2>&1
187         fi
188         ret=$?
189         if [ $ret != 0 ]; then
190                 echo "failed (ignored, ret=$ret): $@" >> "$RESULTS"
191                 if [ $ret == 139 ]; then
192                         _fail "mayfail: returned code 139 (SEGFAULT), not ignored"
193                 elif [ $ret == 134 ]; then
194                         _fail "mayfail: returned code 134 (SIGABRT), not ignored"
195                 fi
196                 return $ret
197         fi
198 }
199
200 # first argument is error message to print if it fails, otherwise
201 # same as run_check but expects the command to fail, output is logged
202 run_mustfail()
203 {
204         local spec
205         local ins
206         local cmd
207         local msg
208
209         msg="$1"
210         shift
211
212         if _is_file_or_command "$msg"; then
213                 echo "ASSERTION FAIL: 1st argument of run_mustfail must be a message"
214                 exit 1
215         fi
216
217         ins=$(_get_spec_ins "$@")
218         spec=$(($ins-1))
219         cmd=$(eval echo "\${$spec}")
220         spec=$(_cmd_spec "${@:$spec}")
221         set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
222         echo "############### $@" >> "$RESULTS" 2>&1
223         if [[ $TEST_LOG =~ tty ]]; then echo "CMD(mustfail): $@" > /dev/tty; fi
224         if [ "$1" = 'root_helper' ]; then
225                 "$@" >> "$RESULTS" 2>&1
226         else
227                 $INSTRUMENT "$@" >> "$RESULTS" 2>&1
228         fi
229         if [ $? != 0 ]; then
230                 echo "failed (expected): $@" >> "$RESULTS"
231                 return 0
232         else
233                 echo "succeeded (unexpected!): $@" >> "$RESULTS"
234                 _fail "unexpected success: $msg"
235                 return 1
236         fi
237 }
238
239 # The first parameter is error message to print if it fails, just like
240 # run_must_fail().
241 # NOTE: we don't use pipefail to avoid disturbing other script, so here we
242 # use a temporary output file.
243 # So it doesn't support pipeline in the @cmd
244 run_mustfail_stdout()
245 {
246         local spec
247         local ins
248         local cmd
249         local msg
250         local ret
251         local tmp_output
252
253         tmp_output=$(mktemp --tmpdir btrfs-progs-test--mustfail-stdtout.XXXXXX)
254
255         msg="$1"
256         shift
257
258         if _is_file_or_command "$msg"; then
259                 echo "ASSERTION FAIL: 1st argument of run_mustfail_stdout must be a message"
260                 exit 1
261         fi
262
263         ins=$(_get_spec_ins "$@")
264         spec=$(($ins-1))
265         cmd=$(eval echo "\${$spec}")
266         spec=$(_cmd_spec "${@:$spec}")
267         set -- "${@:1:$(($ins-1))}" $spec "${@: $ins}"
268         echo "############### $@" >> "$RESULTS" 2>&1
269         if [[ $TEST_LOG =~ tty ]]; then echo "CMD(mustfail): $@" > /dev/tty; fi
270         if [ "$1" = 'root_helper' ]; then
271                 "$@" 2>&1 > "$tmp_output"
272         else
273                 $INSTRUMENT "$@" 2>&1 > "$tmp_output"
274         fi
275         ret=$?
276
277         cat "$tmp_output" >> "$RESULTS"
278         cat "$tmp_output"
279         rm "$tmp_output"
280
281         if [ "$ret" != 0 ]; then
282                 echo "failed (expected): $@" >> "$RESULTS"
283                 return 0
284         else
285                 echo "succeeded (unexpected!): $@" >> "$RESULTS"
286                 _fail "unexpected success: $msg"
287                 return 1
288         fi
289 }
290
291 check_prereq()
292 {
293         if ! [ -f "$TOP/$1" ]; then
294                 _fail "Failed prerequisites: $1";
295         fi
296 }
297
298 check_global_prereq()
299 {
300         which $1 &> /dev/null
301         if [ $? -ne 0 ]; then
302                 _fail "Failed system wide prerequisities: $1";
303         fi
304 }
305
306 check_image()
307 {
308         local image
309
310         image=$1
311         echo "testing image $(basename $image)" >> "$RESULTS"
312         "$TOP/btrfs" check "$image" >> "$RESULTS" 2>&1
313         [ $? -eq 0 ] && _fail "btrfs check should have detected corruption"
314
315         run_check "$TOP/btrfs" check --repair "$image"
316         run_check "$TOP/btrfs" check "$image"
317 }
318
319 # Extract a usable image from packed formats
320 # - raw btrfs filesystem images, suffix .raw
321 # - dtto compressed by XZ, suffix .raw.xz
322 # - meta-dump images with suffix .img
323 # - dtto compressed by XZ, suffix .img.xz
324 # - compressed send stream, .stream.xz
325 extract_image()
326 {
327         local image
328         local cleanme
329
330         image="$1"
331         case "$image" in
332         *.img)
333                 rm -f "$image.restored"
334                 : ;;
335         *.img.xz)
336                 xz --decompress --keep "$image" || \
337                         _fail "failed to decompress image $image" >&2
338                 image=${image%%.xz}
339                 rm -f "$image.restored"
340                 cleanme=$image
341                 ;;
342         *.raw)
343                 cp --sparse=auto "$image" "$image.restored"
344                 ;;
345         *.raw.xz)
346                 xz --decompress --keep "$image" || \
347                         _fail "failed to decompress image $image" >&2
348                 image=${image%%.xz}
349                 mv "$image" "$image.restored"
350                 ;;
351         *.stream.xz)
352                 xz --decompress --keep "$image" || \
353                         _fail "failed to decompress file $image" >&2
354                 image=${image%%.xz}
355                 mv "$image" "$image.restored"
356                 ;;
357         esac
358
359         if ! [ -f "$image.restored" ]; then
360                 echo "restoring image $(basename $image)" >> "$RESULTS"
361                 "$TOP/btrfs-image" -r "$image" "$image.restored" \
362                         &>> "$RESULTS" \
363                         || _fail "failed to restore image $image" >&2
364         fi
365
366         [ -f "$cleanme" ] && rm -f "$cleanme"
367
368         echo "$image.restored"
369 }
370
371 # Process all image dumps in a given directory
372 check_all_images()
373 {
374         local dir
375         local extracted
376
377         dir="$1"
378         if [ -z "$dir" ]; then
379                 dir=.
380         fi
381         _assert_path "$dir"
382         for image in $(find "$dir" \( -iname '*.img' -o \
383                                 -iname '*.img.xz' -o    \
384                                 -iname '*.raw' -o       \
385                                 -iname '*.raw.xz' \) | sort)
386         do
387                 extracted=$(extract_image "$image")
388                 check_image "$extracted"
389                 rm -f "$extracted"
390         done
391 }
392
393 # some tests need to mount the recovered image and do verifications call
394 # 'setup_root_helper' and then check for have_root_helper == 1 if the test
395 # needs to fail otherwise; using sudo by default for now
396 SUDO_HELPER=
397 NEED_SUDO_VALIDATE=unknown
398 export SUDO_HELPER
399 export NEED_SUDO_VALIDATE
400 root_helper()
401 {
402         if [ $UID -eq 0 ]; then
403                 "$@"
404         else
405                 if [ "$NEED_SUDO_VALIDATE" = 'yes' ]; then
406                         sudo -v -n &>/dev/null || \
407                                 _not_run "Need to validate sudo credentials"
408                         sudo -n "$@"
409                 elif [ "$NEED_SUDO_VALIDATE" = 'no' ]; then
410                         sudo -n /bin/true &> /dev/null || \
411                                 _not_run "Need to validate sudo user settings"
412                         sudo -n "$@"
413                 else
414                         # should not happen
415                         _not_run "Need to validate root privileges"
416                 fi
417         fi
418 }
419
420 setup_root_helper()
421 {
422         if [ $UID -eq 0 -o -n "$SUDO_HELPER" ]; then
423                 return
424         fi
425
426         # Test for old sudo or special settings, which make sudo -v fail even
427         # if user setting is NOPASSWD
428         sudo -n /bin/true &>/dev/null && NEED_SUDO_VALIDATE=no
429
430         # Newer sudo or default sudo setting
431         sudo -v -n &>/dev/null && NEED_SUDO_VALIDATE=yes
432
433         if [ "$NEED_SUDO_VALIDATE" = 'unknown' ]; then
434                 _not_run "Need to validate root privileges"
435         fi
436         SUDO_HELPER=root_helper
437 }
438
439 prepare_test_dev()
440 {
441         # num[K/M/G/T...]
442         local size="$1"
443
444         [[ "$size" ]] || size='2G'
445         # Still truncate it to new size
446         if [ -n "$TEST_DEV" ]; then
447                 truncate -s 0 "$TEST_DEV"
448                 truncate -s "$size" "$TEST_DEV"
449                 return;
450         fi
451
452         echo "\$TEST_DEV not given, using $TOP/tests/test.img as fallback" >> \
453                 "$RESULTS"
454         TEST_DEV="$TOP/tests/test.img"
455
456         truncate -s 0 "$TEST_DEV"
457         truncate -s "$size" "$TEST_DEV" || _not_run "create file for loop device failed"
458 }
459
460 run_check_mount_test_dev()
461 {
462         setup_root_helper
463
464         local loop_opt
465         if [[ -b "$TEST_DEV" ]]; then
466                 loop_opt=""
467         elif [[ -f "$TEST_DEV" ]]; then
468                 loop_opt="-o loop"
469         else
470                 _fail "Invalid \$TEST_DEV: $TEST_DEV"
471         fi
472
473         [[ -d "$TEST_MNT" ]] || {
474                 _fail "Invalid \$TEST_MNT: $TEST_MNT"
475         }
476
477         run_check $SUDO_HELPER mount -t btrfs $loop_opt "$@" "$TEST_DEV" "$TEST_MNT"
478 }
479
480 run_check_umount_test_dev()
481 {
482         setup_root_helper
483         run_check $SUDO_HELPER umount "$@" "$TEST_DEV"
484 }
485
486 check_kernel_support()
487 {
488         if ! grep -iq 'btrfs' /proc/filesystems; then
489                 run_check $SUDO_HELPER modprobe btrfs
490                         if ! grep -iq 'btrfs' /proc/filesystems; then
491                                 echo \
492 "WARNING: btrfs filesystem not found in /proc/filesystems, some tests might fail"
493                                 return 1
494                         fi
495         fi
496         return 0
497 }
498
499 # how many files to create.
500 DATASET_SIZE=50
501
502 generate_dataset() {
503
504         dataset_type="$1"
505         dirpath=$TEST_MNT/$dataset_type
506         run_check $SUDO_HELPER mkdir -p "$dirpath"
507
508         case "$dataset_type" in
509                 small)
510                         for num in $(seq 1 "$DATASET_SIZE"); do
511                                 run_check $SUDO_HELPER dd if=/dev/urandom of="$dirpath/$dataset_type.$num" bs=10K \
512                                 count=1 >/dev/null 2>&1
513                         done
514                         ;;
515
516                 hardlink)
517                         for num in $(seq 1 "$DATASET_SIZE"); do
518                                 run_check $SUDO_HELPER touch "$dirpath/$dataset_type.$num"
519                                 run_check $SUDO_HELPER ln "$dirpath/$dataset_type.$num" "$dirpath/hlink.$num"
520                         done
521                         ;;
522
523                 fast_symlink)
524                         for num in $(seq 1 "$DATASET_SIZE"); do
525                                 run_check $SUDO_HELPER touch "$dirpath/$dataset_type.$num"
526                                 run_check cd "$dirpath" && \
527                                         $SUDO_HELPER ln -s "$dataset_type.$num" "$dirpath/slink.$num" && \
528                                         cd /
529                         done
530                         ;;
531
532                 brokenlink)
533                         for num in $(seq 1 "$DATASET_SIZE"); do
534                                 run_check $SUDO_HELPER ln -s "$dirpath/$dataset_type.$num" "$dirpath/blink.$num"
535                         done
536                         ;;
537
538                 perm)
539                         for modes in 777 775 755 750 700 666 664 644 640 600 444 440 400 000            \
540                                 1777 1775 1755 1750 1700 1666 1664 1644 1640 1600 1444 1440 1400 1000   \
541                                 2777 2775 2755 2750 2700 2666 2664 2644 2640 2600 2444 2440 2400 2000   \
542                                 4777 4775 4755 4750 4700 4666 4664 4644 4640 4600 4444 4440 4400 4000; do
543                                 run_check $SUDO_HELPER touch "$dirpath/$dataset_type.$modes"
544                                 run_check $SUDO_HELPER chmod "$modes" "$dirpath/$dataset_type.$modes"
545                         done
546                         ;;
547
548                 sparse)
549                         for num in $(seq 1 "$DATASET_SIZE"); do
550                                 run_check $SUDO_HELPER dd if=/dev/urandom of="$dirpath/$dataset_type.$num" bs=10K \
551                                 count=1 >/dev/null 2>&1
552                                 run_check $SUDO_HELPER truncate -s 500K "$dirpath/$dataset_type.$num"
553                                 run_check $SUDO_HELPER dd if=/dev/urandom of="$dirpath/$dataset_type.$num" bs=10K \
554                                 oflag=append conv=notrunc count=1 >/dev/null 2>&1
555                                 run_check $SUDO_HELPER truncate -s 800K "$dirpath/$dataset_type.$num"
556                         done
557                         ;;
558
559                 acls)
560                         for num in $(seq 1 "$DATASET_SIZE"); do
561                                 run_check $SUDO_HELPER touch "$dirpath/$dataset_type.$num"
562                                 run_check $SUDO_HELPER setfacl -m "u:root:x" "$dirpath/$dataset_type.$num"
563                                 run_check $SUDO_HELPER setfattr -n user.foo -v "bar$num" "$dirpath/$dataset_type.$num"
564                         done
565                         ;;
566
567                 fifo)
568                         for num in $(seq 1 "$DATASET_SIZE"); do
569                                 run_check $SUDO_HELPER mkfifo "$dirpath/$dataset_type.$num"
570                         done
571                         ;;
572
573                 slow_symlink)
574                         long_filename=`date +%s | sha256sum | cut -f1 -d ' '`
575                         run_check $SUDO_HELPER touch "$dirpath/$long_filename"
576                         for num in $(seq 1 "$DATASET_SIZE"); do
577                                 run_check $SUDO_HELPER ln -s "$dirpath/$long_filename" "$dirpath/slow_slink.$num"
578                         done
579                         ;;
580                 large)
581                         run_check $SUDO_HELPER dd if=/dev/urandom bs=32M count=1 \
582                                 of="$dirpath/$dataset_type" >/dev/null 2>&1
583                         ;;
584         esac
585 }
586
587 # prepare environment for loop devices, set up the following variables
588 # - nloopdevs -- number of desired devices
589 # - loopdevs  -- array containing paths to all devices (after prepare is called)
590 # - loopdev_prefix -- file backed images starting with this string, 'img' by default
591 #
592 # $1: number of loop devices to be set up
593 setup_loopdevs()
594 {
595         if [ -z "$1" ]; then
596                 _fail "setup_loopdevs needs a number"
597         fi
598         nloopdevs="$1"
599         loopdev_prefix=img
600         declare -a loopdevs
601
602 }
603
604 # create all loop devices from a given loopdev environment
605 prepare_loopdevs()
606 {
607         for i in `seq $nloopdevs`; do
608                 touch $loopdev_prefix$i
609                 chmod a+rw $loopdev_prefix$i
610                 truncate -s0 $loopdev_prefix$i
611                 truncate -s2g $loopdev_prefix$i
612                 loopdevs[$i]=`run_check_stdout $SUDO_HELPER losetup --find --show $loopdev_prefix$i`
613         done
614 }
615
616 # detach loop devices and reset their size to 0, delete the files afterwards
617 cleanup_loopdevs()
618 {
619         for dev in ${loopdevs[@]}; do
620                 run_check $SUDO_HELPER losetup -d $dev
621         done
622         for i in `seq $nloopdevs`; do
623                 truncate -s0 $loopdev_prefix$i
624                 rm -- "$loopdev_prefix$i"
625         done
626         run_check $SUDO_HELPER losetup --all
627 }
628
629 init_env()
630 {
631         TEST_MNT="${TEST_MNT:-$TOP/tests/mnt}"
632         export TEST_MNT
633         mkdir -p "$TEST_MNT" || { echo "Failed mkdir -p $TEST_MNT"; exit 1; }
634
635         source $TOP/tests/common.local
636
637         if [ "$TEST_ENABLE_OVERRIDE" = 'true' -a -n "$RESULTS" ]; then
638                 echo "INCLUDE common.local" >> "$RESULTS"
639                 echo "  check: $TEST_ARGS_CHECK" >> "$RESULTS"
640         fi
641 }
642 init_env