tests/qemu-iotests/081 - third_party/qemu - Git at Google

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

 # creator
 owner=benoit@irqsave.net

 seq=`basename $0`
 echo "QA output created by $seq"

 status=1	# failure is the default!

 _cleanup()
 {
     _rm_test_img "$TEST_DIR/1.raw"
     _rm_test_img "$TEST_DIR/2.raw"
     _rm_test_img "$TEST_DIR/3.raw"
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15

 # get standard environment, filters and checks
 . ./common.rc
 . ./common.filter

 _supported_fmt raw
 _supported_proto file
 _supported_os Linux
 _require_drivers quorum
 _require_devices virtio-scsi

 do_run_qemu()
 {
     echo Testing: "$@"
     $QEMU -nographic -qmp stdio -serial none "$@"
     echo
 }

 run_qemu()
 {
     do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_imgfmt | _filter_qemu \
                           | _filter_qmp | _filter_qemu_io \
                           | _filter_generated_node_ids
 }

 quorum="driver=raw,file.driver=quorum,file.vote-threshold=2"
 quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
 quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
 quorum="$quorum,file.children.2.file.filename=$TEST_DIR/3.raw"
 quorum="$quorum,file.children.0.driver=raw"
 quorum="$quorum,file.children.1.driver=raw"
 quorum="$quorum,file.children.2.driver=raw"

 echo
 echo "== creating quorum files =="

 size=10M

 TEST_IMG="$TEST_DIR/1.raw" _make_test_img $size
 TEST_IMG="$TEST_DIR/2.raw" _make_test_img $size
 TEST_IMG="$TEST_DIR/3.raw" _make_test_img $size

 echo
 echo "== writing images =="

 $QEMU_IO -c "open -o $quorum" -c "write -P 0x32 0 $size" | _filter_qemu_io

 echo
 echo "== checking quorum write =="

 $QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/1.raw" | _filter_qemu_io
 $QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io
 $QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/3.raw" | _filter_qemu_io

 echo
 echo "== corrupting image =="

 $QEMU_IO -c "write -P 0x42 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io

 echo
 echo "== checking quorum correction =="

 $QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io

 echo
 echo "== checking mixed reference/option specification =="

 run_qemu <<EOF
 { "execute": "qmp_capabilities" }
 { "execute": "blockdev-add",
     "arguments": {
         "node-name": "drive2",
         "driver": "$IMGFMT",
         "file": {
             "driver": "file",
             "filename": "$TEST_DIR/2.raw"
         }
     }
 }
 { "execute": "blockdev-add",
     "arguments": {
         "driver": "quorum",
         "node-name": "drive0-quorum",
         "vote-threshold": 2,
         "children": [
             {
                 "driver": "$IMGFMT",
                 "file": {
                     "driver": "file",
                     "filename": "$TEST_DIR/1.raw"
                 }
             },
             "drive2",
             {
                 "driver": "$IMGFMT",
                 "file": {
                     "driver": "file",
                     "filename": "$TEST_DIR/3.raw"
                 }
             }
         ]
     }
 }
 { "execute": "human-monitor-command",
     "arguments": {
         "command-line": 'qemu-io drive0-quorum "read -P 0x32 0 $size"'
     }
 }
 { "execute": "quit" }
 EOF

 echo
 echo "== using quorum rewrite corrupted mode =="

 quorum="$quorum,file.rewrite-corrupted=on"

 $QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io

 echo
 echo "== checking that quorum has corrected the corrupted file =="

 $QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io

 echo
 echo "== using quorum rewrite corrupted mode without WRITE permission =="

 # The same as above, but this time, do it on a quorum node whose only
 # parent will not take the WRITE permission

 echo '-- corrupting --'
 # Only corrupt a portion: The guest device (scsi-hd on virtio-scsi)
 # will read some data (looking for a partition table to guess the
 # disk's geometry), which would trigger a quorum mismatch if the
 # beginning of the image was corrupted.  The subsequent
 # QUORUM_REPORT_BAD event would be suppressed (because at that point,
 # there cannot have been a qmp_capabilities on the monitor).  Because
 # that event is rate-limited, the next QUORUM_REPORT_BAD that happens
 # thanks to our qemu-io read (which should trigger a mismatch) would
 # then be delayed past the VM quit and not appear in the output.
 # So we keep the first 1M intact to see a QUORUM_REPORT_BAD resulting
 # from the qemu-io invocation.
 $QEMU_IO -c "write -P 0x42 1M 1M" "$TEST_DIR/2.raw" | _filter_qemu_io

 # Fix the corruption (on a read-only quorum node, i.e. without taking
 # the WRITE permission on it -- its child nodes need to be R/W OTOH,
 # so that rewrite-corrupted works)
 echo
 echo '-- running quorum --'
 run_qemu \
     -blockdev file,node-name=file1,filename="$TEST_DIR/1.raw" \
     -blockdev file,node-name=file2,filename="$TEST_DIR/2.raw" \
     -blockdev file,node-name=file3,filename="$TEST_DIR/3.raw" \
     -blockdev '{
         "driver": "quorum",
         "node-name": "quorum",
         "read-only": true,
         "vote-threshold": 2,
         "rewrite-corrupted": true,
         "children": [ "file1", "file2", "file3" ]
     }' \
     -device virtio-scsi,id=scsi \
     -device scsi-hd,id=quorum-drive,bus=scsi.0,drive=quorum \
     <<EOF
 { "execute": "qmp_capabilities" }
 {
     "execute": "human-monitor-command",
     "arguments": {
         "command-line": 'qemu-io -d quorum-drive "read -P 0x32 0 $size"'
     }
 }
 { "execute": "quit" }
 EOF

 echo '-- checking that the image has been corrected --'
 $QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io

 echo
 echo "== breaking quorum =="

 $QEMU_IO -c "write -P 0x41 0 $size" "$TEST_DIR/1.raw" | _filter_qemu_io
 $QEMU_IO -c "write -P 0x42 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io

 echo
 echo "== checking that quorum is broken =="

 $QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io

 echo
 echo "== checking the blkverify mode with broken content =="

 quorum="driver=raw,file.driver=quorum,file.vote-threshold=2,file.blkverify=on"
 quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
 quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
 quorum="$quorum,file.children.0.driver=raw"
 quorum="$quorum,file.children.1.driver=raw"

 $QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io

 echo
 echo "== writing the same data to both files =="

 $QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/1.raw" | _filter_qemu_io
 $QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/2.raw" | _filter_qemu_io

 echo
 echo "== checking the blkverify mode with valid content =="

 $QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" | _filter_qemu_io

 echo
 echo "== checking the blkverify mode with invalid settings =="

 quorum="$quorum,file.children.2.file.filename=$TEST_DIR/3.raw"
 quorum="$quorum,file.children.2.driver=raw"

 $QEMU_IO -c "open -o $quorum" | _filter_qemu_io

 echo
 echo "== dynamically adding a child to a quorum =="

 for verify in false true; do
     run_qemu <<EOF
     { "execute": "qmp_capabilities" }
     { "execute": "blockdev-add",
         "arguments": {
             "driver": "quorum",
             "node-name": "drive0-quorum",
             "vote-threshold": 2,
             "blkverify": ${verify},
             "children": [
                 {
                     "driver": "$IMGFMT",
                     "file": {
                         "driver": "file",
                         "filename": "$TEST_DIR/1.raw"
                     }
                 },
                 {
                     "driver": "$IMGFMT",
                     "file": {
                         "driver": "file",
                         "filename": "$TEST_DIR/2.raw"
                     }
                 }
             ]
         }
     }
     { "execute": "blockdev-add",
         "arguments": {
             "node-name": "drive3",
             "driver": "$IMGFMT",
             "file": {
                 "driver": "file",
                 "filename": "$TEST_DIR/2.raw"
             }
         }
     }
     { "execute": "x-blockdev-change",
       "arguments": { "parent": "drive0-quorum",
                      "node": "drive3" } }
     { "execute": "quit" }
 EOF
 done

 echo
 echo "== dynamically removing a child from a quorum =="

 for verify in false true; do
     for vote_threshold in 1 2; do
         run_qemu <<EOF
         { "execute": "qmp_capabilities" }
         { "execute": "blockdev-add",
             "arguments": {
                 "driver": "quorum",
                 "node-name": "drive0-quorum",
                 "vote-threshold": ${vote_threshold},
                 "blkverify": ${verify},
                 "children": [
                     {
                         "driver": "$IMGFMT",
                         "file": {
                             "driver": "file",
                             "filename": "$TEST_DIR/1.raw"
                         }
                     },
                     {
                         "driver": "$IMGFMT",
                         "file": {
                             "driver": "file",
                             "filename": "$TEST_DIR/2.raw"
                         }
                     }
                 ]
             }
         }
         { "execute": "x-blockdev-change",
           "arguments": { "parent": "drive0-quorum",
                          "child": "children.1" } }
         { "execute": "quit" }
 EOF
     done
 done

 # success, all done
 echo "*** done"
 rm -f $seq.full
 status=0
	#!/usr/bin/env bash
	# group: rw quick
	#
	# Test Quorum block driver
	#
	# Copyright (C) 2013 Nodalink, SARL.
	#
	# This program is free software; you can redistribute it and/or modify
	# it under the terms of the GNU General Public License as published by
	# the Free Software Foundation; either version 2 of the License, or
	# (at your option) any later version.
	#
	# This program is distributed in the hope that it will be useful,
	# but WITHOUT ANY WARRANTY; without even the implied warranty of
	# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
	# GNU General Public License for more details.
	#
	# You should have received a copy of the GNU General Public License
	# along with this program. If not, see <http://www.gnu.org/licenses/>.
	#

	# creator
	owner=benoit@irqsave.net

	seq=`basename $0`
	echo "QA output created by $seq"

	status=1 # failure is the default!

	_cleanup()
	{
	_rm_test_img "$TEST_DIR/1.raw"
	_rm_test_img "$TEST_DIR/2.raw"
	_rm_test_img "$TEST_DIR/3.raw"
	}
	trap "_cleanup; exit \$status" 0 1 2 3 15

	# get standard environment, filters and checks
	. ./common.rc
	. ./common.filter

	_supported_fmt raw
	_supported_proto file
	_supported_os Linux
	_require_drivers quorum
	_require_devices virtio-scsi

	do_run_qemu()
	{
	echo Testing: "$@"
	$QEMU -nographic -qmp stdio -serial none "$@"
	echo
	}

	run_qemu()
	{
	do_run_qemu "$@" 2>&1 \| _filter_testdir \| _filter_imgfmt \| _filter_qemu \
	\| _filter_qmp \| _filter_qemu_io \
	\| _filter_generated_node_ids
	}

	quorum="driver=raw,file.driver=quorum,file.vote-threshold=2"
	quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
	quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
	quorum="$quorum,file.children.2.file.filename=$TEST_DIR/3.raw"
	quorum="$quorum,file.children.0.driver=raw"
	quorum="$quorum,file.children.1.driver=raw"
	quorum="$quorum,file.children.2.driver=raw"

	echo
	echo "== creating quorum files =="

	size=10M

	TEST_IMG="$TEST_DIR/1.raw" _make_test_img $size
	TEST_IMG="$TEST_DIR/2.raw" _make_test_img $size
	TEST_IMG="$TEST_DIR/3.raw" _make_test_img $size

	echo
	echo "== writing images =="

	$QEMU_IO -c "open -o $quorum" -c "write -P 0x32 0 $size" \| _filter_qemu_io

	echo
	echo "== checking quorum write =="

	$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/1.raw" \| _filter_qemu_io
	$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/2.raw" \| _filter_qemu_io
	$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/3.raw" \| _filter_qemu_io

	echo
	echo "== corrupting image =="

	$QEMU_IO -c "write -P 0x42 0 $size" "$TEST_DIR/2.raw" \| _filter_qemu_io

	echo
	echo "== checking quorum correction =="

	$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" \| _filter_qemu_io

	echo
	echo "== checking mixed reference/option specification =="

	run_qemu <<EOF
	{ "execute": "qmp_capabilities" }
	{ "execute": "blockdev-add",
	"arguments": {
	"node-name": "drive2",
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/2.raw"
	}
	}
	}
	{ "execute": "blockdev-add",
	"arguments": {
	"driver": "quorum",
	"node-name": "drive0-quorum",
	"vote-threshold": 2,
	"children": [
	{
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/1.raw"
	}
	},
	"drive2",
	{
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/3.raw"
	}
	}
	]
	}
	}
	{ "execute": "human-monitor-command",
	"arguments": {
	"command-line": 'qemu-io drive0-quorum "read -P 0x32 0 $size"'
	}
	}
	{ "execute": "quit" }
	EOF

	echo
	echo "== using quorum rewrite corrupted mode =="

	quorum="$quorum,file.rewrite-corrupted=on"

	$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" \| _filter_qemu_io

	echo
	echo "== checking that quorum has corrected the corrupted file =="

	$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/2.raw" \| _filter_qemu_io

	echo
	echo "== using quorum rewrite corrupted mode without WRITE permission =="

	# The same as above, but this time, do it on a quorum node whose only
	# parent will not take the WRITE permission

	echo '-- corrupting --'
	# Only corrupt a portion: The guest device (scsi-hd on virtio-scsi)
	# will read some data (looking for a partition table to guess the
	# disk's geometry), which would trigger a quorum mismatch if the
	# beginning of the image was corrupted. The subsequent
	# QUORUM_REPORT_BAD event would be suppressed (because at that point,
	# there cannot have been a qmp_capabilities on the monitor). Because
	# that event is rate-limited, the next QUORUM_REPORT_BAD that happens
	# thanks to our qemu-io read (which should trigger a mismatch) would
	# then be delayed past the VM quit and not appear in the output.
	# So we keep the first 1M intact to see a QUORUM_REPORT_BAD resulting
	# from the qemu-io invocation.
	$QEMU_IO -c "write -P 0x42 1M 1M" "$TEST_DIR/2.raw" \| _filter_qemu_io

	# Fix the corruption (on a read-only quorum node, i.e. without taking
	# the WRITE permission on it -- its child nodes need to be R/W OTOH,
	# so that rewrite-corrupted works)
	echo
	echo '-- running quorum --'
	run_qemu \
	-blockdev file,node-name=file1,filename="$TEST_DIR/1.raw" \
	-blockdev file,node-name=file2,filename="$TEST_DIR/2.raw" \
	-blockdev file,node-name=file3,filename="$TEST_DIR/3.raw" \
	-blockdev '{
	"driver": "quorum",
	"node-name": "quorum",
	"read-only": true,
	"vote-threshold": 2,
	"rewrite-corrupted": true,
	"children": [ "file1", "file2", "file3" ]
	}' \
	-device virtio-scsi,id=scsi \
	-device scsi-hd,id=quorum-drive,bus=scsi.0,drive=quorum \
	<<EOF
	{ "execute": "qmp_capabilities" }
	{
	"execute": "human-monitor-command",
	"arguments": {
	"command-line": 'qemu-io -d quorum-drive "read -P 0x32 0 $size"'
	}
	}
	{ "execute": "quit" }
	EOF

	echo '-- checking that the image has been corrected --'
	$QEMU_IO -c "read -P 0x32 0 $size" "$TEST_DIR/2.raw" \| _filter_qemu_io

	echo
	echo "== breaking quorum =="

	$QEMU_IO -c "write -P 0x41 0 $size" "$TEST_DIR/1.raw" \| _filter_qemu_io
	$QEMU_IO -c "write -P 0x42 0 $size" "$TEST_DIR/2.raw" \| _filter_qemu_io

	echo
	echo "== checking that quorum is broken =="

	$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" \| _filter_qemu_io

	echo
	echo "== checking the blkverify mode with broken content =="

	quorum="driver=raw,file.driver=quorum,file.vote-threshold=2,file.blkverify=on"
	quorum="$quorum,file.children.0.file.filename=$TEST_DIR/1.raw"
	quorum="$quorum,file.children.1.file.filename=$TEST_DIR/2.raw"
	quorum="$quorum,file.children.0.driver=raw"
	quorum="$quorum,file.children.1.driver=raw"

	$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" \| _filter_qemu_io

	echo
	echo "== writing the same data to both files =="

	$QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/1.raw" \| _filter_qemu_io
	$QEMU_IO -c "write -P 0x32 0 $size" "$TEST_DIR/2.raw" \| _filter_qemu_io

	echo
	echo "== checking the blkverify mode with valid content =="

	$QEMU_IO -c "open -o $quorum" -c "read -P 0x32 0 $size" \| _filter_qemu_io

	echo
	echo "== checking the blkverify mode with invalid settings =="

	quorum="$quorum,file.children.2.file.filename=$TEST_DIR/3.raw"
	quorum="$quorum,file.children.2.driver=raw"

	$QEMU_IO -c "open -o $quorum" \| _filter_qemu_io

	echo
	echo "== dynamically adding a child to a quorum =="

	for verify in false true; do
	run_qemu <<EOF
	{ "execute": "qmp_capabilities" }
	{ "execute": "blockdev-add",
	"arguments": {
	"driver": "quorum",
	"node-name": "drive0-quorum",
	"vote-threshold": 2,
	"blkverify": ${verify},
	"children": [
	{
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/1.raw"
	}
	},
	{
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/2.raw"
	}
	}
	]
	}
	}
	{ "execute": "blockdev-add",
	"arguments": {
	"node-name": "drive3",
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/2.raw"
	}
	}
	}
	{ "execute": "x-blockdev-change",
	"arguments": { "parent": "drive0-quorum",
	"node": "drive3" } }
	{ "execute": "quit" }
	EOF
	done

	echo
	echo "== dynamically removing a child from a quorum =="

	for verify in false true; do
	for vote_threshold in 1 2; do
	run_qemu <<EOF
	{ "execute": "qmp_capabilities" }
	{ "execute": "blockdev-add",
	"arguments": {
	"driver": "quorum",
	"node-name": "drive0-quorum",
	"vote-threshold": ${vote_threshold},
	"blkverify": ${verify},
	"children": [
	{
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/1.raw"
	}
	},
	{
	"driver": "$IMGFMT",
	"file": {
	"driver": "file",
	"filename": "$TEST_DIR/2.raw"
	}
	}
	]
	}
	}
	{ "execute": "x-blockdev-change",
	"arguments": { "parent": "drive0-quorum",
	"child": "children.1" } }
	{ "execute": "quit" }
	EOF
	done
	done

	# success, all done
	echo "*** done"
	rm -f $seq.full
	status=0