OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity

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

Browse Source 
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
echo "== reading whole image ==" 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
echo "== rewriting whole image ==" 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
echo "== verify pattern ==" 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 # success, all done

36
tests/qemu-iotests/002
View File

@ -48,36 +48,36 @@ _make_test_img $size
echo echo
echo "== reading whole image ==" 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
echo "== rewriting whole image ==" 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
echo "== verify pattern ==" 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
echo "unaligned pwrite" echo "unaligned pwrite"
$QEMU_IO -c 'write -pP 0xab 66 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 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 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 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 0xaf 256k 42' "$TEST_IMG" | _filter_qemu_io
echo echo
echo "verify pattern" echo "verify pattern"
$QEMU_IO -c 'read -pP 0xa 0 66' $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 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 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 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 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 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 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 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 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 262186 470' "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

10
tests/qemu-iotests/003
View File

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

24
tests/qemu-iotests/004
View File

@ -51,51 +51,51 @@ _make_test_img $size
echo echo
echo "write before image boundary" 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
echo "write into image boundary" 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
echo "write at image boundary" echo "write at image boundary"
$QEMU_IO -c "write $size 4096" $TEST_IMG $QEMU_IO -c "write $size 4096" "$TEST_IMG"
echo echo
echo "write past image boundary" 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
echo "pwrite past image boundary" 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
echo "writev past image boundary" 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
echo "read before image boundary" 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
echo "read into image boundary" 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
echo "read at image boundary" echo "read at image boundary"
$QEMU_IO -c "read $size 4096" $TEST_IMG $QEMU_IO -c "read $size 4096" "$TEST_IMG"
echo echo
echo "read past image boundary" 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
echo "pread past image boundary" 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
echo "readv past image boundary" 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 # success, all done

4
tests/qemu-iotests/005
View File

@ -61,11 +61,11 @@ _make_test_img 5000G
echo echo
echo "small read" 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
echo "small write" 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 # success, all done
echo "*** 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 for i in `seq 1 10`; do
echo "savevm $i" 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 savevm test-$i
quit quit
EOF EOF

6
tests/qemu-iotests/008
View File

@ -48,15 +48,15 @@ _make_test_img $size
echo echo
echo "== reading whole image ==" 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
echo "== rewriting whole image ==" 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
echo "== verify pattern ==" 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 # success, all done

2
tests/qemu-iotests/009
View File

@ -57,7 +57,7 @@ $QEMU_IO \
-c "write 4k 4k" \ -c "write 4k 4k" \
-c "write 9M 4k" \ -c "write 9M 4k" \
-c "read -P 65 -s 4k -l 4k 2044k 8k" \ -c "read -P 65 -s 4k -l 4k 2044k 8k" \
$TEST_IMG | _filter_qemu_io "$TEST_IMG" | _filter_qemu_io
echo echo
echo "checking image for errors" 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 165 2044k 4k" \
-c "write -P 99 8M 4k" \ -c "write -P 99 8M 4k" \
-c "read -P 165 2044k 8k" \ -c "read -P 165 2044k 8k" \
$TEST_IMG | _filter_qemu_io "$TEST_IMG" | _filter_qemu_io
echo echo
echo "checking image for errors" 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 # 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 # may re-order the two aio requests. We only want to make sure the
# filesystem isn't corrupted afterwards anyway. # 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 | \ _filter_qemu_io | \
sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
done done

4
tests/qemu-iotests/012
View File

@ -50,11 +50,11 @@ _make_test_img $size
echo echo
echo "== mark image read-only" echo "== mark image read-only"
chmod a-w $TEST_IMG chmod a-w "$TEST_IMG"
echo echo
echo "== read from read-only image" 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 # success, all done
echo "*** done" echo "*** done"

4
tests/qemu-iotests/013
View File

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

2
tests/qemu-iotests/014
View File

@ -61,7 +61,7 @@ done
# With snapshots # With snapshots
for i in `seq 1 3`; do 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 for offset in $TEST_OFFSETS; do
echo With snapshot test$i, offset $offset echo With snapshot test$i, offset $offset
for op in $TEST_OPS; do 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 # Create two snapshots which fill the image with two different patterns
echo "creating first snapshot" echo "creating first snapshot"
$QEMU_IO -c "aio_write -P 123 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_write -P 123 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -c snap1 $TEST_IMG $QEMU_IMG snapshot -c snap1 "$TEST_IMG"
echo "creating second snapshot" echo "creating second snapshot"
$QEMU_IO -c "aio_write -P 165 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_write -P 165 0 $size" "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -c snap2 $TEST_IMG $QEMU_IMG snapshot -c snap2 "$TEST_IMG"
# Now check the pattern # Now check the pattern
echo "checking first snapshot" echo "checking first snapshot"
$QEMU_IMG snapshot -a snap1 $TEST_IMG $QEMU_IMG snapshot -a snap1 "$TEST_IMG"
$QEMU_IO -c "aio_read -P 123 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_read -P 123 0 $size" "$TEST_IMG" | _filter_qemu_io
echo "checking second snapshot" echo "checking second snapshot"
$QEMU_IMG snapshot -a snap2 $TEST_IMG $QEMU_IMG snapshot -a snap2 "$TEST_IMG"
$QEMU_IO -c "aio_read -P 165 0 $size" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "aio_read -P 165 0 $size" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "checking image for errors" echo "checking image for errors"

12
tests/qemu-iotests/016
View File

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

6
tests/qemu-iotests/018
View File

@ -66,7 +66,7 @@ echo "Creating test image with backing file"
echo echo
TEST_IMG=$TEST_IMG_SAVE 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 "Filling test image"
echo echo
@ -80,8 +80,8 @@ for offset in $TEST_OFFSETS; do
done done
_check_test_img _check_test_img
mv $TEST_IMG $TEST_IMG.orig mv "$TEST_IMG" "$TEST_IMG.orig"
$QEMU_IMG convert -O $IMGFMT $TEST_IMG.orig $TEST_IMG $QEMU_IMG convert -O $IMGFMT "$TEST_IMG.orig" "$TEST_IMG"
echo "Reading" echo "Reading"
echo echo

12
tests/qemu-iotests/019
View File

@ -33,8 +33,8 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_IMG.base rm -f "$TEST_IMG.base"
rm -f $TEST_IMG.orig rm -f "$TEST_IMG.orig"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -68,8 +68,8 @@ _check_test_img
echo "Creating test image with backing file" echo "Creating test image with backing file"
echo echo
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 "Filling test image" echo "Filling test image"
echo echo
@ -83,7 +83,7 @@ for offset in $TEST_OFFSETS; do
done done
_check_test_img _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
echo Testing conversion with $backing_option | _filter_testdir | _filter_imgfmt echo Testing conversion with $backing_option | _filter_testdir | _filter_imgfmt
echo 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 "Checking if backing clusters are allocated when they shouldn't"
echo echo

12
tests/qemu-iotests/020
View File

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

2
tests/qemu-iotests/021
View File

@ -53,7 +53,7 @@ for pattern in $INVALID_PATTERNS; do
for op in $TEST_OPS; do for op in $TEST_OPS; do
echo echo
echo "== testing $op -P $pattern ==" 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
done done

4
tests/qemu-iotests/023
View File

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

12
tests/qemu-iotests/024
View File

@ -31,8 +31,8 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm -f $TEST_DIR/t.$IMGFMT.base_old rm -f "$TEST_DIR/t.$IMGFMT.base_old"
rm -f $TEST_DIR/t.$IMGFMT.base_new rm -f "$TEST_DIR/t.$IMGFMT.base_new"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
@ -62,19 +62,19 @@ echo
_make_test_img 1G _make_test_img 1G
io_pattern writev 0 $CLUSTER_SIZE $((2 * CLUSTER_SIZE)) 8 0x11 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 "Creating new backing file"
echo echo
_make_test_img 1G _make_test_img 1G
io_pattern writev 0 $((2 * CLUSTER_SIZE)) $((4 * CLUSTER_SIZE)) 4 0x22 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 "Creating COW image"
echo 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 0 $((4 * CLUSTER_SIZE)) 0 1 0x33
io_pattern writev $((8 * CLUSTER_SIZE)) $((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
echo Rebase and test again echo Rebase and test again
echo 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 $((0 * CLUSTER_SIZE)) $CLUSTER_SIZE 0 1 0x33
io_pattern readv $((1 * 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 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
echo "=== Resizing image" echo "=== Resizing image"
$QEMU_IO $TEST_IMG <<EOF $QEMU_IO "$TEST_IMG" <<EOF
length length
truncate $big_size truncate $big_size
length length
@ -65,7 +65,7 @@ _check_test_img
echo echo
echo "=== Verifying image size after reopen" echo "=== Verifying image size after reopen"
$QEMU_IO -c "length" $TEST_IMG $QEMU_IO -c "length" "$TEST_IMG"
echo echo
echo "=== Verifying resized image" echo "=== Verifying resized image"

20
tests/qemu-iotests/026
View File

@ -31,7 +31,7 @@ status=1 # failure is the default!
_cleanup() _cleanup()
{ {
_cleanup_test_img _cleanup_test_img
rm $TEST_DIR/blkdebug.conf rm "$TEST_DIR/blkdebug.conf"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 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 once in on off; do
for vmstate in "" "-b"; do for vmstate in "" "-b"; do
cat > $TEST_DIR/blkdebug.conf <<EOF cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error] [inject-error]
event = "$event" event = "$event"
errno = "$errno" 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 # We want to catch a simple L2 update, not the allocation of the first L2 table
if [ "$event" == "l2_update" ]; then 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 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 # 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 # Reads are another path to trigger l2_load, so do a read, too
if [ "$event" == "l2_load" ]; then if [ "$event" == "l2_load" ]; then
$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
$QEMU_IO -c "read $vmstate 0 128k " $BLKDBG_TEST_IMG | _filter_qemu_io $QEMU_IO -c "read $vmstate 0 128k " "$BLKDBG_TEST_IMG" | _filter_qemu_io
fi fi
_check_test_img 2>&1 | grep -v "refcount=1 reference=0" _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 once in on off; do
for vmstate in "" "-b"; do for vmstate in "" "-b"; do
cat > $TEST_DIR/blkdebug.conf <<EOF cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error] [inject-error]
event = "$event" event = "$event"
errno = "$errno" errno = "$errno"
@ -145,7 +145,7 @@ _make_test_img 1G
echo echo
echo "Event: $event; errno: $errno; imm: $imm; once: $once; write $vmstate" 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" _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 imm in off; do
for once in on off; do for once in on off; do
cat > $TEST_DIR/blkdebug.conf <<EOF cat > "$TEST_DIR/blkdebug.conf" <<EOF
[inject-error] [inject-error]
event = "$event" event = "$event"
errno = "$errno" errno = "$errno"
@ -184,7 +184,7 @@ _make_test_img 1G
echo echo
echo "Event: $event; errno: $errno; imm: $imm; once: $once" 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" _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. # Otherwise an L2 table could get in the way after the data cluster.
echo echo
echo "== writing first cluster to populate metadata ==" 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
echo "== writing at sub-cluster granularity ==" 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
echo "== verify pattern ==" 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
echo "== verify zeroes before sub-cluster pattern ==" 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
echo "== verify zeroes after sub-cluster pattern ==" 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 # success, all done
echo "*** 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 "Creating test image with backing file"
echo echo
mv $TEST_IMG $TEST_IMG.base mv "$TEST_IMG" "$TEST_IMG.base"
_make_test_img -b $TEST_IMG.base $image_size _make_test_img -b "$TEST_IMG.base" $image_size
echo "Filling test image" echo "Filling test image"
echo echo
@ -97,7 +97,7 @@ io_zero readv $(( offset + 32 * 1024 )) 512 1024 32
_check_test_img _check_test_img
# Rebase it on top of its base image # 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 _check_test_img

12
tests/qemu-iotests/029
View File

@ -47,16 +47,16 @@ _supported_os Linux
CLUSTER_SIZE=65536 CLUSTER_SIZE=65536
_make_test_img 64M _make_test_img 64M
$QEMU_IMG snapshot -c foo $TEST_IMG $QEMU_IMG snapshot -c foo "$TEST_IMG"
$QEMU_IO -c 'write -b 0 4k' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -b 0 4k' "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -a foo $TEST_IMG $QEMU_IMG snapshot -a foo "$TEST_IMG"
_check_test_img _check_test_img
CLUSTER_SIZE=1024 CLUSTER_SIZE=1024
_make_test_img 16M _make_test_img 16M
$QEMU_IMG snapshot -c foo $TEST_IMG $QEMU_IMG snapshot -c foo "$TEST_IMG"
$QEMU_IO -c 'write -b 0 4M' $TEST_IMG | _filter_qemu_io $QEMU_IO -c 'write -b 0 4M' "$TEST_IMG" | _filter_qemu_io
$QEMU_IMG snapshot -a foo $TEST_IMG $QEMU_IMG snapshot -a foo "$TEST_IMG"
_check_test_img _check_test_img
# success, all done # 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 === Create image with unknown header extension ===
echo echo
_make_test_img 64M _make_test_img 64M
./qcow2.py $TEST_IMG add-header-ext 0x12345678 "This is a test header extension" ./qcow2.py "$TEST_IMG" add-header-ext 0x12345678 "This is a test header extension"
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
_check_test_img _check_test_img
echo echo
echo === Rewrite header with no backing file === echo === Rewrite header with no backing file ===
echo echo
$QEMU_IMG rebase -u -b "" $TEST_IMG $QEMU_IMG rebase -u -b "" "$TEST_IMG"
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
_check_test_img _check_test_img
echo echo
echo === Add a backing file and format === echo === Add a backing file and format ===
echo echo
$QEMU_IMG rebase -u -b "/some/backing/file/path" -F host_device $TEST_IMG $QEMU_IMG rebase -u -b "/some/backing/file/path" -F host_device "$TEST_IMG"
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
done done
# success, all 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 # 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 # 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
echo === AIO request during close === echo === AIO request during close ===
echo 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 _check_test_img
# success, all done # success, all done

18
tests/qemu-iotests/033
View File

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

64
tests/qemu-iotests/034
View File

@ -49,63 +49,63 @@ echo
echo "== creating backing file for COW tests ==" echo "== creating backing file for COW tests =="
_make_test_img $size _make_test_img $size
$QEMU_IO -c "write -P 0x55 0 1M" $TEST_IMG | _filter_qemu_io $QEMU_IO -c "write -P 0x55 0 1M" "$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
echo "== zero write with backing file ==" echo "== zero write with backing file =="
$QEMU_IO -c "write -z 64k 192k" $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 $QEMU_IO -c "write -z 513k 13k" "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img
echo echo
echo "== verifying patterns (3) ==" echo "== verifying patterns (3) =="
$QEMU_IO -c "read -P 0x55 0 64k" $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 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 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 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 526k 498k" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== overwriting zero cluster ==" echo "== overwriting zero cluster =="
$QEMU_IO -c "write -P 0xa 60k 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 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 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 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 0xe 248k 8k" "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img
echo echo
echo "== verifying patterns (4) ==" echo "== verifying patterns (4) =="
$QEMU_IO -c "read -P 0x55 0 60k" $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 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 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 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 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 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 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 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 260k 64k" "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== re-zeroing overwritten area ==" 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 _check_test_img
echo echo
echo "== verifying patterns (5) ==" echo "== verifying patterns (5) =="
$QEMU_IO -c "read -P 0x55 0 60k" $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 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 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 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 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 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 526k 498k" "$TEST_IMG" | _filter_qemu_io
# success, all done # success, all done
echo "*** done" echo "*** done"

2
tests/qemu-iotests/035
View File

@ -59,7 +59,7 @@ function generate_requests() {
done 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' sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
echo 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 === Create image with unknown autoclear feature bit ===
echo echo
_make_test_img 64M _make_test_img 64M
./qcow2.py $TEST_IMG set-feature-bit autoclear 63 ./qcow2.py "$TEST_IMG" set-feature-bit autoclear 63
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
echo echo
echo === Repair image === echo === Repair image ===
echo echo
_check_test_img -r all _check_test_img -r all
./qcow2.py $TEST_IMG dump-header ./qcow2.py "$TEST_IMG" dump-header
# success, all done # success, all done
echo "*** done" echo "*** done"

60
tests/qemu-iotests/037
View File

@ -66,50 +66,50 @@ function backing_io()
done 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
echo "== COW in a single cluster ==" echo "== COW in a single cluster =="
$QEMU_IO -c "write -P 0x77 0 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 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 0x99 9k 2k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 0 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 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 $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 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 $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 backing_io $((11 * 1024)) 2 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== COW in two-cluster allocations ==" echo "== COW in two-cluster allocations =="
$QEMU_IO -c "write -P 0x77 16k 6k" $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 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 0x99 33k 5k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 16k 6k" $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 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 $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 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 $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 backing_io $((38 * 1024)) 4 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
echo echo
echo "== COW in multi-cluster allocations ==" echo "== COW in multi-cluster allocations =="
$QEMU_IO -c "write -P 0x77 48k 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 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 0x99 83k 15k" "$TEST_IMG" | _filter_qemu_io
$QEMU_IO -c "read -P 0x77 48k 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 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 $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 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 $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 backing_io $((98 * 1024)) 4 read | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img _check_test_img

10
tests/qemu-iotests/038
View File

@ -66,11 +66,11 @@ function backing_io()
done 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
echo "== Some concurrent requests touching the same cluster ==" echo "== Some concurrent requests touching the same cluster =="
@ -94,7 +94,7 @@ function overlay_io()
echo aio_write -P 0x90 4080k 80k 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' \ sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g' \
-e 's/qemu-io> //g' | paste - - | sort | tr '\t' '\n' -e 's/qemu-io> //g' | paste - - | sort | tr '\t' '\n'
@ -124,7 +124,7 @@ function verify_io()
done done
} }
verify_io | $QEMU_IO $TEST_IMG | _filter_qemu_io verify_io | $QEMU_IO "$TEST_IMG" | _filter_qemu_io
_check_test_img _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" IMGOPTS="compat=1.1,lazy_refcounts=on"
_make_test_img $size _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 # 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 _check_test_img
echo echo
@ -68,20 +68,20 @@ _make_test_img $size
old_ulimit=$(ulimit -c) old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3) 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" ulimit -c "$old_ulimit"
# The dirty bit must be set # 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 _check_test_img
echo echo
echo "== Read-only access must still work ==" 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 # 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
echo "== Repairing the image file must succeed ==" echo "== Repairing the image file must succeed =="
@ -89,12 +89,12 @@ echo "== Repairing the image file must succeed =="
_check_test_img -r all _check_test_img -r all
# The dirty bit must not be set # 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
echo "== Data should still be accessible after repair ==" 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
echo "== Opening a dirty image read/write should repair it ==" echo "== Opening a dirty image read/write should repair it =="
@ -104,16 +104,16 @@ _make_test_img $size
old_ulimit=$(ulimit -c) old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3) 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" ulimit -c "$old_ulimit"
# The dirty bit must be set # 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 # 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
echo "== Creating an image file with lazy_refcounts=off ==" echo "== Creating an image file with lazy_refcounts=off =="
@ -123,11 +123,11 @@ _make_test_img $size
old_ulimit=$(ulimit -c) old_ulimit=$(ulimit -c)
ulimit -c 0 # do not produce a core dump on abort(3) 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" ulimit -c "$old_ulimit"
# The dirty bit must not be set since lazy_refcounts=off # 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 _check_test_img
# success, all done # success, all done

10
tests/qemu-iotests/042
View File

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

32
tests/qemu-iotests/043
View File

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

10
tests/qemu-iotests/046
View File

@ -66,11 +66,11 @@ function backing_io()
done 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
echo "== Some concurrent requests touching the same cluster ==" echo "== Some concurrent requests touching the same cluster =="
@ -185,7 +185,7 @@ aio_flush
EOF 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' sed -e 's/bytes at offset [0-9]*/bytes at offset XXX/g'
echo echo
@ -252,7 +252,7 @@ function verify_io()
echo read -P 17 0x11c000 0x4000 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 _check_test_img

2
tests/qemu-iotests/047
View File

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

8
tests/qemu-iotests/048
View File

@ -31,13 +31,13 @@ _cleanup()
{ {
echo "Cleanup" echo "Cleanup"
_cleanup_test_img _cleanup_test_img
rm ${TEST_IMG2} rm "${TEST_IMG2}"
} }
trap "_cleanup; exit \$status" 0 1 2 3 15 trap "_cleanup; exit \$status" 0 1 2 3 15
_compare() _compare()
{ {
$QEMU_IMG compare "$@" $TEST_IMG ${TEST_IMG2} $QEMU_IMG compare "$@" "$TEST_IMG" "${TEST_IMG2}"
echo $? echo $?
} }
@ -59,12 +59,12 @@ _make_test_img $size
io_pattern write 524288 $CLUSTER_SIZE $CLUSTER_SIZE 4 45 io_pattern write 524288 $CLUSTER_SIZE $CLUSTER_SIZE 4 45
# Compare identical images # Compare identical images
cp $TEST_IMG ${TEST_IMG2} cp "$TEST_IMG" "${TEST_IMG2}"
_compare _compare
_compare -q _compare -q
# Compare images with different size # Compare images with different size
$QEMU_IMG resize $TEST_IMG +512M $QEMU_IMG resize "$TEST_IMG" +512M
_compare _compare
_compare -s _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 "== 1. Traditional size parameter =="
echo echo
for s in $sizes; do for s in $sizes; do
test_qemu_img create -f $IMGFMT $TEST_IMG $s test_qemu_img create -f $IMGFMT "$TEST_IMG" $s
done done
echo "== 2. Specifying size via -o ==" echo "== 2. Specifying size via -o =="
echo echo
for s in $sizes; do 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 done
echo "== 3. Invalid sizes ==" echo "== 3. Invalid sizes =="
@ -77,8 +77,8 @@ echo
sizes="-1024 -1k 1kilobyte foobar" sizes="-1024 -1k 1kilobyte foobar"
for s in $sizes; do for s in $sizes; do
test_qemu_img create -f $IMGFMT $TEST_IMG -- $s 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 -o size=$s "$TEST_IMG"
done done
echo "== Check correct interpretation of suffixes for cluster size ==" 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" sizes+="1024.0 1024.0b 0.5k 0.5K 0.5M"
for s in $sizes; do 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 done
echo "== Check compat level option ==" echo "== Check compat level option =="
echo echo
test_qemu_img create -f $IMGFMT -o compat=0.10 $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=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=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=foobar "$TEST_IMG" 64M
echo "== Check preallocation option ==" echo "== Check preallocation option =="
echo echo
test_qemu_img create -f $IMGFMT -o preallocation=off $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=metadata "$TEST_IMG" 64M
test_qemu_img create -f $IMGFMT -o preallocation=1234 $TEST_IMG 64M test_qemu_img create -f $IMGFMT -o preallocation=1234 "$TEST_IMG" 64M
echo "== Check encryption option ==" echo "== Check encryption option =="
echo echo
test_qemu_img create -f $IMGFMT -o encryption=off $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 test_qemu_img create -f $IMGFMT -o encryption=on "$TEST_IMG" 64M
echo "== Check lazy_refcounts option (only with v3) ==" echo "== Check lazy_refcounts option (only with v3) =="
echo 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=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=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=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=on "$TEST_IMG" 64M
# success, all done # success, all done
echo "*** done" echo "*** done"

20
tests/qemu-iotests/050
View File

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

50
tests/qemu-iotests/051
View File

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

6
tests/qemu-iotests/052
View File

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

10
tests/qemu-iotests/053
View File

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

2
tests/qemu-iotests/054
View File

@ -49,7 +49,7 @@ _make_test_img $((1024*1024))T
echo echo
echo "creating too large image (1 EB) using qcow2.py" echo "creating too large image (1 EB) using qcow2.py"
_make_test_img 4G _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 _check_test_img
# success, all done # success, all done

6
tests/qemu-iotests/059
View File

@ -51,20 +51,20 @@ echo "=== Testing invalid granularity ==="
echo echo
_make_test_img 64M _make_test_img 64M
poke_file "$TEST_IMG" "$granularity_offset" "\xff\xff\xff\xff\xff\xff\xff\xff" 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 "=== Testing too big L2 table size ==="
echo echo
_make_test_img 64M _make_test_img 64M
poke_file "$TEST_IMG" "$grain_table_size_offset" "\xff\xff\xff\xff" 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 "=== Testing too big L1 table size ==="
echo echo
_make_test_img 64M _make_test_img 64M
poke_file "$TEST_IMG" "$capacity_offset" "\xff\xff\xff\xff" poke_file "$TEST_IMG" "$capacity_offset" "\xff\xff\xff\xff"
poke_file "$TEST_IMG" "$grain_table_size_offset" "\x01\x00\x00\x00" 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 "=== Testing monolithicFlat creation and opening ==="
echo echo

28
tests/qemu-iotests/063
View File

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

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

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