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

#!/bin/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/>.
#

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
}


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

_qemu_wrapper()
{
    (
        if [ -n "${QEMU_NEED_PID}" ]; then
            echo $BASHPID > "${QEMU_TEST_DIR}/qemu-${_QEMU_HANDLE}.pid"
        fi
        exec "$QEMU_PROG" $QEMU_OPTIONS "$@"
    )
}

_qemu_img_wrapper()
{
    (exec "$QEMU_IMG_PROG" $QEMU_IMG_OPTIONS "$@")
}

_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
    local RETVAL
    (
        if [ "${VALGRIND_QEMU}" == "y" ]; then
            exec valgrind --log-file="${VALGRIND_LOGFILE}" --error-exitcode=99 "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@"
        else
            exec "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@"
        fi
    )
    RETVAL=$?
    if [ "${VALGRIND_QEMU}" == "y" ]; then
        if [ $RETVAL == 99 ]; then
            cat "${VALGRIND_LOGFILE}"
        fi
        rm -f "${VALGRIND_LOGFILE}"
    fi
    (exit $RETVAL)
}

_qemu_nbd_wrapper()
{
    (
        echo $BASHPID > "${QEMU_TEST_DIR}/qemu-nbd.pid"
        exec "$QEMU_NBD_PROG" $QEMU_NBD_OPTIONS "$@"
    )
}

_qemu_vxhs_wrapper()
{
    (
        echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
        exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
    )
}

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.host=127.0.0.1,file.port=10810"
    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:127.0.0.1:10810"
    elif [ "$IMGPROTO" = "ssh" ]; then
        TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
        TEST_IMG="ssh://127.0.0.1$TEST_IMG_FILE"
    elif [ "$IMGPROTO" = "nfs" ]; then
        TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
        TEST_IMG=$TEST_DIR/t.$IMGFMT
    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.config: Error: \$TEST_DIR ($TEST_DIR) is not a directory"
    exit 1
fi

if [ ! -d "$SAMPLE_IMG_DIR" ]; then
    echo "common.config: 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
}

_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 image_size=$*
    local optstr=""
    local img_name=""
    local use_backing=0
    local backing_file=""
    local object_options=""

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

    if [ -n "$IMGOPTS" ]; then
        optstr=$(_optstr_add "$optstr" "$IMGOPTS")
    fi
    if [ -n "$IMGKEYSECRET" ]; then
        object_options="--object secret,id=keysec0,data=$IMGKEYSECRET"
        optstr=$(_optstr_add "$optstr" "key-secret=keysec0")
    fi

    if [ "$1" = "-b" ]; then
        use_backing=1
        backing_file=$2
        image_size=$3
    fi
    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

    # 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" $image_size 2>&1
     else
        $QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1
     fi
    ) | _filter_img_create

    # Start an NBD server on the image file, which is what we'll be talking to
    if [ $IMGPROTO = "nbd" ]; then
        # Pass a sufficiently high number to -e that should be enough for all
        # tests
        eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT -e 42  $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 "{}"
    fi
    rm -f "$img"
}

_cleanup_test_img()
{
    case "$IMGPROTO" in

        nbd)
            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"
            fi
            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
}

_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 "$@" "$TEST_IMG" 2>&1 | \
        sed -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 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
}

# 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
}

_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"
}

# make sure this script returns success
true
Commit	Line	Data
908eaf68	1	#!/bin/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	#
	19
	20	dd()
	21	{
	22	if [ "$HOSTOS" == "Linux" ]
79e40ab1 KW	23	then
	24	command dd --help \| grep noxfer > /dev/null 2>&1
	25
	26	if [ "$?" -eq 0 ]
	27	then
	28	command dd status=noxfer $@
	29	else
	30	command dd $@
	31	fi
6bf19c94	32	else
79e40ab1	33	command dd $@
6bf19c94 CH	34	fi
	35	}
	36
23ea2ecc SH	37	# poke_file 'test.img' 512 '\xff\xfe'
	38	poke_file()
	39	{
	40	printf "$3" \| dd "of=$1" bs=1 "seek=$2" conv=notrunc &>/dev/null
	41	}
	42
3817ce03 PB	43
	44	if ! . ./common.config
	45	then
	46	echo "$iam: failed to source common.config"
	47	exit 1
6bf19c94 CH	48	fi
6bf19c94 CH	49
d1f2447a PB	50	_qemu_wrapper()
	51	{
	52	(
	53	if [ -n "${QEMU_NEED_PID}" ]; then
	54	echo $BASHPID > "${QEMU_TEST_DIR}/qemu-${_QEMU_HANDLE}.pid"
	55	fi
	56	exec "$QEMU_PROG" $QEMU_OPTIONS "$@"
	57	)
	58	}
	59
	60	_qemu_img_wrapper()
	61	{
	62	(exec "$QEMU_IMG_PROG" $QEMU_IMG_OPTIONS "$@")
	63	}
	64
	65	_qemu_io_wrapper()
	66	{
	67	local VALGRIND_LOGFILE="${TEST_DIR}"/$$.valgrind
	68	local QEMU_IO_ARGS="$QEMU_IO_OPTIONS"
	69	if [ "$IMGOPTSSYNTAX" = "true" ]; then
	70	QEMU_IO_ARGS="--image-opts $QEMU_IO_ARGS"
	71	if [ -n "$IMGKEYSECRET" ]; then
	72	QEMU_IO_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IO_ARGS"
	73	fi
	74	fi
	75	local RETVAL
	76	(
	77	if [ "${VALGRIND_QEMU}" == "y" ]; then
	78	exec valgrind --log-file="${VALGRIND_LOGFILE}" --error-exitcode=99 "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@"
	79	else
	80	exec "$QEMU_IO_PROG" $QEMU_IO_ARGS "$@"
	81	fi
	82	)
	83	RETVAL=$?
	84	if [ "${VALGRIND_QEMU}" == "y" ]; then
	85	if [ $RETVAL == 99 ]; then
	86	cat "${VALGRIND_LOGFILE}"
	87	fi
	88	rm -f "${VALGRIND_LOGFILE}"
	89	fi
	90	(exit $RETVAL)
	91	}
	92
	93	_qemu_nbd_wrapper()
	94	{
	95	(
	96	echo $BASHPID > "${QEMU_TEST_DIR}/qemu-nbd.pid"
	97	exec "$QEMU_NBD_PROG" $QEMU_NBD_OPTIONS "$@"
	98	)
	99	}
	100
	101	_qemu_vxhs_wrapper()
	102	{
	103	(
	104	echo $BASHPID > "${TEST_DIR}/qemu-vxhs.pid"
	105	exec "$QEMU_VXHS_PROG" $QEMU_VXHS_OPTIONS "$@"
	106	)
	107	}
	108
	109	export QEMU=_qemu_wrapper
	110	export QEMU_IMG=_qemu_img_wrapper
	111	export QEMU_IO=_qemu_io_wrapper
	112	export QEMU_NBD=_qemu_nbd_wrapper
	113	export QEMU_VXHS=_qemu_vxhs_wrapper
114
076003f5 DB	115	if [ "$IMGOPTSSYNTAX" = "true" ]; then
076003f5 DB	116	DRIVER="driver=$IMGFMT"
cce293a2 PB	117	QEMU_IMG_EXTRA_ARGS="--image-opts $QEMU_IMG_EXTRA_ARGS"
	118	if [ -n "$IMGKEYSECRET" ]; then
	119	QEMU_IMG_EXTRA_ARGS="--object secret,id=keysec0,data=$IMGKEYSECRET $QEMU_IMG_EXTRA_ARGS"
	120	fi
4e9b25fb DB	121	if [ "$IMGFMT" = "luks" ]; then
	122	DRIVER="$DRIVER,key-secret=keysec0"
	123	fi
076003f5 DB	124	if [ "$IMGPROTO" = "file" ]; then
	125	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	126	TEST_IMG="$DRIVER,file.filename=$TEST_DIR/t.$IMGFMT"
	127	elif [ "$IMGPROTO" = "nbd" ]; then
	128	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	129	TEST_IMG="$DRIVER,file.driver=nbd,file.host=127.0.0.1,file.port=10810"
	130	elif [ "$IMGPROTO" = "ssh" ]; then
	131	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	132	TEST_IMG="$DRIVER,file.driver=ssh,file.host=127.0.0.1,file.path=$TEST_IMG_FILE"
	133	elif [ "$IMGPROTO" = "nfs" ]; then
	134	TEST_DIR="$DRIVER,file.driver=nfs,file.filename=nfs://127.0.0.1/$TEST_DIR"
e5b77eec	135	TEST_IMG=$TEST_DIR/t.$IMGFMT
076003f5 DB	136	else
	137	TEST_IMG="$DRIVER,file.driver=$IMGPROTO,file.filename=$TEST_DIR/t.$IMGFMT"
	138	fi
9cdfa1b3	139	else
cce293a2	140	QEMU_IMG_EXTRA_ARGS=
076003f5 DB	141	if [ "$IMGPROTO" = "file" ]; then
	142	TEST_IMG=$TEST_DIR/t.$IMGFMT
	143	elif [ "$IMGPROTO" = "nbd" ]; then
	144	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	145	TEST_IMG="nbd:127.0.0.1:10810"
	146	elif [ "$IMGPROTO" = "ssh" ]; then
	147	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	148	TEST_IMG="ssh://127.0.0.1$TEST_IMG_FILE"
	149	elif [ "$IMGPROTO" = "nfs" ]; then
	150	TEST_DIR="nfs://127.0.0.1/$TEST_DIR"
	151	TEST_IMG=$TEST_DIR/t.$IMGFMT
ae0c0a3d AM	152	elif [ "$IMGPROTO" = "vxhs" ]; then
	153	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	154	TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
076003f5 DB	155	else
	156	TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
	157	fi
9cdfa1b3	158	fi
59fa68f3	159	ORIG_TEST_IMG="$TEST_IMG"
6bf19c94	160
cce293a2 PB	161	if [ -z "$TEST_DIR" ]; then
	162	TEST_DIR=`pwd`/scratch
	163	fi
	164
	165	QEMU_TEST_DIR="${TEST_DIR}"
	166
	167	if [ ! -e "$TEST_DIR" ]; then
	168	mkdir "$TEST_DIR"
	169	fi
	170
	171	if [ ! -d "$TEST_DIR" ]; then
	172	echo "common.config: Error: \$TEST_DIR ($TEST_DIR) is not a directory"
	173	exit 1
	174	fi
	175
	176	if [ ! -d "$SAMPLE_IMG_DIR" ]; then
	177	echo "common.config: Error: \$SAMPLE_IMG_DIR ($SAMPLE_IMG_DIR) is not a directory"
	178	exit 1
	179	fi
	180
85edbd37 JC	181	_use_sample_img()
	182	{
	183	SAMPLE_IMG_FILE="${1%\.bz2}"
	184	TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE"
	185	bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG"
	186	if [ $? -ne 0 ]
	187	then
	188	echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'"
	189	exit 1
	190	fi
	191	}
	192
6bf19c94 CH	193	_make_test_img()
	194	{
	195	# extra qemu-img options can be added by tests
	196	# at least one argument (the image size) needs to be added
21af8148	197	local extra_img_options=""
21af8148	198	local image_size=$*
89004368	199	local optstr=""
a9660664	200	local img_name=""
0018c03f JC	201	local use_backing=0
0018c03f JC	202	local backing_file=""
b7e875b2	203	local object_options=""
a9660664 NT	204
	205	if [ -n "$TEST_IMG_FILE" ]; then
	206	img_name=$TEST_IMG_FILE
	207	else
	208	img_name=$TEST_IMG
	209	fi
89004368 KW	210
	211	if [ -n "$IMGOPTS" ]; then
	212	optstr=$(_optstr_add "$optstr" "$IMGOPTS")
	213	fi
b7e875b2 DB	214	if [ -n "$IMGKEYSECRET" ]; then
	215	object_options="--object secret,id=keysec0,data=$IMGKEYSECRET"
	216	optstr=$(_optstr_add "$optstr" "key-secret=keysec0")
	217	fi
6bf19c94	218
21af8148	219	if [ "$1" = "-b" ]; then
0018c03f JC	220	use_backing=1
0018c03f JC	221	backing_file=$2
21af8148 SW	222	image_size=$3
21af8148 SW	223	fi
f5a4bbd9	224	if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then
89004368 KW	225	optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE")
	226	fi
	227
	228	if [ -n "$optstr" ]; then
	229	extra_img_options="-o $optstr $extra_img_options"
8fc1024c KW	230	fi
8fc1024c KW	231
6bf19c94	232	# XXX(hch): have global image options?
0018c03f JC	233	(
0018c03f JC	234	if [ $use_backing = 1 ]; then
b7e875b2	235	$QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" $image_size 2>&1
0018c03f	236	else
b7e875b2	237	$QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1
0018c03f	238	fi
6ffb4cb6	239	) \| _filter_img_create
a9660664 NT	240
	241	# Start an NBD server on the image file, which is what we'll be talking to
	242	if [ $IMGPROTO = "nbd" ]; then
03a0aa37 HR	243	# Pass a sufficiently high number to -e that should be enough for all
	244	# tests
	245	eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT -e 42 $TEST_IMG_FILE >/dev/null &"
a9660664 NT	246	sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
a9660664 NT	247	fi
ae0c0a3d AM	248
	249	# Start QNIO server on image directory for vxhs protocol
	250	if [ $IMGPROTO = "vxhs" ]; then
	251	eval "$QEMU_VXHS -d $TEST_DIR > /dev/null &"
	252	sleep 1 # Wait for server to come up.
	253	fi
6bf19c94 CH	254	}
6bf19c94 CH	255
487c1910 FZ	256	_rm_test_img()
	257	{
	258	local img=$1
	259	if [ "$IMGFMT" = "vmdk" ]; then
	260	# Remove all the extents for vmdk
c5575274	261	"$QEMU_IMG" info "$img" 2>/dev/null \| grep 'filename:' \| cut -f 2 -d: \
487c1910 FZ	262	\| xargs -I {} rm -f "{}"
487c1910 FZ	263	fi
c5575274	264	rm -f "$img"
487c1910 FZ	265	}
487c1910 FZ	266
6bf19c94 CH	267	_cleanup_test_img()
6bf19c94 CH	268	{
9cdfa1b3 MK	269	case "$IMGPROTO" in
9cdfa1b3 MK	270
a9660664	271	nbd)
846a1d11	272	if [ -f "${QEMU_TEST_DIR}/qemu-nbd.pid" ]; then
f6c8c2e0	273	local QEMU_NBD_PID
846a1d11	274	read QEMU_NBD_PID < "${QEMU_TEST_DIR}/qemu-nbd.pid"
f6c8c2e0	275	kill ${QEMU_NBD_PID}
846a1d11	276	rm -f "${QEMU_TEST_DIR}/qemu-nbd.pid"
f798068c	277	fi
fef9c191	278	rm -f "$TEST_IMG_FILE"
a9660664	279	;;
ae0c0a3d AM	280	vxhs)
	281	if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
	282	local QEMU_VXHS_PID
	283	read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
	284	kill ${QEMU_VXHS_PID} >/dev/null 2>&1
	285	rm -f "${TEST_DIR}/qemu-vxhs.pid"
	286	fi
	287	rm -f "$TEST_IMG_FILE"
	288	;;
	289
9cdfa1b3	290	file)
487c1910 FZ	291	_rm_test_img "$TEST_DIR/t.$IMGFMT"
	292	_rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
	293	_rm_test_img "$TEST_DIR/t.$IMGFMT.base"
85edbd37 JC	294	if [ -n "$SAMPLE_IMG_FILE" ]
	295	then
	296	rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
59fa68f3 KW	297	SAMPLE_IMG_FILE=
59fa68f3 KW	298	TEST_IMG="$ORIG_TEST_IMG"
85edbd37	299	fi
9cdfa1b3 MK	300	;;
	301
	302	rbd)
9147d019	303	rbd --no-progress rm "$TEST_DIR/t.$IMGFMT" > /dev/null
9cdfa1b3 MK	304	;;
	305
	306	sheepdog)
fef9c191	307	collie vdi delete "$TEST_DIR/t.$IMGFMT"
9cdfa1b3 MK	308	;;
	309
	310	esac
6bf19c94 CH	311	}
	312
	313	_check_test_img()
	314	{
076003f5 DB	315	(
	316	if [ "$IMGOPTSSYNTAX" = "true" ]; then
	317	$QEMU_IMG check $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1
	318	else
	319	$QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1
	320	fi
86ce1f6e	321	) \| _filter_testdir \| _filter_qemu_img_check
6bf19c94 CH	322	}
6bf19c94 CH	323
514d9da5 SH	324	_img_info()
514d9da5 SH	325	{
e800e5d4 KW	326	if [[ "$1" == "--format-specific" ]]; then
	327	local format_specific=1
	328	shift
	329	else
	330	local format_specific=0
	331	fi
	332
4c2e9465 HR	333	discard=0
4c2e9465 HR	334	regex_json_spec_start='^ *"format-specific": \{'
fef9c191	335	$QEMU_IMG info "$@" "$TEST_IMG" 2>&1 \| \
514d9da5 SH	336	sed -e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
	337	-e "s#$TEST_DIR#TEST_DIR#g" \
	338	-e "s#$IMGFMT#IMGFMT#g" \
	339	-e "/^disk size:/ D" \
4c2e9465 HR	340	-e "/actual-size/ D" \| \
4c2e9465 HR	341	while IFS='' read line; do
e800e5d4 KW	342	if [[ $format_specific == 1 ]]; then
	343	discard=0
	344	elif [[ $line == "Format specific information:" ]]; then
4c2e9465 HR	345	discard=1
	346	elif [[ $line =~ $regex_json_spec_start ]]; then
	347	discard=2
	348	regex_json_spec_end="^${line%%[^ ]}\\},? $"
	349	fi
	350	if [[ $discard == 0 ]]; then
	351	echo "$line"
	352	elif [[ $discard == 1 && ! $line ]]; then
	353	echo
	354	discard=0
	355	elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
	356	discard=0
	357	fi
	358	done
514d9da5 SH	359	}
514d9da5 SH	360
6bf19c94 CH	361	# bail out, setting up .notrun file
	362	#
	363	_notrun()
	364	{
e8f8624d	365	echo "$*" >"$OUTPUT_DIR/$seq.notrun"
6bf19c94 CH	366	echo "$seq not run: $*"
	367	status=0
	368	exit
	369	}
	370
	371	# just plain bail out
	372	#
	373	_fail()
	374	{
e8f8624d	375	echo "$*" \| tee -a "$OUTPUT_DIR/$seq.full"
6bf19c94 CH	376	echo "(see $seq.full for details)"
	377	status=1
	378	exit 1
	379	}
	380
	381	# tests whether $IMGFMT is one of the supported image formats for a test
	382	#
	383	_supported_fmt()
	384	{
47f73da0 SH	385	# "generic" is suitable for most image formats. For some formats it doesn't
	386	# work, however (most notably read-only formats), so they can opt out by
	387	# setting IMGFMT_GENERIC to false.
6bf19c94	388	for f; do
89e91181	389	if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then
79e40ab1 KW	390	return
79e40ab1 KW	391	fi
6bf19c94 CH	392	done
	393
	394	_notrun "not suitable for this image format: $IMGFMT"
	395	}
	396
b4a2caa4 NS	397	# tests whether $IMGFMT is one of the unsupported image format for a test
	398	#
	399	_unsupported_fmt()
	400	{
	401	for f; do
	402	if [ "$f" = "$IMGFMT" ]; then
	403	_notrun "not suitable for this image format: $IMGFMT"
	404	fi
	405	done
	406	}
	407
9cdfa1b3 MK	408	# tests whether $IMGPROTO is one of the supported image protocols for a test
	409	#
	410	_supported_proto()
	411	{
	412	for f; do
79e40ab1 KW	413	if [ "$f" = "$IMGPROTO" -o "$f" = "generic" ]; then
	414	return
	415	fi
9cdfa1b3 MK	416	done
	417
	418	_notrun "not suitable for this image protocol: $IMGPROTO"
	419	}
	420
dfac03dc JC	421	# tests whether $IMGPROTO is specified as an unsupported image protocol for a test
	422	#
	423	_unsupported_proto()
	424	{
	425	for f; do
	426	if [ "$f" = "$IMGPROTO" ]; then
	427	_notrun "not suitable for this image protocol: $IMGPROTO"
	428	return
	429	fi
	430	done
	431	}
	432
6bf19c94 CH	433	# tests whether the host OS is one of the supported OSes for a test
	434	#
	435	_supported_os()
	436	{
	437	for h
	438	do
79e40ab1 KW	439	if [ "$h" = "$HOSTOS" ]
	440	then
	441	return
	442	fi
6bf19c94 CH	443	done
	444
	445	_notrun "not suitable for this OS: $HOSTOS"
	446	}
	447
f210a83c	448	_supported_cache_modes()
166f3c7b	449	{
f210a83c FZ	450	for mode; do
	451	if [ "$mode" = "$CACHEMODE" ]; then
	452	return
	453	fi
166f3c7b	454	done
f210a83c FZ	455	_notrun "not suitable for cache mode: $CACHEMODE"
	456	}
	457
	458	_default_cache_mode()
	459	{
	460	if $CACHEMODE_IS_DEFAULT; then
	461	CACHEMODE="$1"
	462	QEMU_IO="$QEMU_IO --cache $1"
	463	return
	464	fi
166f3c7b SH	465	}
166f3c7b SH	466
2c77f52e FZ	467	_unsupported_imgopts()
	468	{
	469	for bad_opt
	470	do
	471	if echo "$IMGOPTS" \| grep -q 2>/dev/null "$bad_opt"
	472	then
	473	_notrun "not suitable for image option: $bad_opt"
	474	fi
	475	done
	476	}
	477
6bf19c94 CH	478	# this test requires that a specified command (executable) exists
	479	#
	480	_require_command()
	481	{
934659c4 HR	482	if [ "$1" = "QEMU" ]; then
	483	c=$QEMU_PROG
	484	elif [ "$1" = "QEMU_IMG" ]; then
	485	c=$QEMU_IMG_PROG
	486	elif [ "$1" = "QEMU_IO" ]; then
	487	c=$QEMU_IO_PROG
	488	elif [ "$1" = "QEMU_NBD" ]; then
	489	c=$QEMU_NBD_PROG
	490	else
	491	eval c=\$$1
	492	fi
9c468a01	493	[ -x "$c" ] \|\| _notrun "$1 utility required, skipped this test"
6bf19c94 CH	494	}
6bf19c94 CH	495
6bf19c94	496	# make sure this script returns success
a2d9c0c4	497	true