openkylin
/
qemu
mirror of https://gitee.com/openkylin/qemu.git
9
0
Fork 0
Code Issues Projects Releases Wiki Activity

qemu-iotests: Quote $TEST_IMG* and $TEST_DIR usage 

A lot of image filename and paths are used unquoted.  Quote these to
make sure that directories / filenames with spaces are not problematic.

Signed-off-by: Jeff Cody <jcody@redhat.com>
Reviewed-by: Stefan Hajnoczi <stefanha@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
This commit is contained in:
Jeff Cody 2013-09-25 08:12:22 -04:00 committed by Kevin Wolf
parent 85edbd375b
commit fef9c19139
49 changed files with 336 additions and 336 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

6
tests/qemu-iotests/001
View File

@ -48,15 +48,15 @@ _make_test_img $size
echo
echo "== reading whole image =="
$QEMU_IO -c "read 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== rewriting whole image =="
$QEMU_IO -c "write -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verify pattern =="
$QEMU_IO -c "read -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
# success, all done

36
tests/qemu-iotests/002
View File

@ -48,36 +48,36 @@ _make_test_img $size
echo
echo "== reading whole image =="
$QEMU_IO -c "read -p 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -p 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== rewriting whole image =="
$QEMU_IO -c "write -pP 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -pP 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verify pattern =="
$QEMU_IO -c "read -pP 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -pP 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "unaligned pwrite"
$QEMU_IO -c 'write -pP 0xab 66 42' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xac 512 288' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xad 800 224' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xae 66000 128k' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xaf 256k 42' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xab 66 42' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xac 512 288' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xad 800 224' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xae 66000 128k' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'write -pP 0xaf 256k 42' "$TEST_IMG" | _filter_qemu_io
echo
echo "verify pattern"
$QEMU_IO -c 'read -pP 0xa 0 66' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xab 66 42' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 108 404' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xac 512 288' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xad 800 224' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 1k 64976' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xae 66000 128k' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 197072 65072' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xaf 256k 42' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 262186 470' $TEST_IMG | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 0 66' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xab 66 42' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 108 404' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xac 512 288' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xad 800 224' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 1k 64976' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xae 66000 128k' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 197072 65072' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xaf 256k 42' "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c 'read -pP 0xa 262186 470' "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

10
tests/qemu-iotests/003
View File

@ -50,27 +50,27 @@ _make_test_img $size
echo
echo "== reading whole image =="
$QEMU_IO -c "readv 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "readv 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== rewriting whole image =="
$QEMU_IO -c "writev -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "writev -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verify pattern =="
$QEMU_IO -c "readv -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "readv -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== vectored write =="
$QEMU_IO -c "writev -P 0xb $offset $chunksize $chunksize \
$chunksize $chunksize $chunksize $chunksize $chunksize" \
$TEST_IMG | _filter_qemu_io
"$TEST_IMG" | _filter_qemu_io
echo
echo "== verify pattern =="
$QEMU_IO -c "readv -P 0xb $offset $chunksize $chunksize \
$chunksize $chunksize $chunksize $chunksize $chunksize" \
$TEST_IMG | _filter_qemu_io
"$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

24
tests/qemu-iotests/004
View File

@ -51,51 +51,51 @@ _make_test_img $size
echo
echo "write before image boundary"
$QEMU_IO -c "write $pre_offset 1M" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write $pre_offset 1M" "$TEST_IMG" | _filter_qemu_io
echo
echo "write into image boundary"
$QEMU_IO -c "write $pre_offset 4M" $TEST_IMG
$QEMU_IO -c "write $pre_offset 4M" "$TEST_IMG"
echo
echo "write at image boundary"
$QEMU_IO -c "write $size 4096" $TEST_IMG
$QEMU_IO -c "write $size 4096" "$TEST_IMG"
echo
echo "write past image boundary"
$QEMU_IO -c "write $past_offset 4096" $TEST_IMG
$QEMU_IO -c "write $past_offset 4096" "$TEST_IMG"
echo
echo "pwrite past image boundary"
$QEMU_IO -c "write -p $past_offset 4096" $TEST_IMG
$QEMU_IO -c "write -p $past_offset 4096" "$TEST_IMG"
echo
echo "writev past image boundary"
$QEMU_IO -c "writev $past_offset 4096" $TEST_IMG
$QEMU_IO -c "writev $past_offset 4096" "$TEST_IMG"
echo
echo "read before image boundary"
$QEMU_IO -c "read $pre_offset 1M" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read $pre_offset 1M" "$TEST_IMG" | _filter_qemu_io
echo
echo "read into image boundary"
$QEMU_IO -c "read $pre_offset 4M" $TEST_IMG
$QEMU_IO -c "read $pre_offset 4M" "$TEST_IMG"
echo
echo "read at image boundary"
$QEMU_IO -c "read $size 4096" $TEST_IMG
$QEMU_IO -c "read $size 4096" "$TEST_IMG"
echo
echo "read past image boundary"
$QEMU_IO -c "read $past_offset 4096" $TEST_IMG
$QEMU_IO -c "read $past_offset 4096" "$TEST_IMG"
echo
echo "pread past image boundary"
$QEMU_IO -c "read -p $past_offset 4096" $TEST_IMG
$QEMU_IO -c "read -p $past_offset 4096" "$TEST_IMG"
echo
echo "readv past image boundary"
$QEMU_IO -c "readv $past_offset 4096" $TEST_IMG
$QEMU_IO -c "readv $past_offset 4096" "$TEST_IMG"
# success, all done

4
tests/qemu-iotests/005
View File

@ -61,11 +61,11 @@ _make_test_img 5000G
echo
echo "small read"
$QEMU_IO -c "read 1024 4096" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read 1024 4096" "$TEST_IMG" | _filter_qemu_io
echo
echo "small write"
$QEMU_IO -c "write 8192 4096" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write 8192 4096" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

2
tests/qemu-iotests/007
View File

@ -50,7 +50,7 @@ _make_test_img 1M
for i in `seq 1 10`; do
echo "savevm $i"
$QEMU -nographic -hda $TEST_IMG -serial none -monitor stdio >/dev/null 2>&1 <<EOF
$QEMU -nographic -hda "$TEST_IMG" -serial none -monitor stdio >/dev/null 2>&1 <<EOF
savevm test-$i
quit
EOF

6
tests/qemu-iotests/008
View File

@ -48,15 +48,15 @@ _make_test_img $size
echo
echo "== reading whole image =="
$QEMU_IO -c "aio_read 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "aio_read 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== rewriting whole image =="
$QEMU_IO -c "aio_write -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "aio_write -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verify pattern =="
$QEMU_IO -c "aio_read -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "aio_read -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
# success, all done

2
tests/qemu-iotests/009
View File

@ -57,7 +57,7 @@ $QEMU_IO \
-c "write 4k 4k" \
-c "write 9M 4k" \
-c "read -P 65 -s 4k -l 4k 2044k 8k" \
$TEST_IMG | _filter_qemu_io
"$TEST_IMG" | _filter_qemu_io
echo
echo "checking image for errors"

2
tests/qemu-iotests/010
View File

@ -59,7 +59,7 @@ $QEMU_IO \
-c "write -P 165 2044k 4k" \
-c "write -P 99 8M 4k" \
-c "read -P 165 2044k 8k" \
$TEST_IMG | _filter_qemu_io
"$TEST_IMG" | _filter_qemu_io
echo
echo "checking image for errors"

2
tests/qemu-iotests/011
View File

@ -60,7 +60,7 @@ for i in `seq 1 10`; do
# Note that we filter away the actual offset. That's because qemu
# may re-order the two aio requests. We only want to make sure the
# filesystem isn't corrupted afterwards anyway.
$QEMU_IO -c "aio_write $off1 1M" -c "aio_write $off2 1M" $TEST_IMG | \
$QEMU_IO -c "aio_write $off1 1M" -c "aio_write $off2 1M" "$TEST_IMG" | \
_filter_qemu_io | \
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
done

4
tests/qemu-iotests/012
View File

@ -50,11 +50,11 @@ _make_test_img $size
echo
echo "== mark image read-only"
chmod a-w $TEST_IMG
chmod a-w "$TEST_IMG"
echo
echo "== read from read-only image"
$QEMU_IO -r -c "read 0 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -r -c "read 0 512" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

4
tests/qemu-iotests/013
View File

@ -65,8 +65,8 @@ done
echo "Compressing image"
echo
mv $TEST_IMG $TEST_IMG.orig
$QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c $TEST_IMG.orig $TEST_IMG
mv "$TEST_IMG" "$TEST_IMG.orig"
$QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c "$TEST_IMG.orig" "$TEST_IMG"
echo "Testing compressed image"
echo

2
tests/qemu-iotests/014
View File

@ -61,7 +61,7 @@ done
# With snapshots
for i in `seq 1 3`; do
$QEMU_IMG snapshot -c test$i $TEST_IMG
$QEMU_IMG snapshot -c test$i "$TEST_IMG"
for offset in $TEST_OFFSETS; do
echo With snapshot test$i, offset $offset
for op in $TEST_OPS; do

16
tests/qemu-iotests/015
View File

@ -61,19 +61,19 @@ _make_test_img $size
# Create two snapshots which fill the image with two different patterns
echo "creating first snapshot"
$QEMU_IO -c "aio_write -P 123 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IMG snapshot -c snap1 $TEST_IMG
$QEMU_IO -c "aio_write -P 123 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -c snap1 "$TEST_IMG"
echo "creating second snapshot"
$QEMU_IO -c "aio_write -P 165 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IMG snapshot -c snap2 $TEST_IMG
$QEMU_IO -c "aio_write -P 165 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -c snap2 "$TEST_IMG"
# Now check the pattern
echo "checking first snapshot"
$QEMU_IMG snapshot -a snap1 $TEST_IMG
$QEMU_IO -c "aio_read -P 123 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IMG snapshot -a snap1 "$TEST_IMG"
$QEMU_IO -c "aio_read -P 123 0 $size" "$TEST_IMG" | _filter_qemu_io
echo "checking second snapshot"
$QEMU_IMG snapshot -a snap2 $TEST_IMG
$QEMU_IO -c "aio_read -P 165 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IMG snapshot -a snap2 "$TEST_IMG"
$QEMU_IO -c "aio_read -P 165 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "checking image for errors"

12
tests/qemu-iotests/016
View File

@ -48,21 +48,21 @@ _make_test_img $size
echo
echo "== reading at EOF =="
$QEMU_IO -g -c "read -P 0 $size 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -g -c "read -P 0 $size 512" "$TEST_IMG" | _filter_qemu_io
echo
echo "== reading far past EOF =="
$QEMU_IO -g -c "read -P 0 256M 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -g -c "read -P 0 256M 512" "$TEST_IMG" | _filter_qemu_io
echo
echo "== writing at EOF =="
$QEMU_IO -g -c "write -P 66 $size 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 66 $size 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -g -c "write -P 66 $size 512" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 66 $size 512" "$TEST_IMG" | _filter_qemu_io
echo
echo "== writing far past EOF =="
$QEMU_IO -g -c "write -P 66 256M 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 66 256M 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -g -c "write -P 66 256M 512" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 66 256M 512" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

6
tests/qemu-iotests/018
View File

@ -66,7 +66,7 @@ echo "Creating test image with backing file"
echo
TEST_IMG=$TEST_IMG_SAVE
_make_test_img -b $TEST_IMG.base 6G
_make_test_img -b "$TEST_IMG.base" 6G
echo "Filling test image"
echo
@ -80,8 +80,8 @@ for offset in $TEST_OFFSETS; do
done
_check_test_img
mv $TEST_IMG $TEST_IMG.orig
$QEMU_IMG convert -O $IMGFMT $TEST_IMG.orig $TEST_IMG
mv "$TEST_IMG" "$TEST_IMG.orig"
$QEMU_IMG convert -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
echo "Reading"
echo

12
tests/qemu-iotests/019
View File

@ -33,8 +33,8 @@ status=1 # failure is the default!
_cleanup()
{
_cleanup_test_img
rm -f $TEST_IMG.base
rm -f $TEST_IMG.orig
rm -f "$TEST_IMG.base"
rm -f "$TEST_IMG.orig"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -68,8 +68,8 @@ _check_test_img
echo "Creating test image with backing file"
echo
mv $TEST_IMG $TEST_IMG.base
_make_test_img -b $TEST_IMG.base 6G
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b "$TEST_IMG.base" 6G
echo "Filling test image"
echo
@ -83,7 +83,7 @@ for offset in $TEST_OFFSETS; do
done
_check_test_img
mv $TEST_IMG $TEST_IMG.orig
mv "$TEST_IMG" "$TEST_IMG.orig"
@ -95,7 +95,7 @@ for backing_option in "-B $TEST_IMG.base" "-o backing_file=$TEST_IMG.base"; do
echo
echo Testing conversion with $backing_option | _filter_testdir | _filter_imgfmt
echo
$QEMU_IMG convert -O $IMGFMT $backing_option $TEST_IMG.orig $TEST_IMG
$QEMU_IMG convert -O $IMGFMT $backing_option "$TEST_IMG.orig" "$TEST_IMG"
echo "Checking if backing clusters are allocated when they shouldn't"
echo

12
tests/qemu-iotests/020
View File

@ -31,8 +31,8 @@ status=1 # failure is the default!
_cleanup()
{
_cleanup_test_img
rm -f $TEST_IMG.base
rm -f $TEST_IMG.orig
rm -f "$TEST_IMG.base"
rm -f "$TEST_IMG.orig"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -65,8 +65,8 @@ _check_test_img
echo "Creating test image with backing file"
echo
mv $TEST_IMG $TEST_IMG.base
_make_test_img -b $TEST_IMG.base 6G
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b "$TEST_IMG.base" 6G
echo "Filling test image"
echo
@ -80,8 +80,8 @@ for offset in $TEST_OFFSETS; do
done
_check_test_img
$QEMU_IMG commit $TEST_IMG
mv $TEST_IMG.base $TEST_IMG
$QEMU_IMG commit "$TEST_IMG"
mv "$TEST_IMG.base" "$TEST_IMG"
echo "Reading from the backing file"
echo

2
tests/qemu-iotests/021
View File

@ -53,7 +53,7 @@ for pattern in $INVALID_PATTERNS; do
for op in $TEST_OPS; do
echo
echo "== testing $op -P $pattern =="
$QEMU_IO -c "$op -P $pattern 0 4096" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "$op -P $pattern 0 4096" "$TEST_IMG" | _filter_qemu_io
done
done

4
tests/qemu-iotests/023
View File

@ -71,8 +71,8 @@ for CLUSTER_SIZE in $CLUSTER_SIZES; do
echo "Compressing image"
echo
mv $TEST_IMG $TEST_IMG.orig
$QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c $TEST_IMG.orig $TEST_IMG
mv "$TEST_IMG" "$TEST_IMG.orig"
$QEMU_IMG convert -f $IMGFMT -O $IMGFMT -c "$TEST_IMG.orig" "$TEST_IMG"
echo "Testing compressed image"
echo

12
tests/qemu-iotests/024
View File

@ -31,8 +31,8 @@ status=1 # failure is the default!
_cleanup()
{
_cleanup_test_img
rm -f $TEST_DIR/t.$IMGFMT.base_old
rm -f $TEST_DIR/t.$IMGFMT.base_new
rm -f "$TEST_DIR/t.$IMGFMT.base_old"
rm -f "$TEST_DIR/t.$IMGFMT.base_new"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -62,19 +62,19 @@ echo
_make_test_img 1G
io_pattern writev 0 $CLUSTER_SIZE $((2 * CLUSTER_SIZE)) 8 0x11
mv $TEST_IMG $TEST_IMG.base_old
mv "$TEST_IMG" "$TEST_IMG.base_old"
echo "Creating new backing file"
echo
_make_test_img 1G
io_pattern writev 0 $((2 * CLUSTER_SIZE)) $((4 * CLUSTER_SIZE)) 4 0x22
mv $TEST_IMG $TEST_IMG.base_new
mv "$TEST_IMG" "$TEST_IMG.base_new"
echo "Creating COW image"
echo
_make_test_img -b $TEST_IMG.base_old 1G
_make_test_img -b "$TEST_IMG.base_old" 1G
io_pattern writev 0 $((4 * CLUSTER_SIZE)) 0 1 0x33
io_pattern writev $((8 * CLUSTER_SIZE)) $((4 * CLUSTER_SIZE)) 0 1 0x33
@ -100,7 +100,7 @@ io_pattern readv $((15 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x00
echo
echo Rebase and test again
echo
$QEMU_IMG rebase -b $TEST_IMG.base_new $TEST_IMG
$QEMU_IMG rebase -b "$TEST_IMG.base_new" "$TEST_IMG"
io_pattern readv $((0 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33
io_pattern readv $((1 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33
io_pattern readv $((2 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33

4
tests/qemu-iotests/025
View File

@ -56,7 +56,7 @@ _check_test_img
echo
echo "=== Resizing image"
$QEMU_IO $TEST_IMG <<EOF
$QEMU_IO "$TEST_IMG" <<EOF
length
truncate $big_size
length
@ -65,7 +65,7 @@ _check_test_img
echo
echo "=== Verifying image size after reopen"
$QEMU_IO -c "length" $TEST_IMG
$QEMU_IO -c "length" "$TEST_IMG"
echo
echo "=== Verifying resized image"

20
tests/qemu-iotests/026
View File

@ -31,7 +31,7 @@ status=1 # failure is the default!
_cleanup()
{
_cleanup_test_img
rm $TEST_DIR/blkdebug.conf
rm "$TEST_DIR/blkdebug.conf"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -75,7 +75,7 @@ for imm in off; do
for once in on off; do
for vmstate in "" "-b"; do
cat > $TEST_DIR/blkdebug.conf <<EOF
cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error]
event = "$event"
errno = "$errno"
@ -90,16 +90,16 @@ echo "Event: $event; errno: $errno; imm: $imm; once: $once; write $vmstate"
# We want to catch a simple L2 update, not the allocation of the first L2 table
if [ "$event" == "l2_update" ]; then
$QEMU_IO -c "write $vmstate 0 512" $TEST_IMG > /dev/null 2>&1
$QEMU_IO -c "write $vmstate 0 512" "$TEST_IMG" > /dev/null 2>&1
fi
$QEMU_IO -c "write $vmstate 0 128k " $BLKDBG_TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write $vmstate 0 128k " "$BLKDBG_TEST_IMG" | _filter_qemu_io
# l2_load is not called on allocation, so issue a second write
# Reads are another path to trigger l2_load, so do a read, too
if [ "$event" == "l2_load" ]; then
$QEMU_IO -c "write $vmstate 0 128k " $BLKDBG_TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read $vmstate 0 128k " $BLKDBG_TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write $vmstate 0 128k " "$BLKDBG_TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read $vmstate 0 128k " "$BLKDBG_TEST_IMG" | _filter_qemu_io
fi
_check_test_img 2>&1 | grep -v "refcount=1 reference=0"
@ -133,7 +133,7 @@ for imm in off; do
for once in on off; do
for vmstate in "" "-b"; do
cat > $TEST_DIR/blkdebug.conf <<EOF
cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error]
event = "$event"
errno = "$errno"
@ -145,7 +145,7 @@ _make_test_img 1G
echo
echo "Event: $event; errno: $errno; imm: $imm; once: $once; write $vmstate"
$QEMU_IO -c "write $vmstate 0 64M" $BLKDBG_TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write $vmstate 0 64M" "$BLKDBG_TEST_IMG" | _filter_qemu_io
_check_test_img 2>&1 | grep -v "refcount=1 reference=0"
@ -172,7 +172,7 @@ for errno in 5 28; do
for imm in off; do
for once in on off; do
cat > $TEST_DIR/blkdebug.conf <<EOF
cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error]
event = "$event"
errno = "$errno"
@ -184,7 +184,7 @@ _make_test_img 1G
echo
echo "Event: $event; errno: $errno; imm: $imm; once: $once"
$QEMU_IO -c "write -b 0 64k" $BLKDBG_TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -b 0 64k" "$BLKDBG_TEST_IMG" | _filter_qemu_io
_check_test_img 2>&1 | grep -v "refcount=1 reference=0"

10
tests/qemu-iotests/027
View File

@ -54,23 +54,23 @@ _make_test_img $size
# Otherwise an L2 table could get in the way after the data cluster.
echo
echo "== writing first cluster to populate metadata =="
$QEMU_IO -c "write -pP 0xde $cluster_size $cluster_size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -pP 0xde $cluster_size $cluster_size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== writing at sub-cluster granularity =="
$QEMU_IO -c "write -pP 0xa $subcluster_offset $subcluster_size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -pP 0xa $subcluster_offset $subcluster_size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verify pattern =="
$QEMU_IO -c "read -pP 0xa $subcluster_offset $subcluster_size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -pP 0xa $subcluster_offset $subcluster_size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verify zeroes before sub-cluster pattern =="
$QEMU_IO -c "read -pP 0 -l $subcluster_offset 0 $subcluster_size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -pP 0 -l $subcluster_offset 0 $subcluster_size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verify zeroes after sub-cluster pattern =="
$QEMU_IO -c "read -pP 0 -l 512 -s $subcluster_size $subcluster_offset $(( subcluster_size + 512 ))" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -pP 0 -l 512 -s $subcluster_size $subcluster_offset $(( subcluster_size + 512 ))" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

6
tests/qemu-iotests/028
View File

@ -71,8 +71,8 @@ _check_test_img
echo "Creating test image with backing file"
echo
mv $TEST_IMG $TEST_IMG.base
_make_test_img -b $TEST_IMG.base $image_size
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b "$TEST_IMG.base" $image_size
echo "Filling test image"
echo
@ -97,7 +97,7 @@ io_zero readv $(( offset + 32 * 1024 )) 512 1024 32
_check_test_img
# Rebase it on top of its base image
$QEMU_IMG rebase -b $TEST_IMG.base $TEST_IMG
$QEMU_IMG rebase -b "$TEST_IMG.base" "$TEST_IMG"
_check_test_img

12
tests/qemu-iotests/029
View File

@ -47,16 +47,16 @@ _supported_os Linux
CLUSTER_SIZE=65536
_make_test_img 64M
$QEMU_IMG snapshot -c foo $TEST_IMG
$QEMU_IO -c 'write -b 0 4k' $TEST_IMG | _filter_qemu_io
$QEMU_IMG snapshot -a foo $TEST_IMG
$QEMU_IMG snapshot -c foo "$TEST_IMG"
$QEMU_IO -c 'write -b 0 4k' "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -a foo "$TEST_IMG"
_check_test_img
CLUSTER_SIZE=1024
_make_test_img 16M
$QEMU_IMG snapshot -c foo $TEST_IMG
$QEMU_IO -c 'write -b 0 4M' $TEST_IMG | _filter_qemu_io
$QEMU_IMG snapshot -a foo $TEST_IMG
$QEMU_IMG snapshot -c foo "$TEST_IMG"
$QEMU_IO -c 'write -b 0 4M' "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -a foo "$TEST_IMG"
_check_test_img
# success, all done

12
tests/qemu-iotests/031
View File

@ -56,22 +56,22 @@ for IMGOPTS in "compat=0.10" "compat=1.1"; do
echo === Create image with unknown header extension ===
echo
_make_test_img 64M
./qcow2.py $TEST_IMG add-header-ext 0x12345678 "This is a test header extension"
./qcow2.py $TEST_IMG dump-header
./qcow2.py "$TEST_IMG" add-header-ext 0x12345678 "This is a test header extension"
./qcow2.py "$TEST_IMG" dump-header
_check_test_img
echo
echo === Rewrite header with no backing file ===
echo
$QEMU_IMG rebase -u -b "" $TEST_IMG
./qcow2.py $TEST_IMG dump-header
$QEMU_IMG rebase -u -b "" "$TEST_IMG"
./qcow2.py "$TEST_IMG" dump-header
_check_test_img
echo
echo === Add a backing file and format ===
echo
$QEMU_IMG rebase -u -b "/some/backing/file/path" -F host_device $TEST_IMG
./qcow2.py $TEST_IMG dump-header
$QEMU_IMG rebase -u -b "/some/backing/file/path" -F host_device "$TEST_IMG"
./qcow2.py "$TEST_IMG" dump-header
done
# success, all done

4
tests/qemu-iotests/032
View File

@ -55,12 +55,12 @@ _make_test_img 64M
# Allocate every other cluster so that afterwards a big write request will
# actually loop a while and issue many I/O requests for the lower layer
for i in $(seq 0 128 4096); do echo "write ${i}k 64k"; done | $QEMU_IO $TEST_IMG | _filter_qemu_io
for i in $(seq 0 128 4096); do echo "write ${i}k 64k"; done | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo
echo === AIO request during close ===
echo
$QEMU_IO -c "aio_write 0 4M" -c "close" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "aio_write 0 4M" -c "close" "$TEST_IMG" | _filter_qemu_io
_check_test_img
# success, all done

18
tests/qemu-iotests/033
View File

@ -48,24 +48,24 @@ _make_test_img $size
echo
echo "== preparing image =="
$QEMU_IO -c "write -P 0xa 0x200 0x400" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xa 0x20000 0x600" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -z 0x400 0x20000" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xa 0x200 0x400" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xa 0x20000 0x600" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -z 0x400 0x20000" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verifying patterns (1) =="
$QEMU_IO -c "read -P 0xa 0x200 0x200" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 0x400 0x20000" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 0x20400 0x200" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 0x200 0x200" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 0x400 0x20000" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 0x20400 0x200" "$TEST_IMG" | _filter_qemu_io
echo
echo "== rewriting zeroes =="
$QEMU_IO -c "write -P 0xb 0x10000 0x10000" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -z 0x10000 0x10000" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xb 0x10000 0x10000" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -z 0x10000 0x10000" "$TEST_IMG" | _filter_qemu_io
echo
echo "== verifying patterns (2) =="
$QEMU_IO -c "read -P 0x0 0x400 0x20000" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 0x400 0x20000" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

64
tests/qemu-iotests/034
View File

@ -49,63 +49,63 @@ echo
echo "== creating backing file for COW tests =="
_make_test_img $size
$QEMU_IO -c "write -P 0x55 0 1M" $TEST_IMG | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base
$QEMU_IO -c "write -P 0x55 0 1M" "$TEST_IMG" | _filter_qemu_io
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G
_make_test_img -b "$TEST_IMG.base" 6G
echo
echo "== zero write with backing file =="
$QEMU_IO -c "write -z 64k 192k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -z 513k 13k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -z 64k 192k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -z 513k 13k" "$TEST_IMG" | _filter_qemu_io
_check_test_img
echo
echo "== verifying patterns (3) =="
$QEMU_IO -c "read -P 0x55 0 64k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 64k 192k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 256k 257k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 513k 13k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 526k 498k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 0 64k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 64k 192k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 256k 257k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 513k 13k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 526k 498k" "$TEST_IMG" | _filter_qemu_io
echo
echo "== overwriting zero cluster =="
$QEMU_IO -c "write -P 0xa 60k 8k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xb 64k 8k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xc 76k 4k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xd 252k 8k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xe 248k 8k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0xa 60k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xb 64k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xc 76k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xd 252k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0xe 248k 8k" "$TEST_IMG" | _filter_qemu_io
_check_test_img
echo
echo "== verifying patterns (4) =="
$QEMU_IO -c "read -P 0x55 0 60k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 60k 4k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xb 64k 8k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 72k 4k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xc 76k 4k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 80k 168k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xe 248k 8k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xd 256k 4k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 260k 64k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 0 60k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 60k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xb 64k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 72k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xc 76k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 80k 168k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xe 248k 8k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xd 256k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 260k 64k" "$TEST_IMG" | _filter_qemu_io
echo
echo "== re-zeroing overwritten area =="
$QEMU_IO -c "write -z 64k 192k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -z 64k 192k" "$TEST_IMG" | _filter_qemu_io
_check_test_img
echo
echo "== verifying patterns (5) =="
$QEMU_IO -c "read -P 0x55 0 60k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 60k 4k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 64k 192k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0xd 256k 4k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 260k 253k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 513k 13k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 526k 498k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 0 60k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xa 60k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 64k 192k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0xd 256k 4k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 260k 253k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x0 513k 13k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x55 526k 498k" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

2
tests/qemu-iotests/035
View File

@ -59,7 +59,7 @@ function generate_requests() {
done
}
generate_requests | $QEMU_IO $TEST_IMG | _filter_qemu_io |\
generate_requests | $QEMU_IO "$TEST_IMG" | _filter_qemu_io |\
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
echo

6
tests/qemu-iotests/036
View File

@ -53,15 +53,15 @@ IMGOPTS="compat=1.1"
echo === Create image with unknown autoclear feature bit ===
echo
_make_test_img 64M
./qcow2.py $TEST_IMG set-feature-bit autoclear 63
./qcow2.py $TEST_IMG dump-header
./qcow2.py "$TEST_IMG" set-feature-bit autoclear 63
./qcow2.py "$TEST_IMG" dump-header
echo
echo === Repair image ===
echo
_check_test_img -r all
./qcow2.py $TEST_IMG dump-header
./qcow2.py "$TEST_IMG" dump-header
# success, all done
echo "*** done"

60
tests/qemu-iotests/037
View File

@ -66,50 +66,50 @@ function backing_io()
done
}
backing_io 0 256 write | $QEMU_IO $TEST_IMG | _filter_qemu_io
backing_io 0 256 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G
_make_test_img -b "$TEST_IMG.base" 6G
echo
echo "== COW in a single cluster =="
$QEMU_IO -c "write -P 0x77 0 2k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 6k 2k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 9k 2k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x77 0 2k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 6k 2k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 9k 2k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 0 2k" $TEST_IMG | _filter_qemu_io
backing_io $((2 * 1024)) 8 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 6k 2k" $TEST_IMG | _filter_qemu_io
backing_io $((8 * 1024)) 2 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 9k 2k" $TEST_IMG | _filter_qemu_io
backing_io $((11 * 1024)) 2 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 0 2k" "$TEST_IMG" | _filter_qemu_io
backing_io $((2 * 1024)) 8 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 6k 2k" "$TEST_IMG" | _filter_qemu_io
backing_io $((8 * 1024)) 2 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 9k 2k" "$TEST_IMG" | _filter_qemu_io
backing_io $((11 * 1024)) 2 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo
echo "== COW in two-cluster allocations =="
$QEMU_IO -c "write -P 0x77 16k 6k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 26k 6k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 33k 5k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x77 16k 6k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 26k 6k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 33k 5k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 16k 6k" $TEST_IMG | _filter_qemu_io
backing_io $((22 * 1024)) 8 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 26k 6k" $TEST_IMG | _filter_qemu_io
backing_io $((32 * 1024)) 2 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 33k 5k" $TEST_IMG | _filter_qemu_io
backing_io $((38 * 1024)) 4 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 16k 6k" "$TEST_IMG" | _filter_qemu_io
backing_io $((22 * 1024)) 8 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 26k 6k" "$TEST_IMG" | _filter_qemu_io
backing_io $((32 * 1024)) 2 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 33k 5k" "$TEST_IMG" | _filter_qemu_io
backing_io $((38 * 1024)) 4 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo
echo "== COW in multi-cluster allocations =="
$QEMU_IO -c "write -P 0x77 48k 15k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 66k 14k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 83k 15k" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x77 48k 15k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x88 66k 14k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "write -P 0x99 83k 15k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 48k 15k" $TEST_IMG | _filter_qemu_io
backing_io $((63 * 1024)) 6 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 66k 14k" $TEST_IMG | _filter_qemu_io
backing_io $((80 * 1024)) 6 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 83k 15k" $TEST_IMG | _filter_qemu_io
backing_io $((98 * 1024)) 4 read | $QEMU_IO $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 48k 15k" "$TEST_IMG" | _filter_qemu_io
backing_io $((63 * 1024)) 6 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x88 66k 14k" "$TEST_IMG" | _filter_qemu_io
backing_io $((80 * 1024)) 6 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x99 83k 15k" "$TEST_IMG" | _filter_qemu_io
backing_io $((98 * 1024)) 4 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img

10
tests/qemu-iotests/038
View File

@ -66,11 +66,11 @@ function backing_io()
done
}
backing_io 0 256 write | $QEMU_IO $TEST_IMG | _filter_qemu_io
backing_io 0 256 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G
_make_test_img -b "$TEST_IMG.base" 6G
echo
echo "== Some concurrent requests touching the same cluster =="
@ -94,7 +94,7 @@ function overlay_io()
echo aio_write -P 0x90 4080k 80k
}
overlay_io | $QEMU_IO $TEST_IMG | _filter_qemu_io |\
overlay_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io |\
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' \
-e 's/qemu-io> //g' | paste - - | sort | tr '\t' '\n'
@ -124,7 +124,7 @@ function verify_io()
done
}
verify_io | $QEMU_IO $TEST_IMG | _filter_qemu_io
verify_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img

28
tests/qemu-iotests/039
View File

@ -54,10 +54,10 @@ echo "== Checking that image is clean on shutdown =="
IMGOPTS="compat=1.1,lazy_refcounts=on"
_make_test_img $size
$QEMU_IO -c "write -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x5a 0 512" ""$TEST_IMG"" | _filter_qemu_io
# The dirty bit must not be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features
./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
_check_test_img
echo
@ -68,20 +68,20 @@ _make_test_img $size
old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3)
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" "$TEST_IMG" | _filter_qemu_io
ulimit -c "$old_ulimit"
# The dirty bit must be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features
./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
_check_test_img
echo
echo "== Read-only access must still work =="
$QEMU_IO -r -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -r -c "read -P 0x5a 0 512" "$TEST_IMG" | _filter_qemu_io
# The dirty bit must be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features
./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
echo
echo "== Repairing the image file must succeed =="
@ -89,12 +89,12 @@ echo "== Repairing the image file must succeed =="
_check_test_img -r all
# The dirty bit must not be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features
./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
echo
echo "== Data should still be accessible after repair =="
$QEMU_IO -c "read -P 0x5a 0 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0x5a 0 512" "$TEST_IMG" | _filter_qemu_io
echo
echo "== Opening a dirty image read/write should repair it =="
@ -104,16 +104,16 @@ _make_test_img $size
old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3)
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" "$TEST_IMG" | _filter_qemu_io
ulimit -c "$old_ulimit"
# The dirty bit must be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features
./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
$QEMU_IO -c "write 0 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write 0 512" "$TEST_IMG" | _filter_qemu_io
# The dirty bit must not be set
./qcow2.py $TEST_IMG dump-header | grep incompatible_features
./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
echo
echo "== Creating an image file with lazy_refcounts=off =="
@ -123,11 +123,11 @@ _make_test_img $size
old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3)
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "write -P 0x5a 0 512" -c "abort" "$TEST_IMG" | _filter_qemu_io
ulimit -c "$old_ulimit"
# The dirty bit must not be set since lazy_refcounts=off
./qcow2.py $TEST_IMG dump-header | grep incompatible_features
./qcow2.py "$TEST_IMG" dump-header | grep incompatible_features
_check_test_img
# success, all done

10
tests/qemu-iotests/042
View File

@ -48,27 +48,27 @@ echo "== Creating zero size image =="
_make_test_img 0
_check_test_img
mv $TEST_IMG $TEST_IMG.orig
mv "$TEST_IMG" "$TEST_IMG.orig"
echo
echo "== Converting the image =="
$QEMU_IMG convert -O $IMGFMT $TEST_IMG.orig $TEST_IMG
$QEMU_IMG convert -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
_check_test_img
echo
echo "== Converting the image, compressed =="
if [ "$IMGFMT" == "qcow2" ]; then
$QEMU_IMG convert -c -O $IMGFMT $TEST_IMG.orig $TEST_IMG
$QEMU_IMG convert -c -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
fi
_check_test_img
echo
echo "== Rebasing the image =="
$QEMU_IMG rebase -u -b $TEST_IMG.orig $TEST_IMG
$QEMU_IMG rebase -b $TEST_IMG.orig $TEST_IMG
$QEMU_IMG rebase -u -b "$TEST_IMG.orig" "$TEST_IMG"
$QEMU_IMG rebase -b "$TEST_IMG.orig" "$TEST_IMG"
_check_test_img
# success, all done

32
tests/qemu-iotests/043
View File

@ -31,7 +31,7 @@ status=1 # failure is the default!
_cleanup()
{
_cleanup_test_img
rm -f $TEST_IMG.[123].base
rm -f "$TEST_IMG".[123].base
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -47,39 +47,39 @@ _supported_os Linux
size=128M
_make_test_img $size
$QEMU_IMG rebase -u -b $TEST_IMG $TEST_IMG
$QEMU_IMG rebase -u -b "$TEST_IMG" "$TEST_IMG"
echo
echo "== backing file references self =="
_img_info --backing-chain
_make_test_img $size
mv $TEST_IMG $TEST_IMG.base
_make_test_img -b $TEST_IMG.base $size
$QEMU_IMG rebase -u -b $TEST_IMG $TEST_IMG.base
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b "$TEST_IMG.base" $size
$QEMU_IMG rebase -u -b "$TEST_IMG" "$TEST_IMG.base"
echo
echo "== parent references self =="
_img_info --backing-chain
_make_test_img $size
mv $TEST_IMG $TEST_IMG.1.base
_make_test_img -b $TEST_IMG.1.base $size
mv $TEST_IMG $TEST_IMG.2.base
_make_test_img -b $TEST_IMG.2.base $size
mv $TEST_IMG $TEST_IMG.3.base
_make_test_img -b $TEST_IMG.3.base $size
$QEMU_IMG rebase -u -b $TEST_IMG.2.base $TEST_IMG.1.base
mv "$TEST_IMG" "$TEST_IMG.1.base"
_make_test_img -b "$TEST_IMG.1.base" $size
mv "$TEST_IMG" "$TEST_IMG.2.base"
_make_test_img -b "$TEST_IMG.2.base" $size
mv "$TEST_IMG" "$TEST_IMG.3.base"
_make_test_img -b "$TEST_IMG.3.base" $size
$QEMU_IMG rebase -u -b "$TEST_IMG.2.base" "$TEST_IMG.1.base"
echo
echo "== ancestor references another ancestor =="
_img_info --backing-chain
_make_test_img $size
mv $TEST_IMG $TEST_IMG.1.base
_make_test_img -b $TEST_IMG.1.base $size
mv $TEST_IMG $TEST_IMG.2.base
_make_test_img -b $TEST_IMG.2.base $size
mv "$TEST_IMG" "$TEST_IMG.1.base"
_make_test_img -b "$TEST_IMG.1.base" $size
mv "$TEST_IMG" "$TEST_IMG.2.base"
_make_test_img -b "$TEST_IMG.2.base" $size
echo
echo "== finite chain of length 3 (human) =="

10
tests/qemu-iotests/046
View File

@ -66,11 +66,11 @@ function backing_io()
done
}
backing_io 0 32 write | $QEMU_IO $TEST_IMG | _filter_qemu_io
backing_io 0 32 write | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.base
mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base 6G
_make_test_img -b "$TEST_IMG.base" 6G
echo
echo "== Some concurrent requests touching the same cluster =="
@ -185,7 +185,7 @@ aio_flush
EOF
}
overlay_io | $QEMU_IO blkdebug::$TEST_IMG | _filter_qemu_io |\
overlay_io | $QEMU_IO blkdebug::"$TEST_IMG" | _filter_qemu_io |\
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
echo
@ -252,7 +252,7 @@ function verify_io()
echo read -P 17 0x11c000 0x4000
}
verify_io | $QEMU_IO $TEST_IMG | _filter_qemu_io
verify_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img

2
tests/qemu-iotests/047
View File

@ -66,7 +66,7 @@ read -P 0x55 1M 128k
EOF
}
qemu_io_cmds | $QEMU_IO $TEST_IMG | _filter_qemu_io
qemu_io_cmds | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img
# success, all done

8
tests/qemu-iotests/048
View File

@ -31,13 +31,13 @@ _cleanup()
{
echo "Cleanup"
_cleanup_test_img
rm ${TEST_IMG2}
rm "${TEST_IMG2}"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
_compare()
{
$QEMU_IMG compare "$@" $TEST_IMG ${TEST_IMG2}
$QEMU_IMG compare "$@" "$TEST_IMG" "${TEST_IMG2}"
echo $?
}
@ -59,12 +59,12 @@ _make_test_img $size
io_pattern write 524288 $CLUSTER_SIZE $CLUSTER_SIZE 4 45
# Compare identical images
cp $TEST_IMG ${TEST_IMG2}
cp "$TEST_IMG" "${TEST_IMG2}"
_compare
_compare -q
# Compare images with different size
$QEMU_IMG resize $TEST_IMG +512M
$QEMU_IMG resize "$TEST_IMG" +512M
_compare
_compare -s

36
tests/qemu-iotests/049
View File

@ -63,13 +63,13 @@ sizes+="1024.0 1024.0b 1.5k 1.5K 1.5M 1.5G 1.5T"
echo "== 1. Traditional size parameter =="
echo
for s in $sizes; do
test_qemu_img create -f $IMGFMT $TEST_IMG $s
test_qemu_img create -f $IMGFMT "$TEST_IMG" $s
done
echo "== 2. Specifying size via -o =="
echo
for s in $sizes; do
test_qemu_img create -f $IMGFMT -o size=$s $TEST_IMG
test_qemu_img create -f $IMGFMT -o size=$s "$TEST_IMG"
done
echo "== 3. Invalid sizes =="
@ -77,8 +77,8 @@ echo
sizes="-1024 -1k 1kilobyte foobar"
for s in $sizes; do
test_qemu_img create -f $IMGFMT $TEST_IMG -- $s
test_qemu_img create -f $IMGFMT -o size=$s $TEST_IMG
test_qemu_img create -f $IMGFMT "$TEST_IMG" -- $s
test_qemu_img create -f $IMGFMT -o size=$s "$TEST_IMG"
done
echo "== Check correct interpretation of suffixes for cluster size =="
@ -87,35 +87,35 @@ sizes="1024 1024b 1k 1K 1M "
sizes+="1024.0 1024.0b 0.5k 0.5K 0.5M"
for s in $sizes; do
test_qemu_img create -f $IMGFMT -o cluster_size=$s $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o cluster_size=$s "$TEST_IMG" 64M
done
echo "== Check compat level option =="
echo
test_qemu_img create -f $IMGFMT -o compat=0.10 $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=1.1 $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=0.10 "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=1.1 "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=0.42 $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=foobar $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=0.42 "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=foobar "$TEST_IMG" 64M
echo "== Check preallocation option =="
echo
test_qemu_img create -f $IMGFMT -o preallocation=off $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o preallocation=metadata $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o preallocation=1234 $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o preallocation=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o preallocation=metadata "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o preallocation=1234 "$TEST_IMG" 64M
echo "== Check encryption option =="
echo
test_qemu_img create -f $IMGFMT -o encryption=off $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o encryption=on $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o encryption=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o encryption=on "$TEST_IMG" 64M
echo "== Check lazy_refcounts option (only with v3) =="
echo
test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=off $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=on $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=1.1,lazy_refcounts=on "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=off $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=on $TEST_IMG 64M
test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=off "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o compat=0.10,lazy_refcounts=on "$TEST_IMG" 64M
# success, all done
echo "*** done"

20
tests/qemu-iotests/050
View File

@ -31,8 +31,8 @@ status=1 # failure is the default!
_cleanup()
{
_cleanup_test_img
rm -f $TEST_IMG.old
rm -f $TEST_IMG.new
rm -f "$TEST_IMG.old"
rm -f "$TEST_IMG.new"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -53,21 +53,21 @@ echo "== Creating images =="
size=10M
_make_test_img $size
$QEMU_IO -c "write -P 0x40 0 1048576" $TEST_IMG | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.old
$QEMU_IO -c "write -P 0x40 0 1048576" "$TEST_IMG" | _filter_qemu_io
mv "$TEST_IMG" "$TEST_IMG.old"
_make_test_img $size
$QEMU_IO -c "write -P 0x5a 0 1048576" $TEST_IMG | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.new
$QEMU_IO -c "write -P 0x5a 0 1048576" "$TEST_IMG" | _filter_qemu_io
mv "$TEST_IMG" "$TEST_IMG.new"
_make_test_img -b $TEST_IMG.old $size
$QEMU_IO -c "write -z 0 1048576" $TEST_IMG | _filter_qemu_io
_make_test_img -b "$TEST_IMG.old" $size
$QEMU_IO -c "write -z 0 1048576" "$TEST_IMG" | _filter_qemu_io
echo
echo "== Rebasing the image =="
$QEMU_IMG rebase -b $TEST_IMG.new $TEST_IMG
$QEMU_IO -c "read -P 0x00 0 1048576" $TEST_IMG | _filter_qemu_io
$QEMU_IMG rebase -b "$TEST_IMG.new" "$TEST_IMG"
$QEMU_IO -c "read -P 0x00 0 1048576" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

50
tests/qemu-iotests/051
View File

@ -72,10 +72,10 @@ echo
echo === Unknown option ===
echo
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt=
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt=on
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt=1234
run_qemu -drive file=$TEST_IMG,format=qcow2,unknown_opt=foo
run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=
run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=on
run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=1234
run_qemu -drive file="$TEST_IMG",format=qcow2,unknown_opt=foo
echo
echo === Overriding backing file ===
@ -87,11 +87,11 @@ echo
echo === Enable and disable lazy refcounting on the command line, plus some invalid values ===
echo
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=on
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=off
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=42
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=foo
run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on
run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off
run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=
run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=42
run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=foo
echo
@ -100,8 +100,8 @@ echo
_make_test_img -ocompat=0.10 $size
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=on
run_qemu -drive file=$TEST_IMG,format=qcow2,lazy-refcounts=off
run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=on
run_qemu -drive file="$TEST_IMG",format=qcow2,lazy-refcounts=off
echo
echo === No medium ===
@ -127,21 +127,21 @@ echo
echo === Read-only ===
echo
run_qemu -drive file=$TEST_IMG,if=floppy,readonly=on
run_qemu -drive file=$TEST_IMG,if=ide,media=cdrom,readonly=on
run_qemu -drive file=$TEST_IMG,if=scsi,media=cdrom,readonly=on
run_qemu -drive file="$TEST_IMG",if=floppy,readonly=on
run_qemu -drive file="$TEST_IMG",if=ide,media=cdrom,readonly=on
run_qemu -drive file="$TEST_IMG",if=scsi,media=cdrom,readonly=on
run_qemu -drive file=$TEST_IMG,if=ide,readonly=on
run_qemu -drive file=$TEST_IMG,if=virtio,readonly=on
run_qemu -drive file=$TEST_IMG,if=scsi,readonly=on
run_qemu -drive file="$TEST_IMG",if=ide,readonly=on
run_qemu -drive file="$TEST_IMG",if=virtio,readonly=on
run_qemu -drive file="$TEST_IMG",if=scsi,readonly=on
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device ide-cd,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-cd,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-cd,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-cd,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device ide-drive,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device ide-hd,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-disk,drive=disk
run_qemu -drive file=$TEST_IMG,if=none,id=disk,readonly=on -device lsi53c895a -device scsi-hd,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-drive,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device ide-hd,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-disk,drive=disk
run_qemu -drive file="$TEST_IMG",if=none,id=disk,readonly=on -device lsi53c895a -device scsi-hd,drive=disk
echo
echo === Cache modes ===
@ -161,8 +161,8 @@ echo
echo === Specifying the protocol layer ===
echo
run_qemu -drive file=$TEST_IMG,file.driver=file
run_qemu -drive file=$TEST_IMG,file.driver=qcow2
run_qemu -drive file="$TEST_IMG",file.driver=file
run_qemu -drive file="$TEST_IMG",file.driver=qcow2
echo
echo === Parsing protocol from file name ===

6
tests/qemu-iotests/052
View File

@ -49,12 +49,12 @@ _make_test_img $size
echo
echo "== reading whole image =="
$QEMU_IO -s -c "read 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -s -c "read 0 $size" "$TEST_IMG" | _filter_qemu_io
echo
echo "== writing whole image does not modify image =="
$QEMU_IO -s -c "write -P 0xa 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P 0 0 $size" $TEST_IMG | _filter_qemu_io
$QEMU_IO -s -c "write -P 0xa 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0 0 $size" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

10
tests/qemu-iotests/053
View File

@ -30,7 +30,7 @@ status=1 # failure is the default!
_cleanup()
{
rm -f $TEST_IMG.orig
rm -f "$TEST_IMG.orig"
_cleanup_test_img
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -47,13 +47,13 @@ echo
echo "== Creating single sector image =="
_make_test_img 512
$QEMU_IO -c "write -P0xa 0 512" $TEST_IMG | _filter_qemu_io
mv $TEST_IMG $TEST_IMG.orig
$QEMU_IO -c "write -P0xa 0 512" "$TEST_IMG" | _filter_qemu_io
mv "$TEST_IMG" "$TEST_IMG.orig"
echo
echo "== Converting the image, compressed =="
$QEMU_IMG convert -c -O $IMGFMT $TEST_IMG.orig $TEST_IMG
$QEMU_IMG convert -c -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
_check_test_img
echo
@ -64,7 +64,7 @@ _img_info | grep '^virtual size:'
echo
echo "== Verifying the compressed image =="
$QEMU_IO -c "read -P0xa 0 512" $TEST_IMG | _filter_qemu_io
$QEMU_IO -c "read -P0xa 0 512" "$TEST_IMG" | _filter_qemu_io
# success, all done
echo "*** done"

2
tests/qemu-iotests/054
View File

@ -49,7 +49,7 @@ _make_test_img $((1024*1024))T
echo
echo "creating too large image (1 EB) using qcow2.py"
_make_test_img 4G
./qcow2.py $TEST_IMG set-header size $((1024 ** 6))
./qcow2.py "$TEST_IMG" set-header size $((1024 ** 6))
_check_test_img
# success, all done

6
tests/qemu-iotests/059
View File

@ -51,20 +51,20 @@ echo "=== Testing invalid granularity ==="
echo
_make_test_img 64M
poke_file "$TEST_IMG" "$granularity_offset" "\xff\xff\xff\xff\xff\xff\xff\xff"
{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir
{ $QEMU_IO -c "read 0 512" "$TEST_IMG"; } 2>&1 | _filter_qemu_io | _filter_testdir
echo "=== Testing too big L2 table size ==="
echo
_make_test_img 64M
poke_file "$TEST_IMG" "$grain_table_size_offset" "\xff\xff\xff\xff"
{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir
{ $QEMU_IO -c "read 0 512" "$TEST_IMG"; } 2>&1 | _filter_qemu_io | _filter_testdir
echo "=== Testing too big L1 table size ==="
echo
_make_test_img 64M
poke_file "$TEST_IMG" "$capacity_offset" "\xff\xff\xff\xff"
poke_file "$TEST_IMG" "$grain_table_size_offset" "\x01\x00\x00\x00"
{ $QEMU_IO -c "read 0 512" $TEST_IMG; } 2>&1 | _filter_qemu_io | _filter_testdir
{ $QEMU_IO -c "read 0 512" "$TEST_IMG"; } 2>&1 | _filter_qemu_io | _filter_testdir
echo "=== Testing monolithicFlat creation and opening ==="
echo

28
tests/qemu-iotests/063
View File

@ -32,7 +32,7 @@ status=1 # failure is the default!
_cleanup()
{
_cleanup_test_img
rm -f $TEST_IMG.orig $TEST_IMG.raw $TEST_IMG.raw2
rm -f "$TEST_IMG.orig" "$TEST_IMG.raw" "$TEST_IMG.raw2"
}
trap "_cleanup; exit \$status" 0 1 2 3 15
@ -49,47 +49,47 @@ _make_test_img 4M
echo "== Testing conversion with -n fails with no target file =="
# check .orig file does not exist
rm -f $TEST_IMG.orig
if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n $TEST_IMG $TEST_IMG.orig >/dev/null 2>&1; then
rm -f "$TEST_IMG.orig"
if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG.orig" >/dev/null 2>&1; then
exit 1
fi
echo "== Testing conversion with -n succeeds with a target file =="
rm -f $TEST_IMG.orig
cp $TEST_IMG $TEST_IMG.orig
if ! $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n $TEST_IMG $TEST_IMG.orig ; then
rm -f "$TEST_IMG.orig"
cp "$TEST_IMG" "$TEST_IMG.orig"
if ! $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG" "$TEST_IMG.orig" ; then
exit 1
fi
echo "== Testing conversion to raw is the same after conversion with -n =="
# compare the raw files
if ! $QEMU_IMG convert -f $IMGFMT -O raw $TEST_IMG $TEST_IMG.raw1 ; then
if ! $QEMU_IMG convert -f $IMGFMT -O raw "$TEST_IMG" "$TEST_IMG.raw1" ; then
exit 1
fi
if ! $QEMU_IMG convert -f $IMGFMT -O raw $TEST_IMG.orig $TEST_IMG.raw2 ; then
if ! $QEMU_IMG convert -f $IMGFMT -O raw "$TEST_IMG.orig" "$TEST_IMG.raw2" ; then
exit 1
fi
if ! cmp $TEST_IMG.raw1 $TEST_IMG.raw2 ; then
if ! cmp "$TEST_IMG.raw1" "$TEST_IMG.raw2" ; then
exit 1
fi
echo "== Testing conversion back to original format =="
if ! $QEMU_IMG convert -f raw -O $IMGFMT -n $TEST_IMG.raw2 $TEST_IMG ; then
if ! $QEMU_IMG convert -f raw -O $IMGFMT -n "$TEST_IMG.raw2" "$TEST_IMG" ; then
exit 1
fi
_check_test_img
echo "== Testing conversion to a smaller file fails =="
rm -f $TEST_IMG.orig
mv $TEST_IMG $TEST_IMG.orig
rm -f "$TEST_IMG.orig"
mv "$TEST_IMG" "$TEST_IMG.orig"
_make_test_img 2M
if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n $TEST_IMG.orig $TEST_IMG >/dev/null 2>&1; then
if $QEMU_IMG convert -f $IMGFMT -O $IMGFMT -n "$TEST_IMG.orig" "$TEST_IMG" >/dev/null 2>&1; then
exit 1
fi
rm -f $TEST_IMG.orig $TEST_IMG.raw $TEST_IMG.raw2
rm -f "$TEST_IMG.orig" "$TEST_IMG.raw" "$TEST_IMG.raw2"
echo "*** done"
rm -f $seq.full

16
tests/qemu-iotests/common.rc
View File

@ -164,12 +164,12 @@ _cleanup_test_img()
nbd)
kill $QEMU_NBD_PID
rm -f $TEST_IMG_FILE
rm -f "$TEST_IMG_FILE"
;;
file)
rm -f $TEST_DIR/t.$IMGFMT
rm -f $TEST_DIR/t.$IMGFMT.orig
rm -f $TEST_DIR/t.$IMGFMT.base
rm -f "$TEST_DIR/t.$IMGFMT"
rm -f "$TEST_DIR/t.$IMGFMT.orig"
rm -f "$TEST_DIR/t.$IMGFMT.base"
if [ -n "$SAMPLE_IMG_FILE" ]
then
rm -f "$TEST_DIR/$SAMPLE_IMG_FILE"
@ -177,11 +177,11 @@ _cleanup_test_img()
;;
rbd)
rbd rm $TEST_DIR/t.$IMGFMT > /dev/null
rbd rm "$TEST_DIR/t.$IMGFMT" > /dev/null
;;
sheepdog)
collie vdi delete $TEST_DIR/t.$IMGFMT
collie vdi delete "$TEST_DIR/t.$IMGFMT"
;;
esac
@ -189,7 +189,7 @@ _cleanup_test_img()
_check_test_img()
{
$QEMU_IMG check "$@" -f $IMGFMT $TEST_IMG 2>&1 | _filter_testdir | \
$QEMU_IMG check "$@" -f $IMGFMT "$TEST_IMG" 2>&1 | _filter_testdir | \
sed -e '/allocated.*fragmented.*compressed clusters/d' \
-e 's/qemu-img: This image format does not support checks/No errors were found on the image./' \
-e '/Image end offset: [0-9]\+/d'
@ -197,7 +197,7 @@ _check_test_img()
_img_info()
{
$QEMU_IMG info "$@" $TEST_IMG 2>&1 | \
$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" \