dd_test: add different block size

add different block size, which will execute multiple dd test
based on the block sizes provided.
1. use extra parameter to specify partition size.
2. add readonly=off.
3. add dd I/O flag: direct.
Signed-off-by: Nlolyu <lolyu@redhat.com>

generic/tests/cfg/dd_test.cfg

@@ -3,10 +3,11 @@
     only Linux
     type = dd_test
     images += " stg1"
-    create_image_stg1 = yes
+    force_create_image_stg1 = yes
     image_name_stg1 = images/stg1
-    image_size_stg1 = 1M
+    image_size_stg1 = 20G
     image_snapshot_stg1 = no
+    image_readonly_stg1 = no
     drive_index_stg1 = 3
     image_boot_stg1 = no
     blk_extra_params_stg1 = "serial=TARGET_DISK0"
@@ -39,3 +40,16 @@
                     dd_if = stg1
                     dd_of = NULL
                     dd_stat = 0
+        - multiple:
+            partition_size = 2G
+            variants:
+                - zero2disk:
+                    dd_if = ZERO
+                    dd_of = stg1
+                    dd_bs = "4k 8k 16k 64k 128k 256k 4M 1G"
+                    dd_oflag = direct
+                - disk2null:
+                    dd_if = stg1
+                    dd_of = NULL
+                    dd_bs = "4k 8k 16k 64k 128k 256k 4M 1G"
+                    dd_iflag = direct

generic/tests/dd_test.py

@@ -4,12 +4,20 @@ Configurable on-guest dd test.
 :author: Lukas Doktor <ldoktor@redhat.com>
 :copyright: 2012 Red Hat, Inc.
 """
+import os
+import re
 import logging
-
 import aexpect
 
-from virttest import error_context
 from virttest import utils_misc
+from virttest import utils_disk
+from virttest import utils_numeric
+from virttest import error_context
+
+try:
+    from itertools import zip_longest as zip_longest
+except Exception:
+    from itertools import izip_longest as zip_longest
 
 
 @error_context.context_aware
@@ -60,62 +68,105 @@ def run(test, params, env):
     error_context.context("Wait guest boot up", logging.info)
     session = vm.wait_for_login(timeout=timeout)
 
-    dd_if = params.get("dd_if")
-    dd_if_select = int(params.get("dd_if_select", '-1'))
-    dd_of = params.get("dd_of")
-    dd_of_select = int(params.get("dd_of_select", '-1'))
-    dd_bs = params.get("dd_bs")
-    dd_count = params.get("dd_count")
-    dd_iflag = params.get("dd_iflag")
-    dd_oflag = params.get("dd_oflag")
-    dd_skip = params.get("dd_skip")
-    dd_seek = params.get("dd_seek")
+    dd_keys = ['dd_if', 'dd_of', 'dd_bs', 'dd_count', 'dd_iflag',
+               'dd_oflag', 'dd_skip', 'dd_seek']
 
-    dd_timeout = int(params.get("dd_timeout", 60))
+    dd_params = {key: params.get(key, None) for key in dd_keys}
+    if dd_params['dd_bs'] is None:
+        dd_params['dd_bs'] = '512'
+    dd_params['dd_bs'] = dd_params['dd_bs'].split()
+    bs_count = len(dd_params['dd_bs'])
 
+    dd_timeout = int(params.get("dd_timeout", 180))
     dd_output = params.get("dd_output", "")
     dd_stat = int(params.get("dd_stat", 0))
 
-    dd_cmd = "dd"
-    if dd_if:
-        dd_if = _get_file(dd_if, dd_if_select)
-        dd_cmd += " if=%s" % dd_if
-    if dd_of:
-        dd_of = _get_file(dd_of, dd_of_select)
-        dd_cmd += " of=%s" % dd_of
-    if dd_bs:
-        dd_cmd += " bs=%s" % dd_bs
-    if dd_count:
-        dd_cmd += " count=%s" % dd_count
-    if dd_iflag:
-        dd_cmd += " iflag=%s" % dd_iflag
-    if dd_oflag:
-        dd_cmd += " oflag=%s" % dd_oflag
-    if dd_skip:
-        dd_cmd += " skip=%s" % dd_skip
-    if dd_seek:
-        dd_cmd += " seek=%s" % dd_seek
-    logging.info("Using '%s' cmd", dd_cmd)
-
-    error_context.context("Execute dd in guest", logging.info)
+    dev_partitioned = []
+    for arg in ['dd_if', 'dd_of']:
+        filename = dd_params[arg]
+        path = _get_file(filename,
+                         int(params.get('%s_select' % arg, '-1')))
+        if (bs_count > 1
+                and filename in params.objects('images')):
+            psize = float(
+                utils_numeric.normalize_data_size(
+                    params.get("partition_size", '2G')
+                    )
+                )
+            start = 0.0
+            dev_id = os.path.split(path)[-1]
+            dev_partitioned.append(dev_id)
+
+            utils_disk.create_partition_table_linux(session, dev_id, 'gpt')
+            for i in range(bs_count):
+                utils_disk.create_partition_linux(session, dev_id,
+                                                  '%fM' % psize,
+                                                  '%fM' % start)
+                start += psize
+
+            disks = utils_disk.get_linux_disks(session, partition=True)
+            partitions = [key for key in disks if
+                          re.match(r'%s\d+$' % dev_id, key)]
+            partitions.sort()
+            dd_params[arg] = [path.replace(dev_id, part)
+                              for part in partitions]
+        else:
+            dd_params[arg] = [path]
+
+    if bs_count > 1 and not dev_partitioned:
+        test.error('with multiple bs, either dd_if or \
+                   dd_of must be a block device')
+
+    dd_cmd = ['dd']
+    for key in dd_keys:
+        value = dd_params[key]
+        if value is None:
+            continue
+        arg = key.split('_')[-1]
+        if key in ['dd_if', 'dd_of', 'dd_bs']:
+            part = '%s=%s' % (arg, '{}')
+        else:
+            part = '%s=%s' % (arg, value)
+        dd_cmd.append(part)
+    dd_cmd = ' '.join(dd_cmd)
+
+    remaining = [dd_params[key] for key in ['dd_if', 'dd_of', 'dd_bs']]
+    if len(dd_params['dd_if']) != bs_count:
+        fillvalue = dd_params['dd_if'][-1]
+    else:
+        fillvalue = dd_params['dd_of'][-1]
+    cmd = [dd_cmd.format(*t) for t in
+           zip_longest(*remaining, fillvalue=fillvalue)]
+    cmd = ' & '.join(cmd)
+    logging.info("Using '%s' cmd", cmd)
+
     try:
-        (stat, out) = session.cmd_status_output(dd_cmd, timeout=dd_timeout)
-    except aexpect.ShellTimeoutError:
-        err = ("dd command timed-out (cmd='%s', timeout=%d)"
-               % (dd_cmd, dd_timeout))
-        test.fail(err)
-    except aexpect.ShellCmdError as details:
-        stat = details.status
-        out = details.output
-
-    error_context.context("Check command exit status and output", logging.info)
-    logging.debug("Returned dd_status: %s\nReturned output:\n%s", stat, out)
-    if stat != dd_stat:
-        err = ("Return code doesn't match (expected=%s, actual=%s)\n"
-               "Output:\n%s" % (dd_stat, stat, out))
-        test.fail(err)
-    if dd_output not in out:
-        err = ("Output doesn't match:\nExpected:\n%s\nActual:\n%s"
-               % (dd_output, out))
-        test.fail(err)
-    logging.info("dd test succeeded.")
+        error_context.context("Execute dd in guest", logging.info)
+        try:
+            (stat, out) = session.cmd_status_output(cmd, timeout=dd_timeout)
+        except aexpect.ShellTimeoutError:
+            err = ("dd command timed-out (cmd='%s', timeout=%d)"
+                   % (cmd, dd_timeout))
+            test.fail(err)
+        except aexpect.ShellCmdError as details:
+            stat = details.status
+            out = details.output
+
+        error_context.context("Check command exit status and output",
+                              logging.info)
+        logging.debug("Returned dd_status: %s\nReturned output:\n%s",
+                      stat, out)
+        if stat != dd_stat:
+            err = ("Return code doesn't match (expected=%s, actual=%s)\n"
+                   "Output:\n%s" % (dd_stat, stat, out))
+            test.fail(err)
+        if dd_output not in out:
+            err = ("Output doesn't match:\nExpected:\n%s\nActual:\n%s"
+                   % (dd_output, out))
+            test.fail(err)
+        logging.info("dd test succeeded.")
+    finally:
+        for dev_id in dev_partitioned:
+            utils_disk.clean_partition_linux(session, dev_id)
+        session.close()
+        vm.destroy(gracefully=True)