From 9b3ed457aa8c255cb8a5975f5aacd149d0b0397a Mon Sep 17 00:00:00 2001

From: Kevin Wolf <kwolf@redhat.com>

Date: Tue, 26 Jun 2018 09:48:46 +0200

Subject: [PATCH 77/89] qemu-iotests: Rewrite 206 for blockdev-create job

RH-Author: Kevin Wolf <kwolf@redhat.com>

Message-id: <20180626094856.6924-64-kwolf@redhat.com>

Patchwork-id: 81077

O-Subject: [RHV-7.6 qemu-kvm-rhev PATCH v2 63/73] qemu-iotests: Rewrite 206 for blockdev-create job

Bugzilla: 1513543

RH-Acked-by: Jeffrey Cody <jcody@redhat.com>

RH-Acked-by: Max Reitz <mreitz@redhat.com>

RH-Acked-by: Fam Zheng <famz@redhat.com>

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: Kevin Wolf <kwolf@redhat.com>

Reviewed-by: Max Reitz <mreitz@redhat.com>

(cherry picked from commit 4de110f8fd2811171013254fd7ed2384f1de87b4)

Signed-off-by: Kevin Wolf <kwolf@redhat.com>

Signed-off-by: Miroslav Rezanina <mrezanin@redhat.com>

---

 tests/qemu-iotests/206     | 680 ++++++++++++++++++---------------------------

 tests/qemu-iotests/206.out | 253 ++++++++++-------

 tests/qemu-iotests/group   |   2 +-

 3 files changed, 414 insertions(+), 521 deletions(-)

diff --git a/tests/qemu-iotests/206 b/tests/qemu-iotests/206

index 0a18b2b..b8cf2e7 100755

--- a/tests/qemu-iotests/206

+++ b/tests/qemu-iotests/206

@@ -1,9 +1,11 @@

-#!/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 <

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

-

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

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

-

-run_qemu <

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

-

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

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

-

-run_qemu <

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

-{ "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,

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

-{ "execute": "qmp_capabilities" }

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

-  "arguments": {

-      "driver": "$IMGFMT",

-      "file": {

-          "driver": "file",

-          "filename": "$TEST_IMG"

-      },

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

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

-

-# 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 <

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

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

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

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

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

+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

+

+    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 })

+    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

+

+    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 })

+    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': 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,

+                          }})

+    vm.shutdown()

+

+    iotests.img_info_log(disk_path)

+

+    #

+    # 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)

+

+    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 ===")