Commit 4de110f8 authored by Kevin Wolf's avatar Kevin Wolf
Browse files

qemu-iotests: Rewrite 206 for blockdev-create job 



This rewrites the test case 206 to work with the new x-blockdev-create
job rather than the old synchronous version of the command.

All of the test cases stay the same as before, but in order to be able
to implement proper job handling, the test case is rewritten in Python.

Signed-off-by: default avatarKevin Wolf <kwolf@redhat.com>
Reviewed-by: default avatarMax Reitz <mreitz@redhat.com>
parent 5a259e86

tests/qemu-iotests/206

+263 −417
Original line number Diff line number Diff line 
#!/bin/bash

#!/usr/bin/env python

#

# Test qcow2 and file image creation

#

# Copyright (C) 2018 Red Hat, Inc.

#

# Creator/Owner: Kevin Wolf <kwolf@redhat.com>

#

# 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
@@ -18,419 +20,263 @@ 
# along with this program.  If not, see <http://www.gnu.org/licenses/>.

#



# creator

owner=kwolf@redhat.com



seq=`basename $0`

echo "QA output created by $seq"



here=`pwd`

status=1	# failure is the default!



# get standard environment, filters and checks

. ./common.rc

. ./common.filter



_supported_fmt qcow2

_supported_proto file

_supported_os Linux



function do_run_qemu()

{

    echo Testing: "$@"

    $QEMU -nographic -qmp stdio -serial none "$@"

    echo

}



function run_qemu()

{

    do_run_qemu "$@" 2>&1 | _filter_testdir | _filter_qmp \

                          | _filter_qemu | _filter_imgfmt \

                          | _filter_actual_image_size

}



echo

echo "=== Successful image creation (defaults) ==="

echo



size=$((128 * 1024 * 1024))



run_qemu <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "file",

      "filename": "$TEST_IMG",

      "size": 0

  }

}

{ "execute": "blockdev-add",

  "arguments": {

      "driver": "file",

      "node-name": "imgfile",

      "filename": "$TEST_IMG"

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "imgfile",

      "size": $size

  }

}

{ "execute": "quit" }

EOF



_img_info --format-specific



echo

echo "=== Successful image creation (inline blockdev-add, explicit defaults) ==="

echo

import iotests

from iotests import imgfmt



iotests.verify_image_format(supported_fmts=['qcow2'])



def blockdev_create(vm, options):

    result = vm.qmp_log('x-blockdev-create', job_id='job0', options=options)



    if 'return' in result:

        assert result['return'] == {}

        vm.run_job('job0')

    iotests.log("")



with iotests.FilePath('t.qcow2') as disk_path, \

     iotests.FilePath('t.qcow2.base') as backing_path, \

     iotests.VM() as vm:



    vm.add_object('secret,id=keysec0,data=foo')



    #

    # Successful image creation (defaults)

    #

    iotests.log("=== Successful image creation (defaults) ===")

    iotests.log("")



    size = 128 * 1024 * 1024



    vm.launch()

    blockdev_create(vm, { 'driver': 'file',

                          'filename': disk_path,

                          'size': 0 })



    vm.qmp_log('blockdev-add', driver='file', filename=disk_path,

               node_name='imgfile')



    blockdev_create(vm, { 'driver': imgfmt,

                          'file': 'imgfile',

                          'size': size })

    vm.shutdown()



    iotests.img_info_log(disk_path)



    #

    # Successful image creation (inline blockdev-add, explicit defaults)

    #

    iotests.log("=== Successful image creation (inline blockdev-add, explicit defaults) ===")

    iotests.log("")



    # Choose a different size to show that we got a new image

size=$((64 * 1024 * 1024))



run_qemu <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "file",

      "filename": "$TEST_IMG",

      "size": 0,

      "preallocation": "off",

      "nocow": false

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": {

          "driver": "file",

          "filename": "$TEST_IMG"

    size = 64 * 1024 * 1024



    vm.launch()

    blockdev_create(vm, { 'driver': 'file',

                          'filename': disk_path,

                          'size': 0,

                          'preallocation': 'off',

                          'nocow': False })



    blockdev_create(vm, { 'driver': imgfmt,

                          'file': {

                              'driver': 'file',

                              'filename': disk_path,

                          },

      "size": $size,

      "version": "v3",

      "cluster-size": 65536,

      "preallocation": "off",

      "lazy-refcounts": false,

      "refcount-bits": 16

  }

}

{ "execute": "quit" }

EOF



_img_info --format-specific



echo

echo "=== Successful image creation (v3 non-default options) ==="

echo

                          'size': size,

                          'version': 'v3',

                          'cluster-size': 65536,

                          'preallocation': 'off',

                          'lazy-refcounts': False,

                          'refcount-bits': 16 })

    vm.shutdown()



    iotests.img_info_log(disk_path)



    #

    # Successful image creation (v3 non-default options)

    #

    iotests.log("=== Successful image creation (v3 non-default options) ===")

    iotests.log("")



    # Choose a different size to show that we got a new image

size=$((32 * 1024 * 1024))



run_qemu <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "file",

      "filename": "$TEST_IMG",

      "size": 0,

      "preallocation": "falloc",

      "nocow": true

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": {

          "driver": "file",

          "filename": "$TEST_IMG"

    size = 32 * 1024 * 1024



    vm.launch()

    blockdev_create(vm, { 'driver': 'file',

                          'filename': disk_path,

                          'size': 0,

                          'preallocation': 'falloc',

                          'nocow': True })



    blockdev_create(vm, { 'driver': imgfmt,

                          'file': {

                              'driver': 'file',

                              'filename': disk_path,

                          },

      "size": $size,

      "version": "v3",

      "cluster-size": 2097152,

      "preallocation": "metadata",

      "lazy-refcounts": true,

      "refcount-bits": 1

  }

}

{ "execute": "quit" }

EOF



_img_info --format-specific



echo

echo "=== Successful image creation (v2 non-default options) ==="

echo



mv $TEST_IMG $TEST_IMG.base



run_qemu <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "file",

      "filename": "$TEST_IMG",

      "size": 0

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": {

          "driver": "file",

          "filename": "$TEST_IMG"

                          'size': size,

                          'version': 'v3',

                          'cluster-size': 2097152,

                          'preallocation': 'metadata',

                          'lazy-refcounts': True,

                          'refcount-bits': 1 })

    vm.shutdown()



    iotests.img_info_log(disk_path)



    #

    # Successful image creation (v2 non-default options)

    #

    iotests.log("=== Successful image creation (v2 non-default options) ===")

    iotests.log("")



    vm.launch()

    blockdev_create(vm, { 'driver': 'file',

                          'filename': disk_path,

                          'size': 0 })



    blockdev_create(vm, { 'driver': imgfmt,

                          'file': {

                              'driver': 'file',

                              'filename': disk_path,

                          },

      "size": $size,

      "backing-file": "$TEST_IMG.base",

      "backing-fmt": "qcow2",

      "version": "v2",

      "cluster-size": 512

  }

}

{ "execute": "quit" }

EOF



_img_info --format-specific



echo

echo "=== Successful image creation (encrypted) ==="

echo



run_qemu -object secret,id=keysec0,data="foo" <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": {

          "driver": "file",

          "filename": "$TEST_IMG"

                          'size': size,

                          'backing-file': backing_path,

                          'backing-fmt': 'qcow2',

                          'version': 'v2',

                          'cluster-size': 512 })

    vm.shutdown()



    iotests.img_info_log(disk_path)



    #

    # Successful image creation (encrypted)

    #

    iotests.log("=== Successful image creation (encrypted) ===")

    iotests.log("")



    vm.launch()

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': {

                              'driver': 'file',

                              'filename': disk_path,

                          },

      "size": $size,

      "encrypt": {

          "format": "luks",

          "key-secret": "keysec0",

          "cipher-alg": "twofish-128",

          "cipher-mode": "ctr",

          "ivgen-alg": "plain64",

          "ivgen-hash-alg": "md5",

          "hash-alg": "sha1",

          "iter-time": 10

      }

  }

}

{ "execute": "quit" }

EOF



_img_info --format-specific | _filter_img_info --format-specific



echo

echo "=== Invalid BlockdevRef ==="

echo



run_qemu <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "this doesn't exist",

      "size": $size

  }

}

{ "execute": "quit" }

EOF





echo

echo "=== Invalid sizes ==="

echo

                          'size': size,

                          'encrypt': {

                              'format': 'luks',

                              'key-secret': 'keysec0',

                              'cipher-alg': 'twofish-128',

                              'cipher-mode': 'ctr',

                              'ivgen-alg': 'plain64',

                              'ivgen-hash-alg': 'md5',

                              'hash-alg': 'sha1',

                              'iter-time': 10,

                          }})

    vm.shutdown()



    iotests.img_info_log(disk_path)



# TODO Negative image sizes aren't handled correctly, but this is a problem

# with QAPI's implementation of the 'size' type and affects other commands as

# well. Once this is fixed, we may want to add a test case here.

    #

    # Invalid BlockdevRef

    #

    iotests.log("=== Invalid BlockdevRef ===")

    iotests.log("")



    vm.launch()

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': "this doesn't exist",

                          'size': size })

    vm.shutdown()



    #

    # Invalid sizes

    #

    iotests.log("=== Invalid sizes ===")



    # TODO Negative image sizes aren't handled correctly, but this is a problem

    # with QAPI's implementation of the 'size' type and affects other commands

    # as well. Once this is fixed, we may want to add a test case here.

    #

    # 1. Misaligned image size

    # 2. 2^64 - 512

    # 3. 2^63 = 8 EB (qemu-img enforces image sizes less than this)

    # 4. 2^63 - 512 (generally valid, but qcow2 can't handle images this size)



run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 1234

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 18446744073709551104

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 9223372036854775808

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 9223372036854775296

  }

}

{ "execute": "quit" }

EOF



echo

echo "=== Invalid version ==="

echo



run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "version": "v1"

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "version": "v2",

      "lazy-refcounts": true

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "version": "v2",

      "refcount-bits": 8

  }

}

{ "execute": "quit" }

EOF



echo

echo "=== Invalid backing file options ==="

echo



run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "backing-file": "/dev/null",

      "preallocation": "full"

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "backing-fmt": "$IMGFMT"

  }

}

{ "execute": "quit" }

EOF



echo

echo "=== Invalid cluster size ==="

echo



run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "cluster-size": 1234

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "cluster-size": 128

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "cluster-size": 4194304

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "cluster-size": 0

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 281474976710656,

      "cluster-size": 512

  }

}

{ "execute": "quit" }

EOF



echo

echo "=== Invalid refcount width ==="

echo



run_qemu -blockdev driver=file,filename="$TEST_IMG",node-name=node0 <<EOF

{ "execute": "qmp_capabilities" }

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "refcount-bits": 128

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "refcount-bits": 0

  }

}

{ "execute": "x-blockdev-create",

  "arguments": {

      "driver": "$IMGFMT",

      "file": "node0",

      "size": 67108864,

      "refcount-bits": 7

  }

}

{ "execute": "quit" }

EOF



# success, all done

echo "*** done"

rm -f $seq.full

status=0
 
    vm.add_blockdev('driver=file,filename=%s,node-name=node0' % (disk_path))



    vm.launch()

    for size in [ 1234, 18446744073709551104, 9223372036854775808,

                  9223372036854775296 ]:

        blockdev_create(vm, { 'driver': imgfmt,

                              'file': 'node0',

                              'size': size })

    vm.shutdown()



    #

    # Invalid version

    #

    iotests.log("=== Invalid version ===")



    vm.launch()

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': 'node0',

                          'size': 67108864,

                          'version': 'v1' })

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': 'node0',

                          'size': 67108864,

                          'version': 'v2',

                          'lazy-refcounts': True })

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': 'node0',

                          'size': 67108864,

                          'version': 'v2',

                          'refcount-bits': 8 })

    vm.shutdown()



    #

    # Invalid backing file options

    #

    iotests.log("=== Invalid backing file options ===")



    vm.launch()

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': 'node0',

                          'size': 67108864,

                          'backing-file': '/dev/null',

                          'preallocation': 'full' })

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': 'node0',

                          'size': 67108864,

                          'backing-fmt': imgfmt })

    vm.shutdown()



    #

    # Invalid cluster size

    #

    iotests.log("=== Invalid cluster size ===")



    vm.launch()

    for csize in [ 1234, 128, 4194304, 0 ]:

        blockdev_create(vm, { 'driver': imgfmt,

                              'file': 'node0',

                              'size': 67108864,

                              'cluster-size': csize })

    blockdev_create(vm, { 'driver': imgfmt,

                          'file': 'node0',

                          'size': 281474976710656,

                          'cluster-size': 512 })

    vm.shutdown()



    #

    # Invalid refcount width

    #

    iotests.log("=== Invalid refcount width ===")



    vm.launch()

    for refcount_bits in [ 128, 0, 7 ]:

        blockdev_create(vm, { 'driver': imgfmt,

                              'file': 'node0',

                              'size': 67108864,

                              'refcount-bits': refcount_bits })

    vm.shutdown()

tests/qemu-iotests/206.out

+150 −103

File changed.

Preview size limit exceeded, changes collapsed.

tests/qemu-iotests/group

+1 −1
Original line number Diff line number Diff line
@@ -204,9 +204,9 @@ 
203 rw auto migration

204 rw auto quick

205 rw auto quick

206 rw auto

# TODO The following commented out tests need to be reworked to work

# with the x-blockdev-create job

#206 rw auto

#207 rw auto

208 rw auto quick

209 rw auto quick