[mirror_qemu.git] / tests / qemu-iotests / common.rc

#!/usr/bin/env bash
#
# Copyright (C) 2009 Red Hat, Inc.
# Copyright (c) 2000-2006 Silicon Graphics, Inc.  All Rights Reserved.
#
# This program is free software; you can redistribute it and/or modify
# it under the terms of the GNU General Public License as published by
# the Free Software Foundation; either version 2 of the License, or
# (at your option) any later version.
#
# This program is distributed in the hope that it will be useful,
# but WITHOUT ANY WARRANTY; without even the implied warranty of
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
# GNU General Public License for more details.
#
# You should have received a copy of the GNU General Public License
# along with this program.  If not, see <http://www.gnu.org/licenses/>.
#

SED=
for sed in sed gsed; do
    ($sed --version | grep 'GNU sed') > /dev/null 2>&1
    if [ "$?" -eq 0 ]; then
        SED=$sed
        break
    fi
done
if [ -z "$SED" ]; then
    echo "$0: GNU sed not found"
    exit 1
fi

dd()
{
   if [ "$HOSTOS" == "Linux" ]
   then
        command dd --help | grep noxfer > /dev/null 2>&1

        if [ "$?" -eq 0 ]
            then
                command dd status=noxfer $@
            else
                command dd $@
            fi
   else
        command dd $@
   fi
}

# poke_file 'test.img' 512 '\xff\xfe'
poke_file()
{
    printf "$3" | dd "of=$1" bs=1 "seek=$2" conv=notrunc &>/dev/null
}

# peek_file_le 'test.img' 512 2 => 65534
peek_file_le()
{
    # Wrap in echo $() to strip spaces
    echo $(od -j"$2" -N"$3" --endian=little -An -vtu"$3" "$1")
}

# peek_file_be 'test.img' 512 2 => 65279
peek_file_be()
{
    # Wrap in echo $() to strip spaces
    echo $(od -j"$2" -N"$3" --endian=big -An -vtu"$3" "$1")
}

# peek_file_raw 'test.img' 512 2 => '\xff\xfe'
peek_file_raw()
{
    dd if="$1" bs=1 skip="$2" count="$3" status=none
}


if ! . ./common.config
    then
    echo "$0: failed to source common.config"
    exit 1
fi

# Set the variables to the empty string to turn Valgrind off
# for specific processes, e.g.
# $ VALGRIND_QEMU_IO= ./check -qcow2 -valgrind 015

: ${VALGRIND_QEMU_VM=$VALGRIND_QEMU}
: ${VALGRIND_QEMU_IMG=$VALGRIND_QEMU}
: ${VALGRIND_QEMU_IO=$VALGRIND_QEMU}
: ${VALGRIND_QEMU_NBD=$VALGRIND_QEMU}
: ${VALGRIND_QEMU_VXHS=$VALGRIND_QEMU}

# The Valgrind own parameters may be set with
# its environment variable VALGRIND_OPTS, e.g.
# $ VALGRIND_OPTS="--leak-check=yes" ./check -qcow2 -valgrind 015

_qemu_proc_exec()
{
    local VALGRIND_LOGFILE="$1"
    shift
    if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then
        exec valgrind --log-file="${VALGRIND_LOGFILE}" --error-exitcode=99 "$@"
    else
        exec "$@"
    fi
}

_qemu_proc_valgrind_log()
{
    local VALGRIND_LOGFILE="$1"
    local RETVAL="$2"
    if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then
        if [ $RETVAL == 99 ]; then
            cat "${VALGRIND_LOGFILE}"
        fi
        rm -f "${VALGRIND_LOGFILE}"
    fi
}

_qemu_wrapper()
{
    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
    (
        if [ -n "${QEMU_NEED_PID}" ]; then
            echo $BASHPID > "${QEMU_TEST_DIR}/qemu-${_QEMU_HANDLE}.pid"
        fi
        VALGRIND_QEMU="${VALGRIND_QEMU_VM}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
            "$QEMU_PROG" $QEMU_OPTIONS "$@"
    )
    RETVAL=$?
    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
    return $RETVAL
}

_qemu_img_wrapper()
{
    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
    (
        VALGRIND_QEMU="${VALGRIND_QEMU_IMG}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
            "$QEMU_IMG_PROG" $QEMU_IMG_OPTIONS "$@"
    )
    RETVAL=$?
    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
    return $RETVAL
}

_qemu_io_wrapper()
{
    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
    local QEMU_IO_ARGS="$QEMU_IO_OPTIONS"
    if [ "$IMGOPTSSYNTAX" = "true" ]; then
        QEMU_IO_ARGS="--image-opts $QEMU_IO_ARGS"
        if [ -n "$IMGKEYSECRET" ]; then
            QEMU_IO_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IO_ARGS"
        fi
    fi
    (
        VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
            "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@"
    )
    RETVAL=$?
    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
    return $RETVAL
}

_qemu_nbd_wrapper()
{
    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
    (
        VALGRIND_QEMU="${VALGRIND_QEMU_NBD}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
            "$QEMU_NBD_PROG" --pid-file="${QEMU_TEST_DIR}/qemu-nbd.pid" \
             $QEMU_NBD_OPTIONS "$@"
    )
    RETVAL=$?
    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
    return $RETVAL
}

_qemu_vxhs_wrapper()
{
    local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
    (
        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
        VALGRIND_QEMU="${VALGRIND_QEMU_VXHS}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
            "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
    )
    RETVAL=$?
    _qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
    return $RETVAL
}

# Valgrind bug #409141 https://bugs.kde.org/show_bug.cgi?id=409141
# Until valgrind 3.16+ is ubiquitous, we must work around a hang in
# valgrind when issuing sigkill. Disable valgrind for this invocation.
_NO_VALGRIND()
{
    NO_VALGRIND="y" "$@"
}

export QEMU=_qemu_wrapper
export QEMU_IMG=_qemu_img_wrapper
export QEMU_IO=_qemu_io_wrapper
export QEMU_NBD=_qemu_nbd_wrapper
export QEMU_VXHS=_qemu_vxhs_wrapper

if [ "$IMGOPTSSYNTAX" = "true" ]; then
    DRIVER="driver=$IMGFMT"
    QEMU_IMG_EXTRA_ARGS="--image-opts $QEMU_IMG_EXTRA_ARGS"
    if [ -n "$IMGKEYSECRET" ]; then
        QEMU_IMG_EXTRA_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IMG_EXTRA_ARGS"
    fi
    if [ "$IMGFMT" = "luks" ]; then
        DRIVER="$DRIVER,key-secret=keysec0"
    fi
    if [ "$IMGPROTO" = "file" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT"
    elif [ "$IMGPROTO" = "nbd" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix"
        TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd"
    elif [ "$IMGPROTO" = "ssh" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE"
    elif [ "$IMGPROTO" = "nfs" ]; then
        TEST_DIR="$DRIVER,file.driver=nfs,file.filename=nfs://127.0.0.1/$TEST_DIR"
        TEST_IMG=$TEST_DIR/t.$IMGFMT
    else
        TEST_IMG="$DRIVER,file.driver=$IMGPROTO,file.filename=$TEST_DIR/t.$IMGFMT"
    fi
else
    QEMU_IMG_EXTRA_ARGS=
    if [ "$IMGPROTO" = "file" ]; then
        TEST_IMG=$TEST_DIR/t.$IMGFMT
    elif [ "$IMGPROTO" = "nbd" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        TEST_IMG="nbd+unix:///?socket=$SOCK_DIR/nbd"
    elif [ "$IMGPROTO" = "ssh" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        REMOTE_TEST_DIR="ssh://\\($USER@\\)\\?127.0.0.1\\(:[0-9]\\+\\)\\?$TEST_DIR"
        TEST_IMG="ssh://127.0.0.1$TEST_IMG_FILE"
    elif [ "$IMGPROTO" = "nfs" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        REMOTE_TEST_DIR="nfs://127.0.0.1$TEST_DIR"
        TEST_IMG="nfs://127.0.0.1$TEST_IMG_FILE"
    elif [ "$IMGPROTO" = "vxhs" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
    else
        TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
    fi
fi
ORIG_TEST_IMG="$TEST_IMG"

if [ -z "$TEST_DIR" ]; then
        TEST_DIR=$PWD/scratch
fi

QEMU_TEST_DIR="${TEST_DIR}"

if [ ! -e "$TEST_DIR" ]; then
        mkdir "$TEST_DIR"
fi

if [ ! -d "$TEST_DIR" ]; then
    echo "common.rc: Error: \$TEST_DIR ($TEST_DIR) is not a directory"
    exit 1
fi

if [ -z "$REMOTE_TEST_DIR" ]; then
    REMOTE_TEST_DIR="$TEST_DIR"
fi

if [ ! -d "$SAMPLE_IMG_DIR" ]; then
    echo "common.rc: Error: \$SAMPLE_IMG_DIR ($SAMPLE_IMG_DIR) is not a directory"
    exit 1
fi

_use_sample_img()
{
    SAMPLE_IMG_FILE="${1%\.bz2}"
    TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE"
    bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG"
    if [ $? -ne 0 ]
    then
        echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'"
        exit 1
    fi
}

_stop_nbd_server()
{
    if [ -f "${QEMU_TEST_DIR}/qemu-nbd.pid" ]; then
        local QEMU_NBD_PID
        read QEMU_NBD_PID < "${QEMU_TEST_DIR}/qemu-nbd.pid"
        kill ${QEMU_NBD_PID}
        rm -f "${QEMU_TEST_DIR}/qemu-nbd.pid" "$SOCK_DIR/nbd"
    fi
}

# Gets the data_file value from IMGOPTS and replaces the '$TEST_IMG'
# pattern by '$1'
# Caution: The replacement is done with sed, so $1 must be escaped
#          properly.  (The delimiter is '#'.)
_get_data_file()
{
    if ! echo "$IMGOPTS" | grep -q 'data_file='; then
        return 1
    fi

    echo "$IMGOPTS" | sed -e 's/.*data_file=\([^,]*\).*/\1/' \
                    | sed -e "s#\\\$TEST_IMG#$1#"
}

_make_test_img()
{
    # extra qemu-img options can be added by tests
    # at least one argument (the image size) needs to be added
    local extra_img_options=""
    local optstr=""
    local img_name=""
    local use_backing=0
    local backing_file=""
    local object_options=""
    local opts_param=false
    local misc_params=()

    if [ -n "$TEST_IMG_FILE" ]; then
        img_name=$TEST_IMG_FILE
    else
        img_name=$TEST_IMG
    fi

    if [ -n "$IMGOPTS" ]; then
        imgopts_expanded=$(echo "$IMGOPTS" | sed -e "s#\\\$TEST_IMG#$img_name#")
        optstr=$(_optstr_add "$optstr" "$imgopts_expanded")
    fi
    if [ -n "$IMGKEYSECRET" ]; then
        object_options="--object secret,id=keysec0,data=$IMGKEYSECRET"
        optstr=$(_optstr_add "$optstr" "key-secret=keysec0")
    fi

    for param; do
        if [ "$use_backing" = "1" -a -z "$backing_file" ]; then
            backing_file=$param
            continue
        elif $opts_param; then
            optstr=$(_optstr_add "$optstr" "$param")
            opts_param=false
            continue
        fi

        case "$param" in
            -b)
                use_backing=1
                ;;

            -o)
                opts_param=true
                ;;

            --no-opts)
                optstr=""
                ;;

            *)
                misc_params=("${misc_params[@]}" "$param")
                ;;
        esac
    done

    if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then
        optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE")
    fi

    if [ -n "$optstr" ]; then
        extra_img_options="-o $optstr $extra_img_options"
    fi

    if [ $IMGPROTO = "nbd" ]; then
        _stop_nbd_server
    fi

    # XXX(hch): have global image options?
    (
     if [ $use_backing = 1 ]; then
        $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" "${misc_params[@]}" 2>&1
     else
        $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" "${misc_params[@]}" 2>&1
     fi
    ) | _filter_img_create

    # Start an NBD server on the image file, which is what we'll be talking to.
    # Once NBD gains resize support, we may also want to use -f raw at the
    # server and interpret format over NBD, but for now, the format is
    # interpreted at the server and raw data sent over NBD.
    if [ $IMGPROTO = "nbd" ]; then
        # Pass a sufficiently high number to -e that should be enough for all
        # tests
        eval "$QEMU_NBD -v -t -k '$SOCK_DIR/nbd' -f $IMGFMT -e 42 -x '' $TEST_IMG_FILE >/dev/null &"
        sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
    fi

    # Start QNIO server on image directory for vxhs protocol
    if [ $IMGPROTO = "vxhs" ]; then
        eval "$QEMU_VXHS -d  $TEST_DIR > /dev/null &"
        sleep 1 # Wait for server to come up.
    fi
}

_rm_test_img()
{
    local img=$1
    if [ "$IMGFMT" = "vmdk" ]; then
        # Remove all the extents for vmdk
        "$QEMU_IMG" info "$img" 2>/dev/null | grep 'filename:' | cut -f 2 -d: \
            | xargs -I {} rm -f "{}"
    elif [ "$IMGFMT" = "qcow2" ]; then
        # Remove external data file
        if data_file=$(_get_data_file "$img"); then
            rm -f "$data_file"
        fi
    fi
    rm -f "$img"
}

_cleanup_test_img()
{
    case "$IMGPROTO" in

        nbd)
            _stop_nbd_server
            rm -f "$TEST_IMG_FILE"
            ;;
        vxhs)
            if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
                local QEMU_VXHS_PID
                read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
                kill ${QEMU_VXHS_PID} >/dev/null 2>&1
                rm -f "${TEST_DIR}/qemu-vxhs.pid"
            fi
            rm -f "$TEST_IMG_FILE"
            ;;

        file)
            _rm_test_img "$TEST_DIR/t.$IMGFMT"
            _rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
            _rm_test_img "$TEST_DIR/t.$IMGFMT.base"
            if [ -n "$SAMPLE_IMG_FILE" ]
            then
                rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
                SAMPLE_IMG_FILE=
                TEST_IMG="$ORIG_TEST_IMG"
            fi
            ;;

        rbd)
            rbd --no-progress rm "$TEST_DIR/t.$IMGFMT" > /dev/null
            ;;

        sheepdog)
            collie vdi delete "$TEST_DIR/t.$IMGFMT"
            ;;

    esac
}

_check_test_img()
{
    (
        if [ "$IMGOPTSSYNTAX" = "true" ]; then
            $QEMU_IMG check $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1
        else
            $QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1
        fi
    ) | _filter_testdir | _filter_qemu_img_check

    # return real qemu_img check status, to analyze in
    # _check_test_img_ignore_leaks
    return ${PIPESTATUS[0]}
}

_check_test_img_ignore_leaks()
{
    out=$(_check_test_img "$@")
    status=$?
    if [ $status = 3 ]; then
        # This must correspond to success output in dump_human_image_check()
        echo "No errors were found on the image."
        return 0
    fi
    echo "$out"
    return $status
}

_img_info()
{
    if [[ "$1" == "--format-specific" ]]; then
        local format_specific=1
        shift
    else
        local format_specific=0
    fi

    discard=0
    regex_json_spec_start='^ *"format-specific": \{'
    $QEMU_IMG info $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 | \
        sed -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \
            -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
            -e "s#$TEST_DIR#TEST_DIR#g" \
            -e "s#$IMGFMT#IMGFMT#g" \
            -e "/^disk size:/ D" \
            -e "/actual-size/ D" | \
        while IFS='' read -r line; do
            if [[ $format_specific == 1 ]]; then
                discard=0
            elif [[ $line == "Format specific information:" ]]; then
                discard=1
            elif [[ $line =~ $regex_json_spec_start ]]; then
                discard=2
                regex_json_spec_end="^${line%%[^ ]*}\\},? *$"
            fi
            if [[ $discard == 0 ]]; then
                echo "$line"
            elif [[ $discard == 1 && ! $line ]]; then
                echo
                discard=0
            elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
                discard=0
            fi
        done
}

# bail out, setting up .notrun file
#
_notrun()
{
    echo "$*" >"$OUTPUT_DIR/$seq.notrun"
    echo "$seq not run: $*"
    status=0
    exit
}

# bail out, setting up .casenotrun file
# The function _casenotrun() is used as a notifier. It is the
# caller's responsibility to make skipped a particular test.
#
_casenotrun()
{
    echo "    [case not run] $*" >>"$OUTPUT_DIR/$seq.casenotrun"
}

# just plain bail out
#
_fail()
{
    echo "$*" | tee -a "$OUTPUT_DIR/$seq.full"
    echo "(see $seq.full for details)"
    status=1
    exit 1
}

# tests whether $IMGFMT is one of the supported image formats for a test
#
_supported_fmt()
{
    # "generic" is suitable for most image formats. For some formats it doesn't
    # work, however (most notably read-only formats), so they can opt out by
    # setting IMGFMT_GENERIC to false.
    for f; do
        if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then
            return
        fi
    done

    _notrun "not suitable for this image format: $IMGFMT"
}

# tests whether $IMGFMT is one of the unsupported image format for a test
#
_unsupported_fmt()
{
    for f; do
        if [ "$f" = "$IMGFMT" ]; then
            _notrun "not suitable for this image format: $IMGFMT"
        fi
    done
}

# tests whether $IMGPROTO is one of the supported image protocols for a test
#
_supported_proto()
{
    for f; do
        if [ "$f" = "$IMGPROTO" -o "$f" = "generic" ]; then
            return
        fi
    done

    _notrun "not suitable for this image protocol: $IMGPROTO"
}

# tests whether $IMGPROTO is specified as an unsupported image protocol for a test
#
_unsupported_proto()
{
    for f; do
        if [ "$f" = "$IMGPROTO" ]; then
            _notrun "not suitable for this image protocol: $IMGPROTO"
            return
        fi
    done
}

# tests whether the host OS is one of the supported OSes for a test
#
_supported_os()
{
    for h
    do
        if [ "$h" = "$HOSTOS" ]
        then
            return
        fi
    done

    _notrun "not suitable for this OS: $HOSTOS"
}

_supported_cache_modes()
{
    for mode; do
        if [ "$mode" = "$CACHEMODE" ]; then
            return
        fi
    done
    _notrun "not suitable for cache mode: $CACHEMODE"
}

_default_cache_mode()
{
    if $CACHEMODE_IS_DEFAULT; then
        CACHEMODE="$1"
        QEMU_IO="$QEMU_IO --cache $1"
        return
    fi
}
_supported_aio_modes()
{
    for mode; do
        if [ "$mode" = "$AIOMODE" ]; then
            return
        fi
    done
    _notrun "not suitable for aio mode: $AIOMODE"
}
_default_aio_mode()
{
    AIOMODE="$1"
    QEMU_IO="$QEMU_IO --aio $1"
}

_unsupported_imgopts()
{
    for bad_opt
    do
        if echo "$IMGOPTS" | grep -q 2>/dev/null "$bad_opt"
        then
            _notrun "not suitable for image option: $bad_opt"
        fi
    done
}

# this test requires that a specified command (executable) exists
#
_require_command()
{
    if [ "$1" = "QEMU" ]; then
        c=$QEMU_PROG
    elif [ "$1" = "QEMU_IMG" ]; then
        c=$QEMU_IMG_PROG
    elif [ "$1" = "QEMU_IO" ]; then
        c=$QEMU_IO_PROG
    elif [ "$1" = "QEMU_NBD" ]; then
        c=$QEMU_NBD_PROG
    else
        eval c=\$$1
    fi
    [ -x "$c" ] || _notrun "$1 utility required, skipped this test"
}

# Check that a set of drivers has been whitelisted in the QEMU binary
#
_require_drivers()
{
    available=$($QEMU -drive format=help | \
                sed -e '/Supported formats:/!d' -e 's/Supported formats://')
    for driver
    do
        if ! echo "$available" | grep -q " $driver\( \|$\)"; then
            _notrun "$driver not available"
        fi
    done
}

# Check that we have a file system that allows huge (but very sparse) files
#
_require_large_file()
{
    if ! truncate --size="$1" "$TEST_IMG"; then
        _notrun "file system on $TEST_DIR does not support large enough files"
    fi
    rm "$TEST_IMG"
}

# make sure this script returns success
true
Commit	Line	Data
11a82d14	1	#!/usr/bin/env bash
6bf19c94 CH	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
e8c212d6	17	# along with this program. If not, see <http://www.gnu.org/licenses/>.
6bf19c94 CH	18	#
6bf19c94 CH	19
bde36af1 PMD	20	SED=
	21	for 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
	27	done
	28	if [ -z "$SED" ]; then
	29	echo "$0: GNU sed not found"
	30	exit 1
	31	fi
	32
6bf19c94 CH	33	dd()
	34	{
	35	if [ "$HOSTOS" == "Linux" ]
79e40ab1 KW	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
6bf19c94	45	else
79e40ab1	46	command dd $@
6bf19c94 CH	47	fi
	48	}
	49
23ea2ecc SH	50	# poke_file 'test.img' 512 '\xff\xfe'
	51	poke_file()
	52	{
	53	printf "$3" \| dd "of=$1" bs=1 "seek=$2" conv=notrunc &>/dev/null
	54	}
	55
fc8ba423 HR	56	# peek_file_le 'test.img' 512 2 => 65534
	57	peek_file_le()
	58	{
	59	# Wrap in echo $() to strip spaces
	60	echo $(od -j"$2" -N"$3" --endian=little -An -vtu"$3" "$1")
	61	}
	62
	63	# peek_file_be 'test.img' 512 2 => 65279
	64	peek_file_be()
	65	{
	66	# Wrap in echo $() to strip spaces
	67	echo $(od -j"$2" -N"$3" --endian=big -An -vtu"$3" "$1")
	68	}
	69
	70	# peek_file_raw 'test.img' 512 2 => '\xff\xfe'
	71	peek_file_raw()
	72	{
	73	dd if="$1" bs=1 skip="$2" count="$3" status=none
	74	}
	75
3817ce03 PB	76
	77	if ! . ./common.config
	78	then
4e670492	79	echo "$0: failed to source common.config"
3817ce03	80	exit 1
6bf19c94 CH	81	fi
6bf19c94 CH	82
036d8cbf AS	83	# Set the variables to the empty string to turn Valgrind off
	84	# for specific processes, e.g.
	85	# $ VALGRIND_QEMU_IO= ./check -qcow2 -valgrind 015
	86
	87	: ${VALGRIND_QEMU_VM=$VALGRIND_QEMU}
	88	: ${VALGRIND_QEMU_IMG=$VALGRIND_QEMU}
	89	: ${VALGRIND_QEMU_IO=$VALGRIND_QEMU}
	90	: ${VALGRIND_QEMU_NBD=$VALGRIND_QEMU}
	91	: ${VALGRIND_QEMU_VXHS=$VALGRIND_QEMU}
	92
	93	# The Valgrind own parameters may be set with
	94	# its environment variable VALGRIND_OPTS, e.g.
	95	# $ VALGRIND_OPTS="--leak-check=yes" ./check -qcow2 -valgrind 015
	96
	97	_qemu_proc_exec()
	98	{
	99	local VALGRIND_LOGFILE="$1"
	100	shift
8af224d6	101	if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then
036d8cbf AS	102	exec valgrind --log-file="${VALGRIND_LOGFILE}" --error-exitcode=99 "$@"
	103	else
	104	exec "$@"
	105	fi
	106	}
	107
	108	_qemu_proc_valgrind_log()
	109	{
	110	local VALGRIND_LOGFILE="$1"
	111	local RETVAL="$2"
8af224d6	112	if [[ "${VALGRIND_QEMU}" == "y" && "${NO_VALGRIND}" != "y" ]]; then
036d8cbf AS	113	if [ $RETVAL == 99 ]; then
	114	cat "${VALGRIND_LOGFILE}"
	115	fi
	116	rm -f "${VALGRIND_LOGFILE}"
	117	fi
	118	}
	119
d1f2447a PB	120	_qemu_wrapper()
d1f2447a PB	121	{
036d8cbf	122	local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
d1f2447a PB	123	(
	124	if [ -n "${QEMU_NEED_PID}" ]; then
	125	echo $BASHPID > "${QEMU_TEST_DIR}/qemu-${_QEMU_HANDLE}.pid"
	126	fi
036d8cbf AS	127	VALGRIND_QEMU="${VALGRIND_QEMU_VM}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
036d8cbf AS	128	"$QEMU_PROG" $QEMU_OPTIONS "$@"
d1f2447a	129	)
036d8cbf AS	130	RETVAL=$?
	131	_qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
	132	return $RETVAL
d1f2447a PB	133	}
	134
	135	_qemu_img_wrapper()
	136	{
036d8cbf AS	137	local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
	138	(
	139	VALGRIND_QEMU="${VALGRIND_QEMU_IMG}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
	140	"$QEMU_IMG_PROG" $QEMU_IMG_OPTIONS "$@"
	141	)
	142	RETVAL=$?
	143	_qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
	144	return $RETVAL
d1f2447a PB	145	}
	146
	147	_qemu_io_wrapper()
	148	{
	149	local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
	150	local QEMU_IO_ARGS="$QEMU_IO_OPTIONS"
	151	if [ "$IMGOPTSSYNTAX" = "true" ]; then
	152	QEMU_IO_ARGS="--image-opts $QEMU_IO_ARGS"
	153	if [ -n "$IMGKEYSECRET" ]; then
	154	QEMU_IO_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IO_ARGS"
	155	fi
	156	fi
d1f2447a	157	(
036d8cbf AS	158	VALGRIND_QEMU="${VALGRIND_QEMU_IO}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
036d8cbf AS	159	"$QEMU_IO_PROG" $QEMU_IO_ARGS "$@"
d1f2447a PB	160	)
d1f2447a PB	161	RETVAL=$?
036d8cbf AS	162	_qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
036d8cbf AS	163	return $RETVAL
d1f2447a PB	164	}
	165
	166	_qemu_nbd_wrapper()
	167	{
036d8cbf AS	168	local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
	169	(
	170	VALGRIND_QEMU="${VALGRIND_QEMU_NBD}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
	171	"$QEMU_NBD_PROG" --pid-file="${QEMU_TEST_DIR}/qemu-nbd.pid" \
	172	$QEMU_NBD_OPTIONS "$@"
	173	)
	174	RETVAL=$?
	175	_qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
	176	return $RETVAL
d1f2447a PB	177	}
	178
	179	_qemu_vxhs_wrapper()
	180	{
036d8cbf	181	local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
d1f2447a PB	182	(
d1f2447a PB	183	echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
036d8cbf AS	184	VALGRIND_QEMU="${VALGRIND_QEMU_VXHS}" _qemu_proc_exec "${VALGRIND_LOGFILE}" \
036d8cbf AS	185	"$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
d1f2447a	186	)
036d8cbf AS	187	RETVAL=$?
	188	_qemu_proc_valgrind_log "${VALGRIND_LOGFILE}" $RETVAL
	189	return $RETVAL
d1f2447a PB	190	}
d1f2447a PB	191
8af224d6 AS	192	# Valgrind bug #409141 https://bugs.kde.org/show_bug.cgi?id=409141
	193	# Until valgrind 3.16+ is ubiquitous, we must work around a hang in
	194	# valgrind when issuing sigkill. Disable valgrind for this invocation.
	195	_NO_VALGRIND()
	196	{
	197	NO_VALGRIND="y" "$@"
	198	}
	199
d1f2447a PB	200	export QEMU=_qemu_wrapper
	201	export QEMU_IMG=_qemu_img_wrapper
	202	export QEMU_IO=_qemu_io_wrapper
	203	export QEMU_NBD=_qemu_nbd_wrapper
	204	export QEMU_VXHS=_qemu_vxhs_wrapper
	205
076003f5 DB	206	if [ "$IMGOPTSSYNTAX" = "true" ]; then
076003f5 DB	207	DRIVER="driver=$IMGFMT"
cce293a2 PB	208	QEMU_IMG_EXTRA_ARGS="--image-opts $QEMU_IMG_EXTRA_ARGS"
	209	if [ -n "$IMGKEYSECRET" ]; then
	210	QEMU_IMG_EXTRA_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IMG_EXTRA_ARGS"
	211	fi
4e9b25fb DB	212	if [ "$IMGFMT" = "luks" ]; then
	213	DRIVER="$DRIVER,key-secret=keysec0"
	214	fi
076003f5 DB	215	if [ "$IMGPROTO" = "file" ]; then
	216	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	217	TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT"
	218	elif [ "$IMGPROTO" = "nbd" ]; then
	219	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
eb4ea9aa HR	220	TEST_IMG="$DRIVER,file.driver=nbd,file.type=unix"
eb4ea9aa HR	221	TEST_IMG="$TEST_IMG,file.path=$SOCK_DIR/nbd"
076003f5 DB	222	elif [ "$IMGPROTO" = "ssh" ]; then
	223	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	224	TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE"
	225	elif [ "$IMGPROTO" = "nfs" ]; then
	226	TEST_DIR="$DRIVER,file.driver=nfs,file.filename=nfs://127.0.0.1/$TEST_DIR"
e5b77eec	227	TEST_IMG=$TEST_DIR/t.$IMGFMT
076003f5 DB	228	else
	229	TEST_IMG="$DRIVER,file.driver=$IMGPROTO,file.filename=$TEST_DIR/t.$IMGFMT"
	230	fi
9cdfa1b3	231	else
cce293a2	232	QEMU_IMG_EXTRA_ARGS=
076003f5 DB	233	if [ "$IMGPROTO" = "file" ]; then
	234	TEST_IMG=$TEST_DIR/t.$IMGFMT
	235	elif [ "$IMGPROTO" = "nbd" ]; then
	236	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
f3923a72	237	TEST_IMG="nbd+unix:///?socket=$SOCK_DIR/nbd"
076003f5 DB	238	elif [ "$IMGPROTO" = "ssh" ]; then
076003f5 DB	239	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
b8c1f901	240	REMOTE_TEST_DIR="ssh://\\($USER@\\)\\?127.0.0.1\\(:[0-9]\\+\\)\\?$TEST_DIR"
076003f5 DB	241	TEST_IMG="ssh://127.0.0.1$TEST_IMG_FILE"
076003f5 DB	242	elif [ "$IMGPROTO" = "nfs" ]; then
655ae6bb	243	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
8908b253	244	REMOTE_TEST_DIR="nfs://127.0.0.1$TEST_DIR"
655ae6bb	245	TEST_IMG="nfs://127.0.0.1$TEST_IMG_FILE"
ae0c0a3d AM	246	elif [ "$IMGPROTO" = "vxhs" ]; then
	247	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	248	TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
076003f5 DB	249	else
	250	TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
	251	fi
9cdfa1b3	252	fi
59fa68f3	253	ORIG_TEST_IMG="$TEST_IMG"
6bf19c94	254
cce293a2	255	if [ -z "$TEST_DIR" ]; then
e8d81a61	256	TEST_DIR=$PWD/scratch
cce293a2 PB	257	fi
	258
	259	QEMU_TEST_DIR="${TEST_DIR}"
	260
	261	if [ ! -e "$TEST_DIR" ]; then
	262	mkdir "$TEST_DIR"
	263	fi
	264
	265	if [ ! -d "$TEST_DIR" ]; then
49cedf17	266	echo "common.rc: Error: \$TEST_DIR ($TEST_DIR) is not a directory"
cce293a2 PB	267	exit 1
	268	fi
	269
8908b253 KW	270	if [ -z "$REMOTE_TEST_DIR" ]; then
	271	REMOTE_TEST_DIR="$TEST_DIR"
	272	fi
	273
cce293a2	274	if [ ! -d "$SAMPLE_IMG_DIR" ]; then
49cedf17	275	echo "common.rc: Error: \$SAMPLE_IMG_DIR ($SAMPLE_IMG_DIR) is not a directory"
cce293a2 PB	276	exit 1
	277	fi
	278
85edbd37 JC	279	_use_sample_img()
	280	{
	281	SAMPLE_IMG_FILE="${1%\.bz2}"
	282	TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE"
	283	bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG"
	284	if [ $? -ne 0 ]
	285	then
	286	echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'"
	287	exit 1
	288	fi
	289	}
	290
2f9d4083 FZ	291	_stop_nbd_server()
	292	{
	293	if [ -f "${QEMU_TEST_DIR}/qemu-nbd.pid" ]; then
	294	local QEMU_NBD_PID
	295	read QEMU_NBD_PID < "${QEMU_TEST_DIR}/qemu-nbd.pid"
	296	kill ${QEMU_NBD_PID}
f3923a72	297	rm -f "${QEMU_TEST_DIR}/qemu-nbd.pid" "$SOCK_DIR/nbd"
2f9d4083 FZ	298	fi
	299	}
	300
1b35b85a HR	301	# Gets the data_file value from IMGOPTS and replaces the '$TEST_IMG'
	302	# pattern by '$1'
	303	# Caution: The replacement is done with sed, so $1 must be escaped
	304	# properly. (The delimiter is '#'.)
	305	_get_data_file()
	306	{
	307	if ! echo "$IMGOPTS" \| grep -q 'data_file='; then
	308	return 1
	309	fi
	310
	311	echo "$IMGOPTS" \| sed -e 's/.data_file=\([^,]\).*/\1/' \
	312	\| sed -e "s#\\\$TEST_IMG#$1#"
	313	}
	314
6bf19c94 CH	315	_make_test_img()
	316	{
	317	# extra qemu-img options can be added by tests
	318	# at least one argument (the image size) needs to be added
21af8148	319	local extra_img_options=""
89004368	320	local optstr=""
a9660664	321	local img_name=""
0018c03f JC	322	local use_backing=0
0018c03f JC	323	local backing_file=""
b7e875b2	324	local object_options=""
8b6d7be6	325	local opts_param=false
eea871d0	326	local misc_params=()
a9660664 NT	327
	328	if [ -n "$TEST_IMG_FILE" ]; then
	329	img_name=$TEST_IMG_FILE
	330	else
	331	img_name=$TEST_IMG
	332	fi
89004368 KW	333
89004368 KW	334	if [ -n "$IMGOPTS" ]; then
1b35b85a HR	335	imgopts_expanded=$(echo "$IMGOPTS" \| sed -e "s#\\\$TEST_IMG#$img_name#")
1b35b85a HR	336	optstr=$(_optstr_add "$optstr" "$imgopts_expanded")
89004368	337	fi
b7e875b2 DB	338	if [ -n "$IMGKEYSECRET" ]; then
	339	object_options="--object secret,id=keysec0,data=$IMGKEYSECRET"
	340	optstr=$(_optstr_add "$optstr" "key-secret=keysec0")
	341	fi
6bf19c94	342
eea871d0 HR	343	for param; do
	344	if [ "$use_backing" = "1" -a -z "$backing_file" ]; then
	345	backing_file=$param
	346	continue
8b6d7be6 HR	347	elif $opts_param; then
	348	optstr=$(_optstr_add "$optstr" "$param")
	349	opts_param=false
	350	continue
eea871d0 HR	351	fi
	352
	353	case "$param" in
	354	-b)
	355	use_backing=1
	356	;;
	357
8b6d7be6 HR	358	-o)
	359	opts_param=true
	360	;;
	361
	362	--no-opts)
	363	optstr=""
	364	;;
	365
eea871d0 HR	366	*)
	367	misc_params=("${misc_params[@]}" "$param")
	368	;;
	369	esac
	370	done
	371
f5a4bbd9	372	if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then
89004368 KW	373	optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE")
	374	fi
	375
	376	if [ -n "$optstr" ]; then
	377	extra_img_options="-o $optstr $extra_img_options"
8fc1024c KW	378	fi
8fc1024c KW	379
2f9d4083 FZ	380	if [ $IMGPROTO = "nbd" ]; then
	381	_stop_nbd_server
	382	fi
	383
6bf19c94	384	# XXX(hch): have global image options?
0018c03f JC	385	(
0018c03f JC	386	if [ $use_backing = 1 ]; then
eea871d0	387	$QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" "${misc_params[@]}" 2>&1
0018c03f	388	else
eea871d0	389	$QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" "${misc_params[@]}" 2>&1
0018c03f	390	fi
6ffb4cb6	391	) \| _filter_img_create
a9660664	392
f3923a72 EB	393	# Start an NBD server on the image file, which is what we'll be talking to.
	394	# Once NBD gains resize support, we may also want to use -f raw at the
	395	# server and interpret format over NBD, but for now, the format is
	396	# interpreted at the server and raw data sent over NBD.
a9660664	397	if [ $IMGPROTO = "nbd" ]; then
03a0aa37 HR	398	# Pass a sufficiently high number to -e that should be enough for all
03a0aa37 HR	399	# tests
f3923a72	400	eval "$QEMU_NBD -v -t -k '$SOCK_DIR/nbd' -f $IMGFMT -e 42 -x '' $TEST_IMG_FILE >/dev/null &"
a9660664 NT	401	sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
a9660664 NT	402	fi
ae0c0a3d AM	403
	404	# Start QNIO server on image directory for vxhs protocol
	405	if [ $IMGPROTO = "vxhs" ]; then
	406	eval "$QEMU_VXHS -d $TEST_DIR > /dev/null &"
	407	sleep 1 # Wait for server to come up.
	408	fi
6bf19c94 CH	409	}
6bf19c94 CH	410
487c1910 FZ	411	_rm_test_img()
	412	{
	413	local img=$1
	414	if [ "$IMGFMT" = "vmdk" ]; then
	415	# Remove all the extents for vmdk
c5575274	416	"$QEMU_IMG" info "$img" 2>/dev/null \| grep 'filename:' \| cut -f 2 -d: \
487c1910	417	\| xargs -I {} rm -f "{}"
1b35b85a HR	418	elif [ "$IMGFMT" = "qcow2" ]; then
	419	# Remove external data file
	420	if data_file=$(_get_data_file "$img"); then
	421	rm -f "$data_file"
	422	fi
487c1910	423	fi
c5575274	424	rm -f "$img"
487c1910 FZ	425	}
487c1910 FZ	426
6bf19c94 CH	427	_cleanup_test_img()
6bf19c94 CH	428	{
9cdfa1b3 MK	429	case "$IMGPROTO" in
9cdfa1b3 MK	430
a9660664	431	nbd)
2f9d4083	432	_stop_nbd_server
fef9c191	433	rm -f "$TEST_IMG_FILE"
a9660664	434	;;
ae0c0a3d AM	435	vxhs)
	436	if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
	437	local QEMU_VXHS_PID
	438	read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
	439	kill ${QEMU_VXHS_PID} >/dev/null 2>&1
	440	rm -f "${TEST_DIR}/qemu-vxhs.pid"
	441	fi
	442	rm -f "$TEST_IMG_FILE"
	443	;;
	444
9cdfa1b3	445	file)
487c1910 FZ	446	_rm_test_img "$TEST_DIR/t.$IMGFMT"
	447	_rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
	448	_rm_test_img "$TEST_DIR/t.$IMGFMT.base"
85edbd37 JC	449	if [ -n "$SAMPLE_IMG_FILE" ]
	450	then
	451	rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
59fa68f3 KW	452	SAMPLE_IMG_FILE=
59fa68f3 KW	453	TEST_IMG="$ORIG_TEST_IMG"
85edbd37	454	fi
9cdfa1b3 MK	455	;;
	456
	457	rbd)
9147d019	458	rbd --no-progress rm "$TEST_DIR/t.$IMGFMT" > /dev/null
9cdfa1b3 MK	459	;;
	460
	461	sheepdog)
fef9c191	462	collie vdi delete "$TEST_DIR/t.$IMGFMT"
9cdfa1b3 MK	463	;;
	464
	465	esac
6bf19c94 CH	466	}
	467
	468	_check_test_img()
	469	{
076003f5 DB	470	(
	471	if [ "$IMGOPTSSYNTAX" = "true" ]; then
	472	$QEMU_IMG check $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1
	473	else
	474	$QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1
	475	fi
86ce1f6e	476	) \| _filter_testdir \| _filter_qemu_img_check
ee1e66d9 VSO	477
	478	# return real qemu_img check status, to analyze in
	479	# _check_test_img_ignore_leaks
	480	return ${PIPESTATUS[0]}
	481	}
	482
	483	_check_test_img_ignore_leaks()
	484	{
	485	out=$(_check_test_img "$@")
	486	status=$?
	487	if [ $status = 3 ]; then
	488	# This must correspond to success output in dump_human_image_check()
	489	echo "No errors were found on the image."
	490	return 0
	491	fi
	492	echo "$out"
	493	return $status
6bf19c94 CH	494	}
6bf19c94 CH	495
514d9da5 SH	496	_img_info()
514d9da5 SH	497	{
e800e5d4 KW	498	if [[ "$1" == "--format-specific" ]]; then
	499	local format_specific=1
	500	shift
	501	else
	502	local format_specific=0
	503	fi
	504
4c2e9465 HR	505	discard=0
4c2e9465 HR	506	regex_json_spec_start='^ *"format-specific": \{'
d06195e6	507	$QEMU_IMG info $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 \| \
8908b253 KW	508	sed -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \
8908b253 KW	509	-e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
514d9da5 SH	510	-e "s#$TEST_DIR#TEST_DIR#g" \
	511	-e "s#$IMGFMT#IMGFMT#g" \
	512	-e "/^disk size:/ D" \
4c2e9465	513	-e "/actual-size/ D" \| \
6dd6d7ab	514	while IFS='' read -r line; do
e800e5d4 KW	515	if [[ $format_specific == 1 ]]; then
	516	discard=0
	517	elif [[ $line == "Format specific information:" ]]; then
4c2e9465 HR	518	discard=1
	519	elif [[ $line =~ $regex_json_spec_start ]]; then
	520	discard=2
	521	regex_json_spec_end="^${line%%[^ ]}\\},? $"
	522	fi
	523	if [[ $discard == 0 ]]; then
	524	echo "$line"
	525	elif [[ $discard == 1 && ! $line ]]; then
	526	echo
	527	discard=0
	528	elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
	529	discard=0
	530	fi
	531	done
514d9da5 SH	532	}
514d9da5 SH	533
6bf19c94 CH	534	# bail out, setting up .notrun file
	535	#
	536	_notrun()
	537	{
e8f8624d	538	echo "$*" >"$OUTPUT_DIR/$seq.notrun"
6bf19c94 CH	539	echo "$seq not run: $*"
	540	status=0
	541	exit
	542	}
	543
5ff1c2c8 AS	544	# bail out, setting up .casenotrun file
	545	# The function _casenotrun() is used as a notifier. It is the
	546	# caller's responsibility to make skipped a particular test.
	547	#
	548	_casenotrun()
	549	{
	550	echo " [case not run] $*" >>"$OUTPUT_DIR/$seq.casenotrun"
	551	}
	552
6bf19c94 CH	553	# just plain bail out
	554	#
	555	_fail()
	556	{
e8f8624d	557	echo "$*" \| tee -a "$OUTPUT_DIR/$seq.full"
6bf19c94 CH	558	echo "(see $seq.full for details)"
	559	status=1
	560	exit 1
	561	}
	562
	563	# tests whether $IMGFMT is one of the supported image formats for a test
	564	#
	565	_supported_fmt()
	566	{
47f73da0 SH	567	# "generic" is suitable for most image formats. For some formats it doesn't
	568	# work, however (most notably read-only formats), so they can opt out by
	569	# setting IMGFMT_GENERIC to false.
6bf19c94	570	for f; do
89e91181	571	if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then
79e40ab1 KW	572	return
79e40ab1 KW	573	fi
6bf19c94 CH	574	done
	575
	576	_notrun "not suitable for this image format: $IMGFMT"
	577	}
	578
b4a2caa4 NS	579	# tests whether $IMGFMT is one of the unsupported image format for a test
	580	#
	581	_unsupported_fmt()
	582	{
	583	for f; do
	584	if [ "$f" = "$IMGFMT" ]; then
	585	_notrun "not suitable for this image format: $IMGFMT"
	586	fi
	587	done
	588	}
	589
9cdfa1b3 MK	590	# tests whether $IMGPROTO is one of the supported image protocols for a test
	591	#
	592	_supported_proto()
	593	{
	594	for f; do
79e40ab1 KW	595	if [ "$f" = "$IMGPROTO" -o "$f" = "generic" ]; then
	596	return
	597	fi
9cdfa1b3 MK	598	done
	599
	600	_notrun "not suitable for this image protocol: $IMGPROTO"
	601	}
	602
dfac03dc JC	603	# tests whether $IMGPROTO is specified as an unsupported image protocol for a test
	604	#
	605	_unsupported_proto()
	606	{
	607	for f; do
	608	if [ "$f" = "$IMGPROTO" ]; then
	609	_notrun "not suitable for this image protocol: $IMGPROTO"
	610	return
	611	fi
	612	done
	613	}
	614
6bf19c94 CH	615	# tests whether the host OS is one of the supported OSes for a test
	616	#
	617	_supported_os()
	618	{
	619	for h
	620	do
79e40ab1 KW	621	if [ "$h" = "$HOSTOS" ]
	622	then
	623	return
	624	fi
6bf19c94 CH	625	done
	626
	627	_notrun "not suitable for this OS: $HOSTOS"
	628	}
	629
f210a83c	630	_supported_cache_modes()
166f3c7b	631	{
f210a83c FZ	632	for mode; do
	633	if [ "$mode" = "$CACHEMODE" ]; then
	634	return
	635	fi
166f3c7b	636	done
f210a83c FZ	637	_notrun "not suitable for cache mode: $CACHEMODE"
	638	}
	639
	640	_default_cache_mode()
	641	{
	642	if $CACHEMODE_IS_DEFAULT; then
	643	CACHEMODE="$1"
	644	QEMU_IO="$QEMU_IO --cache $1"
	645	return
	646	fi
166f3c7b	647	}
7156ca48 AM	648	_supported_aio_modes()
	649	{
	650	for mode; do
	651	if [ "$mode" = "$AIOMODE" ]; then
	652	return
	653	fi
	654	done
	655	_notrun "not suitable for aio mode: $AIOMODE"
	656	}
	657	_default_aio_mode()
	658	{
	659	AIOMODE="$1"
	660	QEMU_IO="$QEMU_IO --aio $1"
	661	}
166f3c7b	662
2c77f52e FZ	663	_unsupported_imgopts()
	664	{
	665	for bad_opt
	666	do
	667	if echo "$IMGOPTS" \| grep -q 2>/dev/null "$bad_opt"
	668	then
	669	_notrun "not suitable for image option: $bad_opt"
	670	fi
	671	done
	672	}
	673
6bf19c94 CH	674	# this test requires that a specified command (executable) exists
	675	#
	676	_require_command()
	677	{
934659c4 HR	678	if [ "$1" = "QEMU" ]; then
	679	c=$QEMU_PROG
	680	elif [ "$1" = "QEMU_IMG" ]; then
	681	c=$QEMU_IMG_PROG
	682	elif [ "$1" = "QEMU_IO" ]; then
	683	c=$QEMU_IO_PROG
	684	elif [ "$1" = "QEMU_NBD" ]; then
	685	c=$QEMU_NBD_PROG
	686	else
	687	eval c=\$$1
	688	fi
9c468a01	689	[ -x "$c" ] \|\| _notrun "$1 utility required, skipped this test"
6bf19c94 CH	690	}
6bf19c94 CH	691
21b43d00 TH	692	# Check that a set of drivers has been whitelisted in the QEMU binary
	693	#
	694	_require_drivers()
	695	{
	696	available=$($QEMU -drive format=help \| \
	697	sed -e '/Supported formats:/!d' -e 's/Supported formats://')
	698	for driver
	699	do
	700	if ! echo "$available" \| grep -q " $driver\( \\|$\)"; then
	701	_notrun "$driver not available"
	702	fi
	703	done
	704	}
	705
059f708d TH	706	# Check that we have a file system that allows huge (but very sparse) files
	707	#
	708	_require_large_file()
	709	{
	710	if ! truncate --size="$1" "$TEST_IMG"; then
	711	_notrun "file system on $TEST_DIR does not support large enough files"
	712	fi
	713	rm "$TEST_IMG"
	714	}
	715
6bf19c94	716	# make sure this script returns success
a2d9c0c4	717	true