xref: /openbmc/qemu/tests/qemu-iotests/common.rc (revision 7f6c3d1a)
1#!/usr/bin/env bash
2#
3# Copyright (C) 2009 Red Hat, Inc.
4# Copyright (c) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.
5#
6# This program is free software; you can redistribute it and/or modify
7# it under the terms of the GNU General Public License as published by
8# the Free Software Foundation; either version 2 of the License, or
9# (at your option) any later version.
10#
11# This program is distributed in the hope that it will be useful,
12# but WITHOUT ANY WARRANTY; without even the implied warranty of
13# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
14# GNU General Public License for more details.
15#
16# You should have received a copy of the GNU General Public License
17# along with this program.  If not, see <http://www.gnu.org/licenses/>.
18#
19
20SED=
21for sed in sed gsed; do
22    ($sed --version | grep 'GNU sed') > /dev/null 2>&1
23    if [ "$?" -eq 0 ]; then
24        SED=$sed
25        break
26    fi
27done
28if [ -z "$SED" ]; then
29    echo "$0: GNU sed not found"
30    exit 1
31fi
32
33dd()
34{
35   if [ "$HOSTOS" == "Linux" ]
36   then
37        command dd --help | grep noxfer > /dev/null 2>&1
38
39        if [ "$?" -eq 0 ]
40            then
41                command dd status=noxfer $@
42            else
43                command dd $@
44            fi
45   else
46        command dd $@
47   fi
48}
49
50# poke_file 'test.img' 512 '\xff\xfe'
51poke_file()
52{
53    printf "$3" | dd "of=$1" bs=1 "seek=$2" conv=notrunc &>/dev/null
54}
55
56# poke_file_le $img_filename $offset $byte_width $value
57# Example: poke_file_le "$TEST_IMG" 512 2 65534
58poke_file_le()
59{
60    local img=$1 ofs=$2 len=$3 val=$4 str=''
61
62    while ((len--)); do
63        str+=$(printf '\\x%02x' $((val & 0xff)))
64        val=$((val >> 8))
65    done
66
67    poke_file "$img" "$ofs" "$str"
68}
69
70# poke_file_be $img_filename $offset $byte_width $value
71# Example: poke_file_be "$TEST_IMG" 512 2 65279
72poke_file_be()
73{
74    local img=$1 ofs=$2 len=$3 val=$4
75    local str=$(printf "%0$((len * 2))x\n" $val | sed 's/\(..\)/\\x\1/g')
76
77    poke_file "$img" "$ofs" "$str"
78}
79
80# peek_file_le 'test.img' 512 2 => 65534
81peek_file_le()
82{
83    local val=0 shift=0 byte
84
85    # coreutils' od --endian is not portable, so manually assemble bytes.
86    for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do
87        val=$(( val | (byte << shift) ))
88        shift=$((shift + 8))
89    done
90    printf %llu $val
91}
92
93# peek_file_be 'test.img' 512 2 => 65279
94peek_file_be()
95{
96    local val=0 byte
97
98    # coreutils' od --endian is not portable, so manually assemble bytes.
99    for byte in $(od -j"$2" -N"$3" -An -v -tu1 "$1"); do
100        val=$(( (val << 8) | byte ))
101    done
102    printf %llu $val
103}
104
105# peek_file_raw 'test.img' 512 2 => '\xff\xfe'. Do not use if the raw data
106# is likely to contain \0 or trailing \n.
107peek_file_raw()
108{
109    dd if="$1" bs=1 skip="$2" count="$3" status=none
110}
111
112
113if ! . ./common.config
114    then
115    echo "$0: failed to source common.config"
116    exit 1
117fi
118
119# Set the variables to the empty string to turn Valgrind off
120# for specific processes, e.g.
121# $ VALGRIND_QEMU_IO= ./check -qcow2 -valgrind 015
122
123: ${VALGRIND_QEMU_VM=$VALGRIND_QEMU}
124: ${VALGRIND_QEMU_IMG=$VALGRIND_QEMU}
125: ${VALGRIND_QEMU_IO=$VALGRIND_QEMU}
126: ${VALGRIND_QEMU_NBD=$VALGRIND_QEMU}
127
128# The Valgrind own parameters may be set with
129# its environment variable VALGRIND_OPTS, e.g.
130# $ VALGRIND_OPTS="--leak-check=yes" ./check -qcow2 -valgrind 015
131
132_qemu_proc_exec()
133{
134    local VALGRIND_LOGFILE="$1"
135    shift
136    if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then
137        exec valgrind --log-file="${VALGRIND_LOGFILE}" --error-exitcode=99 "$@"
138    else
139        exec "$@"
140    fi
141}
142
143_qemu_proc_valgrind_log()
144{
145    local VALGRIND_LOGFILE="$1"
146    local RETVAL="$2"
147    if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then
148        if [ $RETVAL == 99 ]; then
149            cat "${VALGRIND_LOGFILE}"
150        fi
151        rm -f "${VALGRIND_LOGFILE}"
152    fi
153}
154
155_qemu_wrapper()
156{
157    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
158    (
159        if [ -n "${QEMU_NEED_PID}" ]; then
160            echo $BASHPID > "${QEMU_TEST_DIR}/qemu-${_QEMU_HANDLE}.pid"
161        fi
162        VALGRIND_QEMU="${VALGRIND_QEMU_VM}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
163            "$QEMU_PROG" $QEMU_OPTIONS "$@"
164    )
165    RETVAL=$?
166    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
167    return $RETVAL
168}
169
170_qemu_img_wrapper()
171{
172    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
173    (
174        VALGRIND_QEMU="${VALGRIND_QEMU_IMG}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
175            "$QEMU_IMG_PROG" $QEMU_IMG_OPTIONS "$@"
176    )
177    RETVAL=$?
178    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
179    return $RETVAL
180}
181
182_qemu_io_wrapper()
183{
184    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
185    local QEMU_IO_ARGS="$QEMU_IO_OPTIONS"
186    if [ "$IMGOPTSSYNTAX" = "true" ]; then
187        QEMU_IO_ARGS="--image-opts $QEMU_IO_ARGS"
188        if [ -n "$IMGKEYSECRET" ]; then
189            QEMU_IO_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IO_ARGS"
190        fi
191    fi
192    (
193        VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
194            "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@"
195    )
196    RETVAL=$?
197    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
198    return $RETVAL
199}
200
201_qemu_nbd_wrapper()
202{
203    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
204    (
205        VALGRIND_QEMU="${VALGRIND_QEMU_NBD}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
206            "$QEMU_NBD_PROG" --pid-file="${QEMU_TEST_DIR}/qemu-nbd.pid" \
207             $QEMU_NBD_OPTIONS "$@"
208    )
209    RETVAL=$?
210    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
211    return $RETVAL
212}
213
214# Valgrind bug #409141 https://bugs.kde.org/show_bug.cgi?id=409141
215# Until valgrind 3.16+ is ubiquitous, we must work around a hang in
216# valgrind when issuing sigkill. Disable valgrind for this invocation.
217_NO_VALGRIND()
218{
219    NO_VALGRIND="y" "$@"
220}
221
222export QEMU=_qemu_wrapper
223export QEMU_IMG=_qemu_img_wrapper
224export QEMU_IO=_qemu_io_wrapper
225export QEMU_NBD=_qemu_nbd_wrapper
226
227if [ "$IMGOPTSSYNTAX" = "true" ]; then
228    DRIVER="driver=$IMGFMT"
229    QEMU_IMG_EXTRA_ARGS="--image-opts $QEMU_IMG_EXTRA_ARGS"
230    if [ -n "$IMGKEYSECRET" ]; then
231        QEMU_IMG_EXTRA_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IMG_EXTRA_ARGS"
232    fi
233    if [ "$IMGFMT" = "luks" ]; then
234        DRIVER="$DRIVER,key-secret=keysec0"
235    fi
236    if [ "$IMGPROTO" = "file" ]; then
237        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
238        TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT"
239    elif [ "$IMGPROTO" = "nbd" ]; then
240        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
241        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix"
242        TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd"
243    elif [ "$IMGPROTO" = "ssh" ]; then
244        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
245        TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE"
246    elif [ "$IMGPROTO" = "nfs" ]; then
247        TEST_DIR="$DRIVER,file.driver=nfs,file.filename=nfs://127.0.0.1/$TEST_DIR"
248        TEST_IMG=$TEST_DIR/t.$IMGFMT
249    else
250        TEST_IMG="$DRIVER,file.driver=$IMGPROTO,file.filename=$TEST_DIR/t.$IMGFMT"
251    fi
252else
253    QEMU_IMG_EXTRA_ARGS=
254    if [ "$IMGPROTO" = "file" ]; then
255        TEST_IMG=$TEST_DIR/t.$IMGFMT
256    elif [ "$IMGPROTO" = "nbd" ]; then
257        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
258        TEST_IMG="nbd+unix:///?socket=$SOCK_DIR/nbd"
259    elif [ "$IMGPROTO" = "ssh" ]; then
260        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
261        REMOTE_TEST_DIR="ssh://\\($USER@\\)\\?127.0.0.1\\(:[0-9]\\+\\)\\?$TEST_DIR"
262        TEST_IMG="ssh://127.0.0.1$TEST_IMG_FILE"
263    elif [ "$IMGPROTO" = "nfs" ]; then
264        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
265        REMOTE_TEST_DIR="nfs://127.0.0.1$TEST_DIR"
266        TEST_IMG="nfs://127.0.0.1$TEST_IMG_FILE"
267    else
268        TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
269    fi
270fi
271ORIG_TEST_IMG="$TEST_IMG"
272
273if [ -z "$TEST_DIR" ]; then
274        TEST_DIR=$PWD/scratch
275fi
276
277QEMU_TEST_DIR="${TEST_DIR}"
278
279if [ ! -e "$TEST_DIR" ]; then
280        mkdir "$TEST_DIR"
281fi
282
283if [ ! -d "$TEST_DIR" ]; then
284    echo "common.rc: Error: \$TEST_DIR ($TEST_DIR) is not a directory"
285    exit 1
286fi
287
288if [ -z "$REMOTE_TEST_DIR" ]; then
289    REMOTE_TEST_DIR="$TEST_DIR"
290fi
291
292if [ ! -d "$SAMPLE_IMG_DIR" ]; then
293    echo "common.rc: Error: \$SAMPLE_IMG_DIR ($SAMPLE_IMG_DIR) is not a directory"
294    exit 1
295fi
296
297_use_sample_img()
298{
299    SAMPLE_IMG_FILE="${1%\.bz2}"
300    TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE"
301    bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG"
302    if [ $? -ne 0 ]
303    then
304        echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'"
305        exit 1
306    fi
307}
308
309_stop_nbd_server()
310{
311    if [ -f "${QEMU_TEST_DIR}/qemu-nbd.pid" ]; then
312        local QEMU_NBD_PID
313        read QEMU_NBD_PID < "${QEMU_TEST_DIR}/qemu-nbd.pid"
314        kill ${QEMU_NBD_PID}
315        rm -f "${QEMU_TEST_DIR}/qemu-nbd.pid" "$SOCK_DIR/nbd"
316    fi
317}
318
319# Gets the data_file value from IMGOPTS and replaces the '$TEST_IMG'
320# pattern by '$1'
321# Caution: The replacement is done with sed, so $1 must be escaped
322#          properly.  (The delimiter is '#'.)
323_get_data_file()
324{
325    if ! echo "$IMGOPTS" | grep -q 'data_file='; then
326        return 1
327    fi
328
329    echo "$IMGOPTS" | sed -e 's/.*data_file=\([^,]*\).*/\1/' \
330                    | sed -e "s#\\\$TEST_IMG#$1#"
331}
332
333_make_test_img()
334{
335    # extra qemu-img options can be added by tests
336    # at least one argument (the image size) needs to be added
337    local extra_img_options=""
338    local optstr=""
339    local img_name=""
340    local use_backing=0
341    local backing_file=""
342    local object_options=""
343    local opts_param=false
344    local misc_params=()
345
346    if [ -n "$TEST_IMG_FILE" ]; then
347        img_name=$TEST_IMG_FILE
348    else
349        img_name=$TEST_IMG
350    fi
351
352    if [ -n "$IMGOPTS" ]; then
353        imgopts_expanded=$(echo "$IMGOPTS" | sed -e "s#\\\$TEST_IMG#$img_name#")
354        optstr=$(_optstr_add "$optstr" "$imgopts_expanded")
355    fi
356    if [ -n "$IMGKEYSECRET" ]; then
357        object_options="--object secret,id=keysec0,data=$IMGKEYSECRET"
358        optstr=$(_optstr_add "$optstr" "key-secret=keysec0")
359    fi
360
361    for param; do
362        if [ "$use_backing" = "1" -a -z "$backing_file" ]; then
363            backing_file=$param
364            continue
365        elif $opts_param; then
366            optstr=$(_optstr_add "$optstr" "$param")
367            opts_param=false
368            continue
369        fi
370
371        case "$param" in
372            -b)
373                use_backing=1
374                ;;
375
376            -o)
377                opts_param=true
378                ;;
379
380            --no-opts)
381                optstr=""
382                ;;
383
384            *)
385                misc_params=("${misc_params[@]}" "$param")
386                ;;
387        esac
388    done
389
390    if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then
391        optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE")
392    fi
393
394    if [ -n "$optstr" ]; then
395        extra_img_options="-o $optstr $extra_img_options"
396    fi
397
398    if [ $IMGPROTO = "nbd" ]; then
399        _stop_nbd_server
400    fi
401
402    # XXX(hch): have global image options?
403    (
404     if [ $use_backing = 1 ]; then
405        $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" "${misc_params[@]}" 2>&1
406     else
407        $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" "${misc_params[@]}" 2>&1
408     fi
409    ) | _filter_img_create
410
411    # Start an NBD server on the image file, which is what we'll be talking to.
412    # Once NBD gains resize support, we may also want to use -f raw at the
413    # server and interpret format over NBD, but for now, the format is
414    # interpreted at the server and raw data sent over NBD.
415    if [ $IMGPROTO = "nbd" ]; then
416        # Pass a sufficiently high number to -e that should be enough for all
417        # tests
418        eval "$QEMU_NBD -v -t -k '$SOCK_DIR/nbd' -f $IMGFMT -e 42 -x '' $TEST_IMG_FILE >/dev/null &"
419        sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
420    fi
421}
422
423_rm_test_img()
424{
425    local img=$1
426    if [ "$IMGFMT" = "vmdk" ]; then
427        # Remove all the extents for vmdk
428        "$QEMU_IMG" info "$img" 2>/dev/null | grep 'filename:' | cut -f 2 -d: \
429            | xargs -I {} rm -f "{}"
430    elif [ "$IMGFMT" = "qcow2" ]; then
431        # Remove external data file
432        if data_file=$(_get_data_file "$img"); then
433            rm -f "$data_file"
434        fi
435    fi
436    rm -f "$img"
437}
438
439_cleanup_test_img()
440{
441    case "$IMGPROTO" in
442
443        nbd)
444            _stop_nbd_server
445            rm -f "$TEST_IMG_FILE"
446            ;;
447
448        file)
449            _rm_test_img "$TEST_DIR/t.$IMGFMT"
450            _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
451            _rm_test_img "$TEST_DIR/t.$IMGFMT.base"
452            if [ -n "$SAMPLE_IMG_FILE" ]
453            then
454                rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
455                SAMPLE_IMG_FILE=
456                TEST_IMG="$ORIG_TEST_IMG"
457            fi
458            ;;
459
460        rbd)
461            rbd --no-progress rm "$TEST_DIR/t.$IMGFMT" > /dev/null
462            ;;
463
464        sheepdog)
465            collie vdi delete "$TEST_DIR/t.$IMGFMT"
466            ;;
467
468    esac
469}
470
471_check_test_img()
472{
473    (
474        if [ "$IMGOPTSSYNTAX" = "true" ]; then
475            $QEMU_IMG check $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1
476        else
477            $QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1
478        fi
479    ) | _filter_testdir | _filter_qemu_img_check
480
481    # return real qemu_img check status, to analyze in
482    # _check_test_img_ignore_leaks
483    return ${PIPESTATUS[0]}
484}
485
486_check_test_img_ignore_leaks()
487{
488    out=$(_check_test_img "$@")
489    status=$?
490    if [ $status = 3 ]; then
491        # This must correspond to success output in dump_human_image_check()
492        echo "No errors were found on the image."
493        return 0
494    fi
495    echo "$out"
496    return $status
497}
498
499_img_info()
500{
501    if [[ "$1" == "--format-specific" ]]; then
502        local format_specific=1
503        shift
504    else
505        local format_specific=0
506    fi
507
508    discard=0
509    regex_json_spec_start='^ *"format-specific": \{'
510    $QEMU_IMG info $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 | \
511        sed -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \
512            -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
513            -e "s#$TEST_DIR#TEST_DIR#g" \
514            -e "s#$IMGFMT#IMGFMT#g" \
515            -e "/^disk size:/ D" \
516            -e "/actual-size/ D" | \
517        while IFS='' read -r line; do
518            if [[ $format_specific == 1 ]]; then
519                discard=0
520            elif [[ $line == "Format specific information:" ]]; then
521                discard=1
522            elif [[ $line =~ $regex_json_spec_start ]]; then
523                discard=2
524                regex_json_spec_end="^${line%%[^ ]*}\\},? *$"
525            fi
526            if [[ $discard == 0 ]]; then
527                echo "$line"
528            elif [[ $discard == 1 && ! $line ]]; then
529                echo
530                discard=0
531            elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
532                discard=0
533            fi
534        done
535}
536
537# bail out, setting up .notrun file
538#
539_notrun()
540{
541    echo "$*" >"$OUTPUT_DIR/$seq.notrun"
542    echo "$seq not run: $*"
543    status=0
544    exit
545}
546
547# bail out, setting up .casenotrun file
548# The function _casenotrun() is used as a notifier. It is the
549# caller's responsibility to make skipped a particular test.
550#
551_casenotrun()
552{
553    echo "    [case not run] $*" >>"$OUTPUT_DIR/$seq.casenotrun"
554}
555
556# just plain bail out
557#
558_fail()
559{
560    echo "$*" | tee -a "$OUTPUT_DIR/$seq.full"
561    echo "(see $seq.full for details)"
562    status=1
563    exit 1
564}
565
566# tests whether $IMGFMT is one of the supported image formats for a test
567#
568_supported_fmt()
569{
570    # "generic" is suitable for most image formats. For some formats it doesn't
571    # work, however (most notably read-only formats), so they can opt out by
572    # setting IMGFMT_GENERIC to false.
573    for f; do
574        if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then
575            if [ "$IMGFMT" = "luks" ]; then
576                _require_working_luks
577            fi
578            return
579        fi
580    done
581
582    _notrun "not suitable for this image format: $IMGFMT"
583}
584
585# tests whether $IMGFMT is one of the unsupported image format for a test
586#
587_unsupported_fmt()
588{
589    for f; do
590        if [ "$f" = "$IMGFMT" ]; then
591            _notrun "not suitable for this image format: $IMGFMT"
592        fi
593    done
594}
595
596# tests whether $IMGPROTO is one of the supported image protocols for a test
597#
598_supported_proto()
599{
600    for f; do
601        if [ "$f" = "$IMGPROTO" -o "$f" = "generic" ]; then
602            return
603        fi
604    done
605
606    _notrun "not suitable for this image protocol: $IMGPROTO"
607}
608
609# tests whether $IMGPROTO is specified as an unsupported image protocol for a test
610#
611_unsupported_proto()
612{
613    for f; do
614        if [ "$f" = "$IMGPROTO" ]; then
615            _notrun "not suitable for this image protocol: $IMGPROTO"
616            return
617        fi
618    done
619}
620
621# tests whether the host OS is one of the supported OSes for a test
622#
623_supported_os()
624{
625    for h
626    do
627        if [ "$h" = "$HOSTOS" ]
628        then
629            return
630        fi
631    done
632
633    _notrun "not suitable for this OS: $HOSTOS"
634}
635
636_supported_cache_modes()
637{
638    for mode; do
639        if [ "$mode" = "$CACHEMODE" ]; then
640            return
641        fi
642    done
643    _notrun "not suitable for cache mode: $CACHEMODE"
644}
645
646# Check whether the filesystem supports O_DIRECT
647_check_o_direct()
648{
649    $QEMU_IMG create -f raw "$TEST_IMG".test_o_direct 1M > /dev/null
650    out=$($QEMU_IO -f raw -t none -c quit "$TEST_IMG".test_o_direct 2>&1)
651    rm -f "$TEST_IMG".test_o_direct
652
653    [[ "$out" != *"O_DIRECT"* ]]
654}
655
656_require_o_direct()
657{
658    if ! _check_o_direct; then
659        _notrun "file system on $TEST_DIR does not support O_DIRECT"
660    fi
661}
662
663_check_cache_mode()
664{
665    if [ $CACHEMODE == "none" ] || [ $CACHEMODE == "directsync" ]; then
666        _require_o_direct
667    fi
668}
669
670_check_cache_mode
671
672# $1 - cache mode to use by default
673# $2 - (optional) cache mode to use by default if O_DIRECT is not supported
674_default_cache_mode()
675{
676    if $CACHEMODE_IS_DEFAULT; then
677        if [ -z "$2" ] || _check_o_direct; then
678            CACHEMODE="$1"
679        else
680            CACHEMODE="$2"
681        fi
682        QEMU_IO="$QEMU_IO --cache $CACHEMODE"
683        _check_cache_mode
684        return
685    fi
686}
687_supported_aio_modes()
688{
689    for mode; do
690        if [ "$mode" = "$AIOMODE" ]; then
691            return
692        fi
693    done
694    _notrun "not suitable for aio mode: $AIOMODE"
695}
696_default_aio_mode()
697{
698    AIOMODE="$1"
699    QEMU_IO="$QEMU_IO --aio $1"
700}
701
702_unsupported_imgopts()
703{
704    for bad_opt
705    do
706        if echo "$IMGOPTS" | grep -q 2>/dev/null "$bad_opt"
707        then
708            _notrun "not suitable for image option: $bad_opt"
709        fi
710    done
711}
712
713# Caution: Overwrites $TEST_DIR/t.luks
714_require_working_luks()
715{
716    file="$TEST_DIR/t.luks"
717
718    output=$(
719        $QEMU_IMG create -f luks \
720            --object secret,id=sec0,data=hunter0 \
721            -o key-secret=sec0 \
722            -o iter-time=10 \
723            "$file" \
724            1M \
725            2>&1
726    )
727    status=$?
728
729    IMGFMT='luks' _rm_test_img "$file"
730
731    if [ $status != 0 ]; then
732        reason=$(echo "$output" | grep "$file:" | $SED -e "s#.*$file: *##")
733        if [ -z "$reason" ]; then
734            reason="Failed to create a LUKS image"
735        fi
736        _notrun "$reason"
737    fi
738}
739
740# this test requires that a specified command (executable) exists
741#
742_require_command()
743{
744    if [ "$1" = "QEMU" ]; then
745        c=$QEMU_PROG
746    elif [ "$1" = "QEMU_IMG" ]; then
747        c=$QEMU_IMG_PROG
748    elif [ "$1" = "QEMU_IO" ]; then
749        c=$QEMU_IO_PROG
750    elif [ "$1" = "QEMU_NBD" ]; then
751        c=$QEMU_NBD_PROG
752    else
753        eval c=\$$1
754    fi
755    [ -x "$c" ] || _notrun "$1 utility required, skipped this test"
756}
757
758# Check that a set of drivers has been whitelisted in the QEMU binary
759#
760_require_drivers()
761{
762    available=$($QEMU -drive format=help | \
763                sed -e '/Supported formats:/!d' -e 's/Supported formats://')
764    for driver
765    do
766        if ! echo "$available" | grep -q " $driver\( \|$\)"; then
767            _notrun "$driver not available"
768        fi
769    done
770}
771
772# Check that we have a file system that allows huge (but very sparse) files
773#
774_require_large_file()
775{
776    if ! truncate --size="$1" "$TEST_IMG"; then
777        _notrun "file system on $TEST_DIR does not support large enough files"
778    fi
779    rm "$TEST_IMG"
780}
781
782# Check that a set of devices is available in the QEMU binary
783#
784_require_devices()
785{
786    available=$($QEMU -M none -device help | \
787                grep ^name | sed -e 's/^name "//' -e 's/".*$//')
788    for device
789    do
790        if ! echo "$available" | grep -q "$device" ; then
791            _notrun "$device not available"
792        fi
793    done
794}
795
796# make sure this script returns success
797true
798