[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 "$0: 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_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.config: 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.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
}

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

    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" $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 -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 "{}"
    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
}

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

# 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
4e670492	46	echo "$0: failed to source common.config"
3817ce03	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
655ae6bb	150	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
8908b253	151	REMOTE_TEST_DIR="nfs://127.0.0.1$TEST_DIR"
655ae6bb	152	TEST_IMG="nfs://127.0.0.1$TEST_IMG_FILE"
ae0c0a3d AM	153	elif [ "$IMGPROTO" = "vxhs" ]; then
	154	TEST_IMG_FILE=$TEST_DIR/t.$IMGFMT
	155	TEST_IMG="vxhs://127.0.0.1:9999/t.$IMGFMT"
076003f5 DB	156	else
	157	TEST_IMG=$IMGPROTO:$TEST_DIR/t.$IMGFMT
	158	fi
9cdfa1b3	159	fi
59fa68f3	160	ORIG_TEST_IMG="$TEST_IMG"
6bf19c94	161
cce293a2 PB	162	if [ -z "$TEST_DIR" ]; then
	163	TEST_DIR=`pwd`/scratch
	164	fi
	165
	166	QEMU_TEST_DIR="${TEST_DIR}"
	167
	168	if [ ! -e "$TEST_DIR" ]; then
	169	mkdir "$TEST_DIR"
	170	fi
	171
	172	if [ ! -d "$TEST_DIR" ]; then
	173	echo "common.config: Error: \$TEST_DIR ($TEST_DIR) is not a directory"
	174	exit 1
	175	fi
	176
8908b253 KW	177	if [ -z "$REMOTE_TEST_DIR" ]; then
	178	REMOTE_TEST_DIR="$TEST_DIR"
	179	fi
	180
cce293a2 PB	181	if [ ! -d "$SAMPLE_IMG_DIR" ]; then
	182	echo "common.config: Error: \$SAMPLE_IMG_DIR ($SAMPLE_IMG_DIR) is not a directory"
	183	exit 1
	184	fi
	185
85edbd37 JC	186	_use_sample_img()
	187	{
	188	SAMPLE_IMG_FILE="${1%\.bz2}"
	189	TEST_IMG="$TEST_DIR/$SAMPLE_IMG_FILE"
	190	bzcat "$SAMPLE_IMG_DIR/$1" > "$TEST_IMG"
	191	if [ $? -ne 0 ]
	192	then
	193	echo "_use_sample_img error, cannot extract '$SAMPLE_IMG_DIR/$1'"
	194	exit 1
	195	fi
	196	}
	197
2f9d4083 FZ	198	_stop_nbd_server()
	199	{
	200	if [ -f "${QEMU_TEST_DIR}/qemu-nbd.pid" ]; then
	201	local QEMU_NBD_PID
	202	read QEMU_NBD_PID < "${QEMU_TEST_DIR}/qemu-nbd.pid"
	203	kill ${QEMU_NBD_PID}
	204	rm -f "${QEMU_TEST_DIR}/qemu-nbd.pid"
	205	fi
	206	}
	207
6bf19c94 CH	208	_make_test_img()
	209	{
	210	# extra qemu-img options can be added by tests
	211	# at least one argument (the image size) needs to be added
21af8148	212	local extra_img_options=""
21af8148	213	local image_size=$*
89004368	214	local optstr=""
a9660664	215	local img_name=""
0018c03f JC	216	local use_backing=0
0018c03f JC	217	local backing_file=""
b7e875b2	218	local object_options=""
a9660664 NT	219
	220	if [ -n "$TEST_IMG_FILE" ]; then
	221	img_name=$TEST_IMG_FILE
	222	else
	223	img_name=$TEST_IMG
	224	fi
89004368 KW	225
	226	if [ -n "$IMGOPTS" ]; then
	227	optstr=$(_optstr_add "$optstr" "$IMGOPTS")
	228	fi
b7e875b2 DB	229	if [ -n "$IMGKEYSECRET" ]; then
	230	object_options="--object secret,id=keysec0,data=$IMGKEYSECRET"
	231	optstr=$(_optstr_add "$optstr" "key-secret=keysec0")
	232	fi
6bf19c94	233
21af8148	234	if [ "$1" = "-b" ]; then
0018c03f JC	235	use_backing=1
0018c03f JC	236	backing_file=$2
21af8148 SW	237	image_size=$3
21af8148 SW	238	fi
f5a4bbd9	239	if [ \( "$IMGFMT" = "qcow2" -o "$IMGFMT" = "qed" \) -a -n "$CLUSTER_SIZE" ]; then
89004368 KW	240	optstr=$(_optstr_add "$optstr" "cluster_size=$CLUSTER_SIZE")
	241	fi
	242
	243	if [ -n "$optstr" ]; then
	244	extra_img_options="-o $optstr $extra_img_options"
8fc1024c KW	245	fi
8fc1024c KW	246
2f9d4083 FZ	247	if [ $IMGPROTO = "nbd" ]; then
	248	_stop_nbd_server
	249	fi
	250
6bf19c94	251	# XXX(hch): have global image options?
0018c03f JC	252	(
0018c03f JC	253	if [ $use_backing = 1 ]; then
b7e875b2	254	$QEMU_IMG create $object_options -f $IMGFMT $extra_img_options -b "$backing_file" "$img_name" $image_size 2>&1
0018c03f	255	else
b7e875b2	256	$QEMU_IMG create $object_options -f $IMGFMT $extra_img_options "$img_name" $image_size 2>&1
0018c03f	257	fi
6ffb4cb6	258	) \| _filter_img_create
a9660664 NT	259
	260	# Start an NBD server on the image file, which is what we'll be talking to
	261	if [ $IMGPROTO = "nbd" ]; then
03a0aa37 HR	262	# Pass a sufficiently high number to -e that should be enough for all
03a0aa37 HR	263	# tests
147b44be	264	eval "$QEMU_NBD -v -t -b 127.0.0.1 -p 10810 -f $IMGFMT -e 42 -x '' $TEST_IMG_FILE >/dev/null &"
a9660664 NT	265	sleep 1 # FIXME: qemu-nbd needs to be listening before we continue
a9660664 NT	266	fi
ae0c0a3d AM	267
	268	# Start QNIO server on image directory for vxhs protocol
	269	if [ $IMGPROTO = "vxhs" ]; then
	270	eval "$QEMU_VXHS -d $TEST_DIR > /dev/null &"
	271	sleep 1 # Wait for server to come up.
	272	fi
6bf19c94 CH	273	}
6bf19c94 CH	274
487c1910 FZ	275	_rm_test_img()
	276	{
	277	local img=$1
	278	if [ "$IMGFMT" = "vmdk" ]; then
	279	# Remove all the extents for vmdk
c5575274	280	"$QEMU_IMG" info "$img" 2>/dev/null \| grep 'filename:' \| cut -f 2 -d: \
487c1910 FZ	281	\| xargs -I {} rm -f "{}"
487c1910 FZ	282	fi
c5575274	283	rm -f "$img"
487c1910 FZ	284	}
487c1910 FZ	285
6bf19c94 CH	286	_cleanup_test_img()
6bf19c94 CH	287	{
9cdfa1b3 MK	288	case "$IMGPROTO" in
9cdfa1b3 MK	289
a9660664	290	nbd)
2f9d4083	291	_stop_nbd_server
fef9c191	292	rm -f "$TEST_IMG_FILE"
a9660664	293	;;
ae0c0a3d AM	294	vxhs)
	295	if [ -f "${TEST_DIR}/qemu-vxhs.pid" ]; then
	296	local QEMU_VXHS_PID
	297	read QEMU_VXHS_PID < "${TEST_DIR}/qemu-vxhs.pid"
	298	kill ${QEMU_VXHS_PID} >/dev/null 2>&1
	299	rm -f "${TEST_DIR}/qemu-vxhs.pid"
	300	fi
	301	rm -f "$TEST_IMG_FILE"
	302	;;
	303
9cdfa1b3	304	file)
487c1910 FZ	305	_rm_test_img "$TEST_DIR/t.$IMGFMT"
	306	_rm_test_img "$TEST_DIR/t.$IMGFMT.orig"
	307	_rm_test_img "$TEST_DIR/t.$IMGFMT.base"
85edbd37 JC	308	if [ -n "$SAMPLE_IMG_FILE" ]
	309	then
	310	rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
59fa68f3 KW	311	SAMPLE_IMG_FILE=
59fa68f3 KW	312	TEST_IMG="$ORIG_TEST_IMG"
85edbd37	313	fi
9cdfa1b3 MK	314	;;
	315
	316	rbd)
9147d019	317	rbd --no-progress rm "$TEST_DIR/t.$IMGFMT" > /dev/null
9cdfa1b3 MK	318	;;
	319
	320	sheepdog)
fef9c191	321	collie vdi delete "$TEST_DIR/t.$IMGFMT"
9cdfa1b3 MK	322	;;
	323
	324	esac
6bf19c94 CH	325	}
	326
	327	_check_test_img()
	328	{
076003f5 DB	329	(
	330	if [ "$IMGOPTSSYNTAX" = "true" ]; then
	331	$QEMU_IMG check $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1
	332	else
	333	$QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1
	334	fi
86ce1f6e	335	) \| _filter_testdir \| _filter_qemu_img_check
6bf19c94 CH	336	}
6bf19c94 CH	337
514d9da5 SH	338	_img_info()
514d9da5 SH	339	{
e800e5d4 KW	340	if [[ "$1" == "--format-specific" ]]; then
	341	local format_specific=1
	342	shift
	343	else
	344	local format_specific=0
	345	fi
	346
4c2e9465 HR	347	discard=0
4c2e9465 HR	348	regex_json_spec_start='^ *"format-specific": \{'
d06195e6	349	$QEMU_IMG info $QEMU_IMG_EXTRA_ARGS "$@" "$TEST_IMG" 2>&1 \| \
8908b253 KW	350	sed -e "s#$REMOTE_TEST_DIR#TEST_DIR#g" \
8908b253 KW	351	-e "s#$IMGPROTO:$TEST_DIR#TEST_DIR#g" \
514d9da5 SH	352	-e "s#$TEST_DIR#TEST_DIR#g" \
	353	-e "s#$IMGFMT#IMGFMT#g" \
	354	-e "/^disk size:/ D" \
4c2e9465	355	-e "/actual-size/ D" \| \
6dd6d7ab	356	while IFS='' read -r line; do
e800e5d4 KW	357	if [[ $format_specific == 1 ]]; then
	358	discard=0
	359	elif [[ $line == "Format specific information:" ]]; then
4c2e9465 HR	360	discard=1
	361	elif [[ $line =~ $regex_json_spec_start ]]; then
	362	discard=2
	363	regex_json_spec_end="^${line%%[^ ]}\\},? $"
	364	fi
	365	if [[ $discard == 0 ]]; then
	366	echo "$line"
	367	elif [[ $discard == 1 && ! $line ]]; then
	368	echo
	369	discard=0
	370	elif [[ $discard == 2 && $line =~ $regex_json_spec_end ]]; then
	371	discard=0
	372	fi
	373	done
514d9da5 SH	374	}
514d9da5 SH	375
6bf19c94 CH	376	# bail out, setting up .notrun file
	377	#
	378	_notrun()
	379	{
e8f8624d	380	echo "$*" >"$OUTPUT_DIR/$seq.notrun"
6bf19c94 CH	381	echo "$seq not run: $*"
	382	status=0
	383	exit
	384	}
	385
	386	# just plain bail out
	387	#
	388	_fail()
	389	{
e8f8624d	390	echo "$*" \| tee -a "$OUTPUT_DIR/$seq.full"
6bf19c94 CH	391	echo "(see $seq.full for details)"
	392	status=1
	393	exit 1
	394	}
	395
	396	# tests whether $IMGFMT is one of the supported image formats for a test
	397	#
	398	_supported_fmt()
	399	{
47f73da0 SH	400	# "generic" is suitable for most image formats. For some formats it doesn't
	401	# work, however (most notably read-only formats), so they can opt out by
	402	# setting IMGFMT_GENERIC to false.
6bf19c94	403	for f; do
89e91181	404	if [ "$f" = "$IMGFMT" -o "$f" = "generic" -a "$IMGFMT_GENERIC" = "true" ]; then
79e40ab1 KW	405	return
79e40ab1 KW	406	fi
6bf19c94 CH	407	done
	408
	409	_notrun "not suitable for this image format: $IMGFMT"
	410	}
	411
b4a2caa4 NS	412	# tests whether $IMGFMT is one of the unsupported image format for a test
	413	#
	414	_unsupported_fmt()
	415	{
	416	for f; do
	417	if [ "$f" = "$IMGFMT" ]; then
	418	_notrun "not suitable for this image format: $IMGFMT"
	419	fi
	420	done
	421	}
	422
9cdfa1b3 MK	423	# tests whether $IMGPROTO is one of the supported image protocols for a test
	424	#
	425	_supported_proto()
	426	{
	427	for f; do
79e40ab1 KW	428	if [ "$f" = "$IMGPROTO" -o "$f" = "generic" ]; then
	429	return
	430	fi
9cdfa1b3 MK	431	done
	432
	433	_notrun "not suitable for this image protocol: $IMGPROTO"
	434	}
	435
dfac03dc JC	436	# tests whether $IMGPROTO is specified as an unsupported image protocol for a test
	437	#
	438	_unsupported_proto()
	439	{
	440	for f; do
	441	if [ "$f" = "$IMGPROTO" ]; then
	442	_notrun "not suitable for this image protocol: $IMGPROTO"
	443	return
	444	fi
	445	done
	446	}
	447
6bf19c94 CH	448	# tests whether the host OS is one of the supported OSes for a test
	449	#
	450	_supported_os()
	451	{
	452	for h
	453	do
79e40ab1 KW	454	if [ "$h" = "$HOSTOS" ]
	455	then
	456	return
	457	fi
6bf19c94 CH	458	done
	459
	460	_notrun "not suitable for this OS: $HOSTOS"
	461	}
	462
f210a83c	463	_supported_cache_modes()
166f3c7b	464	{
f210a83c FZ	465	for mode; do
	466	if [ "$mode" = "$CACHEMODE" ]; then
	467	return
	468	fi
166f3c7b	469	done
f210a83c FZ	470	_notrun "not suitable for cache mode: $CACHEMODE"
	471	}
	472
	473	_default_cache_mode()
	474	{
	475	if $CACHEMODE_IS_DEFAULT; then
	476	CACHEMODE="$1"
	477	QEMU_IO="$QEMU_IO --cache $1"
	478	return
	479	fi
166f3c7b SH	480	}
166f3c7b SH	481
2c77f52e FZ	482	_unsupported_imgopts()
	483	{
	484	for bad_opt
	485	do
	486	if echo "$IMGOPTS" \| grep -q 2>/dev/null "$bad_opt"
	487	then
	488	_notrun "not suitable for image option: $bad_opt"
	489	fi
	490	done
	491	}
	492
6bf19c94 CH	493	# this test requires that a specified command (executable) exists
	494	#
	495	_require_command()
	496	{
934659c4 HR	497	if [ "$1" = "QEMU" ]; then
	498	c=$QEMU_PROG
	499	elif [ "$1" = "QEMU_IMG" ]; then
	500	c=$QEMU_IMG_PROG
	501	elif [ "$1" = "QEMU_IO" ]; then
	502	c=$QEMU_IO_PROG
	503	elif [ "$1" = "QEMU_NBD" ]; then
	504	c=$QEMU_NBD_PROG
	505	else
	506	eval c=\$$1
	507	fi
9c468a01	508	[ -x "$c" ] \|\| _notrun "$1 utility required, skipped this test"
6bf19c94 CH	509	}
6bf19c94 CH	510
6bf19c94	511	# make sure this script returns success
a2d9c0c4	512	true