Series comparison

-[PULL 00/11] Block patches
+[PULL 0/5] Block patches
-The following changes since commit 36609b4fa36f0ac934874371874416f7533a5408:
+The following changes since commit 711c0418c8c1ce3a24346f058b001c4c5a2f0f81:
-  Merge remote-tracking branch 'remotes/palmer/tags/palmer-for-master-4.2-sf1' into staging (2019-11-02 17:59:03 +0000)
+  Merge remote-tracking branch 'remotes/philmd/tags/mips-20210702' into staging (2021-07-04 14:04:12 +0100)
 are available in the Git repository at:
-  https://github.com/stefanha/qemu.git tags/block-pull-request
+  https://gitlab.com/stefanha/qemu.git tags/block-pull-request
-for you to fetch changes up to 9fdd7860adec188ed50d2530e9a819e8d953f9bb:
+for you to fetch changes up to 9f460c64e13897117f35ffb61f6f5e0102cabc70:
-  image-fuzzer: Use OSerror.strerror instead of tuple subscript (2019-11-05 16:36:11 +0100)
+  block/io: Merge discard request alignments (2021-07-06 14:28:55 +0100)
 ----------------------------------------------------------------
 Pull request
-Let's get the image fuzzer Python 3 changes merged in QEMU 4.2.
 ----------------------------------------------------------------
-Eduardo Habkost (11):
+Akihiko Odaki (3):
-  image-fuzzer: Open image files in binary mode
+  block/file-posix: Optimize for macOS
-  image-fuzzer: Write bytes instead of string to image file
+  block: Add backend_defaults property
-  image-fuzzer: Explicitly use integer division operator
+  block/io: Merge discard request alignments
   image-fuzzer: Use io.StringIO
   image-fuzzer: Use %r for all fiels at Field.__repr__()
   image-fuzzer: Return bytes objects on string fuzzing functions
   image-fuzzer: Use bytes constant for field values
   image-fuzzer: Encode file name and file format to bytes
   image-fuzzer: Run using python3
   image-fuzzer: Use errors parameter of subprocess.Popen()
   image-fuzzer: Use OSerror.strerror instead of tuple subscript
- tests/image-fuzzer/qcow2/__init__.py |  1 -
+Stefan Hajnoczi (2):
- tests/image-fuzzer/qcow2/fuzz.py     | 54 +++++++++++++-------------
+  util/async: add a human-readable name to BHs for debugging
- tests/image-fuzzer/qcow2/layout.py   | 57 ++++++++++++++--------------
+  util/async: print leaked BH name when AioContext finalizes
- tests/image-fuzzer/runner.py         | 16 ++++----
-files changed, 63 insertions(+), 65 deletions(-)
+ include/block/aio.h            | 31 ++++++++++++++++++++++---
  include/hw/block/block.h       |  3 +++
  include/qemu/main-loop.h       |  4 +++-
  block/file-posix.c             | 27 ++++++++++++++++++++--
  block/io.c                     |  2 ++
  hw/block/block.c               | 42 ++++++++++++++++++++++++++++++----
  tests/unit/ptimer-test-stubs.c |  2 +-
  util/async.c                   | 25 ++++++++++++++++----
  util/main-loop.c               |  4 ++--
  tests/qemu-iotests/172.out     | 38 ++++++++++++++++++++++++++++++
 files changed, 161 insertions(+), 17 deletions(-)
 --
-.23.0
+.31.1

-[PULL 01/11] image-fuzzer: Open image files in binary mode
+Deleted patch
-From: Eduardo Habkost <ehabkost@redhat.com>
-This probably never caused problems because on Linux there's no
-actual newline conversion happening, but on Python 3 the
-binary/text distinction is stronger and we must explicitly open
-the image file in binary mode.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20191016192430.25098-2-ehabkost@redhat.com
-Message-Id: <20191016192430.25098-2-ehabkost@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/image-fuzzer/qcow2/layout.py | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/layout.py
-+++ b/tests/image-fuzzer/qcow2/layout.py
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-     def write(self, filename):
-         """Write an entire image to the file."""
--        image_file = open(filename, 'w')
-+        image_file = open(filename, 'wb')
-         for field in self:
-             image_file.seek(field.offset)
-             image_file.write(struct.pack(field.fmt, field.value))
---
-.23.0

-[PULL 02/11] image-fuzzer: Write bytes instead of string to image file
+Deleted patch
-From: Eduardo Habkost <ehabkost@redhat.com>
-This is necessary for Python 3 compatibility.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20191016192430.25098-3-ehabkost@redhat.com
-Message-Id: <20191016192430.25098-3-ehabkost@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/image-fuzzer/qcow2/layout.py | 2 +-
-file changed, 1 insertion(+), 1 deletion(-)
-diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/layout.py
-+++ b/tests/image-fuzzer/qcow2/layout.py
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         rounded = (size + self.cluster_size - 1) & ~(self.cluster_size - 1)
-         if rounded > size:
-             image_file.seek(rounded - 1)
--            image_file.write("\0")
-+            image_file.write(b'\x00')
-         image_file.close()
-     @staticmethod
---
-.23.0

-[PULL 03/11] image-fuzzer: Explicitly use integer division operator
+Deleted patch
-From: Eduardo Habkost <ehabkost@redhat.com>
-Most of the division expressions in image-fuzzer assume integer
-division.  Use the // operator to keep the same behavior when we
-move to Python 3.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20191016192430.25098-4-ehabkost@redhat.com
-Message-Id: <20191016192430.25098-4-ehabkost@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/image-fuzzer/qcow2/fuzz.py   | 12 ++++-----
- tests/image-fuzzer/qcow2/layout.py | 40 +++++++++++++++---------------
-files changed, 26 insertions(+), 26 deletions(-)
-diff --git a/tests/image-fuzzer/qcow2/fuzz.py b/tests/image-fuzzer/qcow2/fuzz.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/fuzz.py
-+++ b/tests/image-fuzzer/qcow2/fuzz.py
-@@ -XXX,XX +XXX,XX @@ UINT64 = 0xffffffffffffffff
- UINT32_M = 31
- UINT64_M = 63
- # Fuzz vectors
--UINT8_V = [0, 0x10, UINT8/4, UINT8/2 - 1, UINT8/2, UINT8/2 + 1, UINT8 - 1,
-+UINT8_V = [0, 0x10, UINT8//4, UINT8//2 - 1, UINT8//2, UINT8//2 + 1, UINT8 - 1,
-            UINT8]
--UINT16_V = [0, 0x100, 0x1000, UINT16/4, UINT16/2 - 1, UINT16/2, UINT16/2 + 1,
-+UINT16_V = [0, 0x100, 0x1000, UINT16//4, UINT16//2 - 1, UINT16//2, UINT16//2 + 1,
-             UINT16 - 1, UINT16]
--UINT32_V = [0, 0x100, 0x1000, 0x10000, 0x100000, UINT32/4, UINT32/2 - 1,
--            UINT32/2, UINT32/2 + 1, UINT32 - 1, UINT32]
--UINT64_V = UINT32_V + [0x1000000, 0x10000000, 0x100000000, UINT64/4,
--                       UINT64/2 - 1, UINT64/2, UINT64/2 + 1, UINT64 - 1,
-+UINT32_V = [0, 0x100, 0x1000, 0x10000, 0x100000, UINT32//4, UINT32//2 - 1,
-+            UINT32//2, UINT32//2 + 1, UINT32 - 1, UINT32]
-+UINT64_V = UINT32_V + [0x1000000, 0x10000000, 0x100000000, UINT64//4,
-+                       UINT64//2 - 1, UINT64//2, UINT64//2 + 1, UINT64 - 1,
-                        UINT64]
- STRING_V = ['%s%p%x%d', '.1024d', '%.2049d', '%p%p%p%p', '%x%x%x%x',
-             '%d%d%d%d', '%s%s%s%s', '%99999999999s', '%08x', '%%20d', '%%20n',
-diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/layout.py
-+++ b/tests/image-fuzzer/qcow2/layout.py
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-                 ['>I', self.ext_offset, 0x6803f857, 'ext_magic'],
-                 # One feature table contains 3 fields and takes 48 bytes
-                 ['>I', self.ext_offset + UINT32_S,
--                 len(feature_tables) / 3 * 48, 'ext_length']
-+                 len(feature_tables) // 3 * 48, 'ext_length']
-             ] + feature_tables)
-             self.ext_offset = inner_offset
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         def create_l2_entry(host, guest, l2_cluster):
-             """Generate one L2 entry."""
-             offset = l2_cluster * self.cluster_size
--            l2_size = self.cluster_size / UINT64_S
-+            l2_size = self.cluster_size // UINT64_S
-             entry_offset = offset + UINT64_S * (guest % l2_size)
-             cluster_descriptor = host * self.cluster_size
-             if not self.header['version'][0].value == 2:
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         def create_l1_entry(l2_cluster, l1_offset, guest):
-             """Generate one L1 entry."""
--            l2_size = self.cluster_size / UINT64_S
--            entry_offset = l1_offset + UINT64_S * (guest / l2_size)
-+            l2_size = self.cluster_size // UINT64_S
-+            entry_offset = l1_offset + UINT64_S * (guest // l2_size)
-             # While snapshots are not supported bit #63 = 1
-             entry_val = (1 << 63) + l2_cluster * self.cluster_size
-             return ['>Q', entry_offset, entry_val, 'l1_entry']
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-             l2 = []
-         else:
-             meta_data = self._get_metadata()
--            guest_clusters = random.sample(range(self.image_size /
-+            guest_clusters = random.sample(range(self.image_size //
-                                                  self.cluster_size),
-                                            len(self.data_clusters))
-             # Number of entries in a L1/L2 table
--            l_size = self.cluster_size / UINT64_S
-+            l_size = self.cluster_size // UINT64_S
-             # Number of clusters necessary for L1 table
-             l1_size = int(ceil((max(guest_clusters) + 1) / float(l_size**2)))
-             l1_start = self._get_adjacent_clusters(self.data_clusters |
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-             # L2 entries
-             l2 = []
-             for host, guest in zip(self.data_clusters, guest_clusters):
--                l2_id = guest / l_size
-+                l2_id = guest // l_size
-                 if l2_id not in l2_ids:
-                     l2_ids.append(l2_id)
-                     l2_clusters.append(self._get_adjacent_clusters(
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         def allocate_rfc_blocks(data, size):
-             """Return indices of clusters allocated for refcount blocks."""
-             cluster_ids = set()
--            diff = block_ids = set([x / size for x in data])
-+            diff = block_ids = set([x // size for x in data])
-             while len(diff) != 0:
-                 # Allocate all yet not allocated clusters
-                 new = self._get_available_clusters(data | cluster_ids,
-                                                    len(diff))
-                 # Indices of new refcount blocks necessary to cover clusters
-                 # in 'new'
--                diff = set([x / size for x in new]) - block_ids
-+                diff = set([x // size for x in new]) - block_ids
-                 cluster_ids |= new
-                 block_ids |= diff
-             return cluster_ids, block_ids
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-             blocks = set(init_blocks)
-             clusters = set()
-             # Number of entries in one cluster of the refcount table
--            size = self.cluster_size / UINT64_S
-+            size = self.cluster_size // UINT64_S
-             # Number of clusters necessary for the refcount table based on
-             # the current number of refcount blocks
-             table_size = int(ceil((max(blocks) + 1) / float(size)))
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-                                                  table_size + 1))
-             # New refcount blocks necessary for clusters occupied by the
-             # refcount table
--            diff = set([c / block_size for c in table_clusters]) - blocks
-+            diff = set([c // block_size for c in table_clusters]) - blocks
-             blocks |= diff
-             while len(diff) != 0:
-                 # Allocate clusters for new refcount blocks
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-                                                    len(diff))
-                 # Indices of new refcount blocks necessary to cover
-                 # clusters in 'new'
--                diff = set([x / block_size for x in new]) - blocks
-+                diff = set([x // block_size for x in new]) - blocks
-                 clusters |= new
-                 blocks |= diff
-                 # Check if the refcount table needs one more cluster
-                 if int(ceil((max(blocks) + 1) / float(size))) > table_size:
--                    new_block_id = (table_start + table_size) / block_size
-+                    new_block_id = (table_start + table_size) // block_size
-                     # Check if the additional table cluster needs
-                     # one more refcount block
-                     if new_block_id not in blocks:
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         def create_table_entry(table_offset, block_cluster, block_size,
-                                cluster):
-             """Generate a refcount table entry."""
--            offset = table_offset + UINT64_S * (cluster / block_size)
-+            offset = table_offset + UINT64_S * (cluster // block_size)
-             return ['>Q', offset, block_cluster * self.cluster_size,
-                     'refcount_table_entry']
-         def create_block_entry(block_cluster, block_size, cluster):
-             """Generate a list of entries for the current block."""
--            entry_size = self.cluster_size / block_size
-+            entry_size = self.cluster_size // block_size
-             offset = block_cluster * self.cluster_size
-             entry_offset = offset + entry_size * (cluster % block_size)
-             # While snapshots are not supported all refcounts are set to 1
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         # Number of refcount entries per refcount block
-         # Convert self.cluster_size from bytes to bits to have the same
-         # base for the numerator and denominator
--        block_size = self.cluster_size * 8 / refcount_bits
-+        block_size = self.cluster_size * 8 // refcount_bits
-         meta_data = self._get_metadata()
-         if len(self.data_clusters) == 0:
-             # All metadata for an empty guest image needs 4 clusters:
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         rfc_blocks = []
-         for cluster in sorted(self.data_clusters | meta_data):
--            if cluster / block_size != block_id:
--                block_id = cluster / block_size
-+            if cluster // block_size != block_id:
-+                block_id = cluster // block_size
-                 block_cluster = block_clusters[block_ids.index(block_id)]
-                 rfc_table.append(create_table_entry(table_offset,
-                                                     block_cluster,
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-     def _alloc_data(img_size, cluster_size):
-         """Return a set of random indices of clusters allocated for guest data.
-         """
--        num_of_cls = img_size/cluster_size
-+        num_of_cls = img_size // cluster_size
-         return set(random.sample(range(1, num_of_cls + 1),
-                                  random.randint(0, num_of_cls)))
-@@ -XXX,XX +XXX,XX @@ class Image(object):
-         """Return indices of clusters allocated for image metadata."""
-         ids = set()
-         for x in self:
--            ids.add(x.offset/self.cluster_size)
-+            ids.add(x.offset // self.cluster_size)
-         return ids
---
-.23.0

-[PULL 04/11] image-fuzzer: Use io.StringIO
+Deleted patch
-From: Eduardo Habkost <ehabkost@redhat.com>
-StringIO.StringIO is not available on Python 3, but io.StringIO
-is available on both Python 2 and 3.  io.StringIO is slightly
-different from the Python 2 StringIO module, though, so we need
-bytes coming from subprocess.Popen() to be explicitly decoded.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20191016192430.25098-5-ehabkost@redhat.com
-Message-Id: <20191016192430.25098-5-ehabkost@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/image-fuzzer/runner.py | 14 +++++++++-----
-file changed, 9 insertions(+), 5 deletions(-)
-diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
-index XXXXXXX..XXXXXXX 100755
---- a/tests/image-fuzzer/runner.py
-+++ b/tests/image-fuzzer/runner.py
-@@ -XXX,XX +XXX,XX @@ import shutil
- from itertools import count
- import time
- import getopt
--import StringIO
-+import io
- import resource
- try:
-@@ -XXX,XX +XXX,XX @@ def run_app(fd, q_args):
-     try:
-         out, err = process.communicate()
-         signal.alarm(0)
--        fd.write(out)
--        fd.write(err)
-+        # fd is a text file, so we need to decode the process output before
-+        # writing to it.
-+        # We could be simply using the `errors` parameter of subprocess.Popen(),
-+        # but this will be possible only after migrating to Python 3
-+        fd.write(out.decode(errors='replace'))
-+        fd.write(err.decode(errors='replace'))
-         fd.flush()
-         return process.returncode
-@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
-                                            MAX_BACKING_FILE_SIZE) * (1 << 20)
-         cmd = self.qemu_img + ['create', '-f', backing_file_fmt,
-                                backing_file_name, str(backing_file_size)]
--        temp_log = StringIO.StringIO()
-+        temp_log = io.StringIO()
-         retcode = run_app(temp_log, cmd)
-         if retcode == 0:
-             temp_log.close()
-@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
-                            "Backing file: %s\n" \
-                            % (self.seed, " ".join(current_cmd),
-                               self.current_dir, backing_file_name)
--            temp_log = StringIO.StringIO()
-+            temp_log = io.StringIO()
-             try:
-                 retcode = run_app(temp_log, current_cmd)
-             except OSError as e:
---
-.23.0

-[PULL 05/11] image-fuzzer: Use %r for all fiels at Field.__repr__()
+Deleted patch
-From: Eduardo Habkost <ehabkost@redhat.com>
-This makes the formatting code simpler, and safer if we change
-the type of self.value from str to bytes.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20191016192430.25098-6-ehabkost@redhat.com
-Message-Id: <20191016192430.25098-6-ehabkost@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/image-fuzzer/qcow2/layout.py | 4 ++--
-file changed, 2 insertions(+), 2 deletions(-)
-diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/layout.py
-+++ b/tests/image-fuzzer/qcow2/layout.py
-@@ -XXX,XX +XXX,XX @@ class Field(object):
-         return iter([self.fmt, self.offset, self.value, self.name])
-     def __repr__(self):
--        return "Field(fmt='%s', offset=%d, value=%s, name=%s)" % \
--            (self.fmt, self.offset, str(self.value), self.name)
-+        return "Field(fmt=%r, offset=%r, value=%r, name=%r)" % \
-+            (self.fmt, self.offset, self.value, self.name)
- class FieldsList(object):
---
-.23.0

-[PULL 06/11] image-fuzzer: Return bytes objects on string fuzzing functions
+Deleted patch
-From: Eduardo Habkost <ehabkost@redhat.com>
-No caller of fuzzer functions is interested in unicode string values,
-so replace them with bytes sequences.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20191016192430.25098-7-ehabkost@redhat.com
-Message-Id: <20191016192430.25098-7-ehabkost@redhat.com>
-Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
----
- tests/image-fuzzer/qcow2/fuzz.py | 42 ++++++++++++++++----------------
-file changed, 21 insertions(+), 21 deletions(-)
-diff --git a/tests/image-fuzzer/qcow2/fuzz.py b/tests/image-fuzzer/qcow2/fuzz.py
-index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/fuzz.py
-+++ b/tests/image-fuzzer/qcow2/fuzz.py
-@@ -XXX,XX +XXX,XX @@ UINT32_V = [0, 0x100, 0x1000, 0x10000, 0x100000, UINT32//4, UINT32//2 - 1,
- UINT64_V = UINT32_V + [0x1000000, 0x10000000, 0x100000000, UINT64//4,
-                        UINT64//2 - 1, UINT64//2, UINT64//2 + 1, UINT64 - 1,
-                        UINT64]
--STRING_V = ['%s%p%x%d', '.1024d', '%.2049d', '%p%p%p%p', '%x%x%x%x',
--            '%d%d%d%d', '%s%s%s%s', '%99999999999s', '%08x', '%%20d', '%%20n',
--            '%%20x', '%%20s', '%s%s%s%s%s%s%s%s%s%s', '%p%p%p%p%p%p%p%p%p%p',
--            '%#0123456x%08x%x%s%p%d%n%o%u%c%h%l%q%j%z%Z%t%i%e%g%f%a%C%S%08x%%',
--            '%s x 129', '%x x 257']
-+BYTES_V = [b'%s%p%x%d', b'.1024d', b'%.2049d', b'%p%p%p%p', b'%x%x%x%x',
-+           b'%d%d%d%d', b'%s%s%s%s', b'%99999999999s', b'%08x', b'%%20d', b'%%20n',
-+           b'%%20x', b'%%20s', b'%s%s%s%s%s%s%s%s%s%s', b'%p%p%p%p%p%p%p%p%p%p',
-+           b'%#0123456x%08x%x%s%p%d%n%o%u%c%h%l%q%j%z%Z%t%i%e%g%f%a%C%S%08x%%',
-+           b'%s x 129', b'%x x 257']
- def random_from_intervals(intervals):
-@@ -XXX,XX +XXX,XX @@ def random_bits(bit_ranges):
-     return val
--def truncate_string(strings, length):
--    """Return strings truncated to specified length."""
--    if type(strings) == list:
--        return [s[:length] for s in strings]
-+def truncate_bytes(sequences, length):
-+    """Return sequences truncated to specified length."""
-+    if type(sequences) == list:
-+        return [s[:length] for s in sequences]
-     else:
--        return strings[:length]
-+        return sequences[:length]
- def validator(current, pick, choices):
-@@ -XXX,XX +XXX,XX @@ def bit_validator(current, bit_ranges):
-     return validator(current, random_bits, bit_ranges)
--def string_validator(current, strings):
--    """Return a random string value from the list not equal to the current.
-+def bytes_validator(current, sequences):
-+    """Return a random bytes value from the list not equal to the current.
-     This function is useful for selection from valid values except current one.
-     """
--    return validator(current, random.choice, strings)
-+    return validator(current, random.choice, sequences)
- def selector(current, constraints, validate=int_validator):
-@@ -XXX,XX +XXX,XX @@ def header_length(current):
- def bf_name(current):
-     """Fuzz the backing file name."""
-     constraints = [
--        truncate_string(STRING_V, len(current))
-+        truncate_bytes(BYTES_V, len(current))
-     ]
--    return selector(current, constraints, string_validator)
-+    return selector(current, constraints, bytes_validator)
- def ext_magic(current):
-@@ -XXX,XX +XXX,XX @@ def ext_length(current):
- def bf_format(current):
-     """Fuzz backing file format in the corresponding header extension."""
-     constraints = [
--        truncate_string(STRING_V, len(current)),
--        truncate_string(STRING_V, (len(current) + 7) & ~7)  # Fuzz padding
-+        truncate_bytes(BYTES_V, len(current)),
-+        truncate_bytes(BYTES_V, (len(current) + 7) & ~7)  # Fuzz padding
-     ]
--    return selector(current, constraints, string_validator)
-+    return selector(current, constraints, bytes_validator)
- def feature_type(current):
-@@ -XXX,XX +XXX,XX @@ def feature_bit_number(current):
- def feature_name(current):
-     """Fuzz feature name field of a feature name table header extension."""
-     constraints = [
--        truncate_string(STRING_V, len(current)),
--        truncate_string(STRING_V, 46)  # Fuzz padding (field length = 46)
-+        truncate_bytes(BYTES_V, len(current)),
-+        truncate_bytes(BYTES_V, 46)  # Fuzz padding (field length = 46)
-     ]
--    return selector(current, constraints, string_validator)
-+    return selector(current, constraints, bytes_validator)
- def l1_entry(current):
---
-.23.0

-[PULL 11/11] image-fuzzer: Use OSerror.strerror instead of tuple subscript
+[PULL 1/5] util/async: add a human-readable name to BHs for debugging
-From: Eduardo Habkost <ehabkost@redhat.com>
+It can be difficult to debug issues with BHs in production environments.
 Although BHs can usually be identified by looking up their ->cb()
 function pointer, this requires debug information for the program. It is
 also not possible to print human-readable diagnostics about BHs because
 they have no identifier.
-OSError can't be used like a tuple on Python 3, so change the
+This patch adds a name to each BH. The name is not unique per instance
-code to use `e.sterror` instead of `e[1]`.
+but differentiates between cb() functions, which is usually enough. It's
 done by changing aio_bh_new() and friends to macros that stringify cb.
-Reported-by: John Snow <jsnow@redhat.com>
+The next patch will use the name field when reporting leaked BHs.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Message-id: 20191021214117.18091-1-ehabkost@redhat.com
 Message-Id: <20191021214117.18091-1-ehabkost@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+Message-Id: <20210414200247.917496-2-stefanha@redhat.com>
 ---
- tests/image-fuzzer/runner.py | 4 ++--
+ include/block/aio.h            | 31 ++++++++++++++++++++++++++++---
-file changed, 2 insertions(+), 2 deletions(-)
+ include/qemu/main-loop.h       |  4 +++-
  tests/unit/ptimer-test-stubs.c |  2 +-
  util/async.c                   |  9 +++++++--
  util/main-loop.c               |  4 ++--
 files changed, 41 insertions(+), 9 deletions(-)
-diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
+diff --git a/include/block/aio.h b/include/block/aio.h
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/runner.py
+--- a/include/block/aio.h
-+++ b/tests/image-fuzzer/runner.py
++++ b/include/block/aio.h
-@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
+@@ -XXX,XX +XXX,XX @@ void aio_context_acquire(AioContext *ctx);
-             os.makedirs(self.current_dir)
+ /* Relinquish ownership of the AioContext. */
-         except OSError as e:
+ void aio_context_release(AioContext *ctx);
-             print("Error: The working directory '%s' cannot be used. Reason: %s"\
--                % (self.work_dir, e[1]), file=sys.stderr)
++/**
-+                % (self.work_dir, e.strerror), file=sys.stderr)
++ * aio_bh_schedule_oneshot_full: Allocate a new bottom half structure that will
-             raise TestException
++ * run only once and as soon as possible.
-         self.log = open(os.path.join(self.current_dir, "test.log"), "w")
++ *
-         self.parent_log = open(run_log, "a")
++ * @name: A human-readable identifier for debugging purposes.
-@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
++ */
-             except OSError as e:
++void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
-                 multilog("%sError: Start of '%s' failed. Reason: %s\n\n"
++                                  const char *name);
-                          % (test_summary, os.path.basename(current_cmd[0]),
++
--                            e[1]),
+ /**
-+                            e.strerror),
+  * aio_bh_schedule_oneshot: Allocate a new bottom half structure that will run
-                          sys.stderr, self.log, self.parent_log)
+  * only once and as soon as possible.
-                 raise TestException
++ *
++ * A convenience wrapper for aio_bh_schedule_oneshot_full() that uses cb as the
 + * name string.
   */
 -void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
 +#define aio_bh_schedule_oneshot(ctx, cb, opaque) \
 +    aio_bh_schedule_oneshot_full((ctx), (cb), (opaque), (stringify(cb)))
  /**
 - * aio_bh_new: Allocate a new bottom half structure.
 + * aio_bh_new_full: Allocate a new bottom half structure.
   *
   * Bottom halves are lightweight callbacks whose invocation is guaranteed
   * to be wait-free, thread-safe and signal-safe.  The #QEMUBH structure
   * is opaque and must be allocated prior to its use.
 + *
 + * @name: A human-readable identifier for debugging purposes.
   */
 -QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
 +QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
 +                        const char *name);
 +
 +/**
 + * aio_bh_new: Allocate a new bottom half structure
 + *
 + * A convenience wrapper for aio_bh_new_full() that uses the cb as the name
 + * string.
 + */
 +#define aio_bh_new(ctx, cb, opaque) \
 +    aio_bh_new_full((ctx), (cb), (opaque), (stringify(cb)))
  /**
   * aio_notify: Force processing of pending events.
 diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/qemu/main-loop.h
 +++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@ void qemu_cond_timedwait_iothread(QemuCond *cond, int ms);
  void qemu_fd_register(int fd);
 -QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
 +#define qemu_bh_new(cb, opaque) \
 +    qemu_bh_new_full((cb), (opaque), (stringify(cb)))
 +QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name);
  void qemu_bh_schedule_idle(QEMUBH *bh);
  enum {
 diff --git a/tests/unit/ptimer-test-stubs.c b/tests/unit/ptimer-test-stubs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/unit/ptimer-test-stubs.c
 +++ b/tests/unit/ptimer-test-stubs.c
@@ -XXX,XX +XXX,XX @@ int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
      return deadline;
  }
 -QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
 +QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
  {
      QEMUBH *bh = g_new(QEMUBH, 1);
 diff --git a/util/async.c b/util/async.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/async.c
 +++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ enum {
  struct QEMUBH {
      AioContext *ctx;
 +    const char *name;
      QEMUBHFunc *cb;
      void *opaque;
      QSLIST_ENTRY(QEMUBH) next;
@@ -XXX,XX +XXX,XX @@ static QEMUBH *aio_bh_dequeue(BHList *head, unsigned *flags)
      return bh;
  }
 -void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
 +void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb,
 +                                  void *opaque, const char *name)
  {
      QEMUBH *bh;
      bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
          .ctx = ctx,
          .cb = cb,
          .opaque = opaque,
 +        .name = name,
      };
      aio_bh_enqueue(bh, BH_SCHEDULED | BH_ONESHOT);
  }
 -QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
 +QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
 +                        const char *name)
  {
      QEMUBH *bh;
      bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
          .ctx = ctx,
          .cb = cb,
          .opaque = opaque,
 +        .name = name,
      };
      return bh;
  }
 diff --git a/util/main-loop.c b/util/main-loop.c
 index XXXXXXX..XXXXXXX 100644
 --- a/util/main-loop.c
 +++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@ void main_loop_wait(int nonblocking)
  /* Functions to operate on the main QEMU AioContext.  */
 -QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
 +QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
  {
 -    return aio_bh_new(qemu_aio_context, cb, opaque);
 +    return aio_bh_new_full(qemu_aio_context, cb, opaque, name);
  }
  /*
 --
-.23.0
+.31.1

-[PULL 10/11] image-fuzzer: Use errors parameter of subprocess.Popen()
+[PULL 2/5] util/async: print leaked BH name when AioContext finalizes
-From: Eduardo Habkost <ehabkost@redhat.com>
+BHs must be deleted before the AioContext is finalized. If not, it's a
 bug and probably indicates that some part of the program still expects
 the BH to run in the future. That can lead to memory leaks, inconsistent
 state, or just hangs.
-Instead of manually encoding stderr and stdout output, use
+Unfortunately the assert(flags & BH_DELETED) call in aio_ctx_finalize()
-`errors` parameter of subprocess.Popen().  This will make
+is difficult to debug because the assertion failure contains no
-process.communicate() return unicode strings instead of bytes
+information about the BH!
 objects.
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
+Use the QEMUBH name field added in the previous patch to show a useful
-Reviewed-by: John Snow <jsnow@redhat.com>
+error when a leaked BH is detected.
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Message-id: 20191016192430.25098-11-ehabkost@redhat.com
+Suggested-by: Eric Ernst <eric.g.ernst@gmail.com>
 Message-Id: <20191016192430.25098-11-ehabkost@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
+Message-Id: <20210414200247.917496-3-stefanha@redhat.com>
 ---
- tests/image-fuzzer/runner.py | 11 ++++-------
+ util/async.c | 16 ++++++++++++++--
-file changed, 4 insertions(+), 7 deletions(-)
+file changed, 14 insertions(+), 2 deletions(-)
-diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
+diff --git a/util/async.c b/util/async.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/runner.py
+--- a/util/async.c
-+++ b/tests/image-fuzzer/runner.py
++++ b/util/async.c
-@@ -XXX,XX +XXX,XX @@ def run_app(fd, q_args):
+@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
-     devnull = open('/dev/null', 'r+')
+     assert(QSIMPLEQ_EMPTY(&ctx->bh_slice_list));
-     process = subprocess.Popen(q_args, stdin=devnull,
-                                stdout=subprocess.PIPE,
+     while ((bh = aio_bh_dequeue(&ctx->bh_list, &flags))) {
--                               stderr=subprocess.PIPE)
+-        /* qemu_bh_delete() must have been called on BHs in this AioContext */
-+                               stderr=subprocess.PIPE,
+-        assert(flags & BH_DELETED);
-+                               errors='replace')
++        /*
-     try:
++         * qemu_bh_delete() must have been called on BHs in this AioContext. In
-         out, err = process.communicate()
++         * many cases memory leaks, hangs, or inconsistent state occur when a
-         signal.alarm(0)
++         * BH is leaked because something still expects it to run.
--        # fd is a text file, so we need to decode the process output before
++         *
--        # writing to it.
++         * If you hit this, fix the lifecycle of the BH so that
--        # We could be simply using the `errors` parameter of subprocess.Popen(),
++         * qemu_bh_delete() and any associated cleanup is called before the
--        # but this will be possible only after migrating to Python 3
++         * AioContext is finalized.
--        fd.write(out.decode(errors='replace'))
++         */
--        fd.write(err.decode(errors='replace'))
++        if (unlikely(!(flags & BH_DELETED))) {
-+        fd.write(out)
++            fprintf(stderr, "%s: BH '%s' leaked, aborting...\n",
-+        fd.write(err)
++                    __func__, bh->name);
-         fd.flush()
++            abort();
-         return process.returncode
++        }
          g_free(bh);
      }
 --
-.23.0
+.31.1

-[PULL 09/11] image-fuzzer: Run using python3
+[PULL 3/5] block/file-posix: Optimize for macOS
-From: Eduardo Habkost <ehabkost@redhat.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-image-fuzzer is now supposed to be ready to run using Python 3.
+This commit introduces "punch hole" operation and optimizes transfer
-Remove the __future__ imports and change the interpreter line to
+block size for macOS.
 "#!/usr/bin/env python3".
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
+Thanks to Konstantin Nazarov for detailed analysis of a flaw in an
-Reviewed-by: John Snow <jsnow@redhat.com>
+old version of this change:
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+https://gist.github.com/akihikodaki/87df4149e7ca87f18dc56807ec5a1bc5#gistcomment-3654667
-Message-id: 20191016192430.25098-10-ehabkost@redhat.com
-Message-Id: <20191016192430.25098-10-ehabkost@redhat.com>
+Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Message-id: 20210705130458.97642-1-akihiko.odaki@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/image-fuzzer/qcow2/__init__.py | 1 -
+ block/file-posix.c | 27 +++++++++++++++++++++++++--
- tests/image-fuzzer/qcow2/layout.py   | 1 -
+file changed, 25 insertions(+), 2 deletions(-)
  tests/image-fuzzer/runner.py         | 3 +--
 files changed, 1 insertion(+), 4 deletions(-)
-diff --git a/tests/image-fuzzer/qcow2/__init__.py b/tests/image-fuzzer/qcow2/__init__.py
+diff --git a/block/file-posix.c b/block/file-posix.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/__init__.py
+--- a/block/file-posix.c
-+++ b/tests/image-fuzzer/qcow2/__init__.py
++++ b/block/file-posix.c
@@ -1,2 +1 @@
 -from __future__ import absolute_import
  from .layout import create_image
 diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/image-fuzzer/qcow2/layout.py
 +++ b/tests/image-fuzzer/qcow2/layout.py
 @@ -XXX,XX +XXX,XX @@
- # along with this program.  If not, see <http://www.gnu.org/licenses/>.
+ #if defined(HAVE_HOST_BLOCK_DEVICE)
- #
+ #include <paths.h>
+ #include <sys/param.h>
--from __future__ import absolute_import
++#include <sys/mount.h>
- import random
+ #include <IOKit/IOKitLib.h>
- import struct
+ #include <IOKit/IOBSD.h>
- from . import fuzz
+ #include <IOKit/storage/IOMediaBSDClient.h>
-diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
+@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
-index XXXXXXX..XXXXXXX 100755
+         return;
---- a/tests/image-fuzzer/runner.py
+     }
-+++ b/tests/image-fuzzer/runner.py
-@@ -XXX,XX +XXX,XX @@
++#if defined(__APPLE__) && (__MACH__)
--#!/usr/bin/env python
++    struct statfs buf;
-+#!/usr/bin/env python3
++
++    if (!fstatfs(s->fd, &buf)) {
- # Tool for running fuzz tests
++        bs->bl.opt_transfer = buf.f_iosize;
- #
++        bs->bl.pdiscard_alignment = buf.f_bsize;
-@@ -XXX,XX +XXX,XX @@
++    }
- # along with this program.  If not, see <http://www.gnu.org/licenses/>.
++#endif
- #
++
+     if (bs->sg || S_ISBLK(st.st_mode)) {
--from __future__ import print_function
+         int ret = hdev_get_max_hw_transfer(s->fd, &st);
- import sys
- import os
+@@ -XXX,XX +XXX,XX @@ out:
- import signal
+     }
  }
 +#if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
  static int translate_err(int err)
  {
      if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
@@ -XXX,XX +XXX,XX @@ static int translate_err(int err)
      }
      return err;
  }
 +#endif
  #ifdef CONFIG_FALLOCATE
  static int do_fallocate(int fd, int mode, off_t offset, off_t len)
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
              }
          } while (errno == EINTR);
 -        ret = -errno;
 +        ret = translate_err(-errno);
  #endif
      } else {
  #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
          ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
                             aiocb->aio_offset, aiocb->aio_nbytes);
 +        ret = translate_err(-errno);
 +#elif defined(__APPLE__) && (__MACH__)
 +        fpunchhole_t fpunchhole;
 +        fpunchhole.fp_flags = 0;
 +        fpunchhole.reserved = 0;
 +        fpunchhole.fp_offset = aiocb->aio_offset;
 +        fpunchhole.fp_length = aiocb->aio_nbytes;
 +        if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
 +            ret = errno == ENODEV ? -ENOTSUP : -errno;
 +        } else {
 +            ret = 0;
 +        }
  #endif
      }
 -    ret = translate_err(ret);
      if (ret == -ENOTSUP) {
          s->has_discard = false;
      }
 --
-.23.0
+.31.1

-[PULL 08/11] image-fuzzer: Encode file name and file format to bytes
+[PULL 4/5] block: Add backend_defaults property
-From: Eduardo Habkost <ehabkost@redhat.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-Callers of create_image() will pass strings as arguments, but the
+backend_defaults property allow users to control if default block
-Image class will expect bytes objects to be provided.  Encode
+properties should be decided with backend information.
-them inside create_image().
+If it is off, any backend information will be discarded, which is
-Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
+suitable if you plan to perform live migration to a different disk backend.
-Reviewed-by: John Snow <jsnow@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
+If it is on, a block device may utilize backend information more
-Message-id: 20191016192430.25098-9-ehabkost@redhat.com
+aggressively.
-Message-Id: <20191016192430.25098-9-ehabkost@redhat.com>
 By default, it is auto, which uses backend information for block
 sizes and ignores the others, which is consistent with the older
 versions.
 Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
 Message-id: 20210705130458.97642-2-akihiko.odaki@gmail.com
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/image-fuzzer/qcow2/layout.py | 4 ++--
+ include/hw/block/block.h   |  3 +++
-file changed, 2 insertions(+), 2 deletions(-)
+ hw/block/block.c           | 42 ++++++++++++++++++++++++++++++++++----
+ tests/qemu-iotests/172.out | 38 ++++++++++++++++++++++++++++++++++
-diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
+files changed, 79 insertions(+), 4 deletions(-)
 diff --git a/include/hw/block/block.h b/include/hw/block/block.h
 index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/layout.py
+--- a/include/hw/block/block.h
-+++ b/tests/image-fuzzer/qcow2/layout.py
++++ b/include/hw/block/block.h
-@@ -XXX,XX +XXX,XX @@ class Image(object):
+@@ -XXX,XX +XXX,XX @@
- def create_image(test_img_path, backing_file_name=None, backing_file_fmt=None,
-                  fields_to_fuzz=None):
+ typedef struct BlockConf {
-     """Create a fuzzed image and write it to the specified file."""
+     BlockBackend *blk;
--    image = Image(backing_file_name)
++    OnOffAuto backend_defaults;
--    image.set_backing_file_format(backing_file_fmt)
+     uint32_t physical_block_size;
-+    image = Image(backing_file_name.encode())
+     uint32_t logical_block_size;
-+    image.set_backing_file_format(backing_file_fmt.encode())
+     uint32_t min_io_size;
-     image.create_feature_name_table()
+@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
-     image.set_end_of_extension_area()
+ }
-     image.create_l_structures()
  #define DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf)                     \
 +    DEFINE_PROP_ON_OFF_AUTO("backend_defaults", _state,                 \
 +                            _conf.backend_defaults, ON_OFF_AUTO_AUTO),  \
      DEFINE_PROP_BLOCKSIZE("logical_block_size", _state,                 \
                            _conf.logical_block_size),                    \
      DEFINE_PROP_BLOCKSIZE("physical_block_size", _state,                \
 diff --git a/hw/block/block.c b/hw/block/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/hw/block/block.c
 +++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp)
  {
      BlockBackend *blk = conf->blk;
      BlockSizes blocksizes;
 -    int backend_ret;
 +    BlockDriverState *bs;
 +    bool use_blocksizes;
 +    bool use_bs;
 +
 +    switch (conf->backend_defaults) {
 +    case ON_OFF_AUTO_AUTO:
 +        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
 +        use_bs = false;
 +        break;
 +
 +    case ON_OFF_AUTO_ON:
 +        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
 +        bs = blk_bs(blk);
 +        use_bs = bs;
 +        break;
 +
 +    case ON_OFF_AUTO_OFF:
 +        use_blocksizes = false;
 +        use_bs = false;
 +        break;
 +
 +    default:
 +        abort();
 +    }
 -    backend_ret = blk_probe_blocksizes(blk, &blocksizes);
      /* fill in detected values if they are not defined via qemu command line */
      if (!conf->physical_block_size) {
 -        if (!backend_ret) {
 +        if (use_blocksizes) {
             conf->physical_block_size = blocksizes.phys;
          } else {
              conf->physical_block_size = BDRV_SECTOR_SIZE;
          }
      }
      if (!conf->logical_block_size) {
 -        if (!backend_ret) {
 +        if (use_blocksizes) {
              conf->logical_block_size = blocksizes.log;
          } else {
              conf->logical_block_size = BDRV_SECTOR_SIZE;
          }
      }
 +    if (use_bs) {
 +        if (!conf->opt_io_size) {
 +            conf->opt_io_size = bs->bl.opt_transfer;
 +        }
 +        if (conf->discard_granularity == -1) {
 +            if (bs->bl.pdiscard_alignment) {
 +                conf->discard_granularity = bs->bl.pdiscard_alignment;
 +            } else if (bs->bl.request_alignment != 1) {
 +                conf->discard_granularity = bs->bl.request_alignment;
 +            }
 +        }
 +    }
      if (conf->logical_block_size > conf->physical_block_size) {
          error_setg(errp,
 diff --git a/tests/qemu-iotests/172.out b/tests/qemu-iotests/172.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/172.out
 +++ b/tests/qemu-iotests/172.out
@@ -XXX,XX +XXX,XX @@ Testing:
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,unit=1
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "floppy1"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 1 (0x1)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "floppy0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -global floppy.drive=none0 -device
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=120
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=144
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=288
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = ""
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,logical
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,physica
                dev: floppy, id ""
                  unit = 0 (0x0)
                  drive = "none0"
 +                backend_defaults = "auto"
                  logical_block_size = 512 (512 B)
                  physical_block_size = 512 (512 B)
                  min_io_size = 0 (0 B)
 --
-.23.0
+.31.1

-[PULL 07/11] image-fuzzer: Use bytes constant for field values
+[PULL 5/5] block/io: Merge discard request alignments
-From: Eduardo Habkost <ehabkost@redhat.com>
+From: Akihiko Odaki <akihiko.odaki@gmail.com>
-Field values are supposed to be bytes objects, not unicode
+Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
-strings.  Change two constants that were declared as strings.
+Message-id: 20210705130458.97642-3-akihiko.odaki@gmail.com
 Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 Message-id: 20191016192430.25098-8-ehabkost@redhat.com
 Message-Id: <20191016192430.25098-8-ehabkost@redhat.com>
 Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
 ---
- tests/image-fuzzer/qcow2/layout.py | 4 ++--
+ block/io.c | 2 ++
-file changed, 2 insertions(+), 2 deletions(-)
+file changed, 2 insertions(+)
-diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
+diff --git a/block/io.c b/block/io.c
 index XXXXXXX..XXXXXXX 100644
---- a/tests/image-fuzzer/qcow2/layout.py
+--- a/block/io.c
-+++ b/tests/image-fuzzer/qcow2/layout.py
++++ b/block/io.c
-@@ -XXX,XX +XXX,XX @@ class Image(object):
+@@ -XXX,XX +XXX,XX @@ void bdrv_parent_drained_begin_single(BdrvChild *c, bool poll)
-     def create_header(self, cluster_bits, backing_file_name=None):
-         """Generate a random valid header."""
+ static void bdrv_merge_limits(BlockLimits *dst, const BlockLimits *src)
-         meta_header = [
+ {
--            ['>4s', 0, "QFI\xfb", 'magic'],
++    dst->pdiscard_alignment = MAX(dst->pdiscard_alignment,
-+            ['>4s', 0, b"QFI\xfb", 'magic'],
++                                  src->pdiscard_alignment);
-             ['>I', 4, random.randint(2, 3), 'version'],
+     dst->opt_transfer = MAX(dst->opt_transfer, src->opt_transfer);
-             ['>Q', 8, 0, 'backing_file_offset'],
+     dst->max_transfer = MIN_NON_ZERO(dst->max_transfer, src->max_transfer);
-             ['>I', 16, 0, 'backing_file_size'],
+     dst->max_hw_transfer = MIN_NON_ZERO(dst->max_hw_transfer,
@@ -XXX,XX +XXX,XX @@ class Image(object):
              feature_tables = []
              feature_ids = []
              inner_offset = self.ext_offset + ext_header_len
 -            feat_name = 'some cool feature'
 +            feat_name = b'some cool feature'
              while len(feature_tables) < num_fnt_entries * 3:
                  feat_type, feat_bit = gen_feat_ids()
                  # Remove duplicates
 --
-.23.0
+.31.1

The following changes since commit 36609b4fa36f0ac934874371874416f7533a5408:

Merge remote-tracking branch 'remotes/palmer/tags/palmer-for-master-4.2-sf1' into staging (2019-11-02 17:59:03 +0000)

are available in the Git repository at:

https://github.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 9fdd7860adec188ed50d2530e9a819e8d953f9bb:

image-fuzzer: Use OSerror.strerror instead of tuple subscript (2019-11-05 16:36:11 +0100)

----------------------------------------------------------------
Pull request

Let's get the image fuzzer Python 3 changes merged in QEMU 4.2.

----------------------------------------------------------------

Eduardo Habkost (11):
  image-fuzzer: Open image files in binary mode
  image-fuzzer: Write bytes instead of string to image file
  image-fuzzer: Explicitly use integer division operator
  image-fuzzer: Use io.StringIO
  image-fuzzer: Use %r for all fiels at Field.__repr__()
  image-fuzzer: Return bytes objects on string fuzzing functions
  image-fuzzer: Use bytes constant for field values
  image-fuzzer: Encode file name and file format to bytes
  image-fuzzer: Run using python3
  image-fuzzer: Use errors parameter of subprocess.Popen()
  image-fuzzer: Use OSerror.strerror instead of tuple subscript

tests/image-fuzzer/qcow2/__init__.py |  1 -
 tests/image-fuzzer/qcow2/fuzz.py     | 54 +++++++++++++-------------
 tests/image-fuzzer/qcow2/layout.py   | 57 ++++++++++++++--------------
 tests/image-fuzzer/runner.py         | 16 ++++----
 4 files changed, 63 insertions(+), 65 deletions(-)

-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

This probably never caused problems because on Linux there's no
actual newline conversion happening, but on Python 3 the
binary/text distinction is stronger and we must explicitly open
the image file in binary mode.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-2-ehabkost@redhat.com
Message-Id: <20191016192430.25098-2-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/layout.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

From: Eduardo Habkost <ehabkost@redhat.com>

This is necessary for Python 3 compatibility.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-3-ehabkost@redhat.com
Message-Id: <20191016192430.25098-3-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/layout.py | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

From: Eduardo Habkost <ehabkost@redhat.com>

Most of the division expressions in image-fuzzer assume integer
division.  Use the // operator to keep the same behavior when we
move to Python 3.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-4-ehabkost@redhat.com
Message-Id: <20191016192430.25098-4-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/fuzz.py   | 12 ++++-----
 tests/image-fuzzer/qcow2/layout.py | 40 +++++++++++++++---------------
 2 files changed, 26 insertions(+), 26 deletions(-)

diff --git a/tests/image-fuzzer/qcow2/fuzz.py b/tests/image-fuzzer/qcow2/fuzz.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/image-fuzzer/qcow2/fuzz.py
+++ b/tests/image-fuzzer/qcow2/fuzz.py
@@ -XXX,XX +XXX,XX @@ UINT64 = 0xffffffffffffffff
 UINT32_M = 31
 UINT64_M = 63
 # Fuzz vectors
-UINT8_V = [0, 0x10, UINT8/4, UINT8/2 - 1, UINT8/2, UINT8/2 + 1, UINT8 - 1,
+UINT8_V = [0, 0x10, UINT8//4, UINT8//2 - 1, UINT8//2, UINT8//2 + 1, UINT8 - 1,
            UINT8]
-UINT16_V = [0, 0x100, 0x1000, UINT16/4, UINT16/2 - 1, UINT16/2, UINT16/2 + 1,
+UINT16_V = [0, 0x100, 0x1000, UINT16//4, UINT16//2 - 1, UINT16//2, UINT16//2 + 1,
             UINT16 - 1, UINT16]
-UINT32_V = [0, 0x100, 0x1000, 0x10000, 0x100000, UINT32/4, UINT32/2 - 1,
-            UINT32/2, UINT32/2 + 1, UINT32 - 1, UINT32]
-UINT64_V = UINT32_V + [0x1000000, 0x10000000, 0x100000000, UINT64/4,
-                       UINT64/2 - 1, UINT64/2, UINT64/2 + 1, UINT64 - 1,
+UINT32_V = [0, 0x100, 0x1000, 0x10000, 0x100000, UINT32//4, UINT32//2 - 1,
+            UINT32//2, UINT32//2 + 1, UINT32 - 1, UINT32]
+UINT64_V = UINT32_V + [0x1000000, 0x10000000, 0x100000000, UINT64//4,
+                       UINT64//2 - 1, UINT64//2, UINT64//2 + 1, UINT64 - 1,
                        UINT64]
 STRING_V = ['%s%p%x%d', '.1024d', '%.2049d', '%p%p%p%p', '%x%x%x%x',
             '%d%d%d%d', '%s%s%s%s', '%99999999999s', '%08x', '%%20d', '%%20n',
diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/image-fuzzer/qcow2/layout.py
+++ b/tests/image-fuzzer/qcow2/layout.py
@@ -XXX,XX +XXX,XX @@ class Image(object):
                 ['>I', self.ext_offset, 0x6803f857, 'ext_magic'],
                 # One feature table contains 3 fields and takes 48 bytes
                 ['>I', self.ext_offset + UINT32_S,
-                 len(feature_tables) / 3 * 48, 'ext_length']
+                 len(feature_tables) // 3 * 48, 'ext_length']
             ] + feature_tables)
             self.ext_offset = inner_offset
 
@@ -XXX,XX +XXX,XX @@ class Image(object):
         def create_l2_entry(host, guest, l2_cluster):
             """Generate one L2 entry."""
             offset = l2_cluster * self.cluster_size
-            l2_size = self.cluster_size / UINT64_S
+            l2_size = self.cluster_size // UINT64_S
             entry_offset = offset + UINT64_S * (guest % l2_size)
             cluster_descriptor = host * self.cluster_size
             if not self.header['version'][0].value == 2:
@@ -XXX,XX +XXX,XX @@ class Image(object):
 
         def create_l1_entry(l2_cluster, l1_offset, guest):
             """Generate one L1 entry."""
-            l2_size = self.cluster_size / UINT64_S
-            entry_offset = l1_offset + UINT64_S * (guest / l2_size)
+            l2_size = self.cluster_size // UINT64_S
+            entry_offset = l1_offset + UINT64_S * (guest // l2_size)
             # While snapshots are not supported bit #63 = 1
             entry_val = (1 << 63) + l2_cluster * self.cluster_size
             return ['>Q', entry_offset, entry_val, 'l1_entry']
@@ -XXX,XX +XXX,XX @@ class Image(object):
             l2 = []
         else:
             meta_data = self._get_metadata()
-            guest_clusters = random.sample(range(self.image_size /
+            guest_clusters = random.sample(range(self.image_size //
                                                  self.cluster_size),
                                            len(self.data_clusters))
             # Number of entries in a L1/L2 table
-            l_size = self.cluster_size / UINT64_S
+            l_size = self.cluster_size // UINT64_S
             # Number of clusters necessary for L1 table
             l1_size = int(ceil((max(guest_clusters) + 1) / float(l_size**2)))
             l1_start = self._get_adjacent_clusters(self.data_clusters |
@@ -XXX,XX +XXX,XX @@ class Image(object):
             # L2 entries
             l2 = []
             for host, guest in zip(self.data_clusters, guest_clusters):
-                l2_id = guest / l_size
+                l2_id = guest // l_size
                 if l2_id not in l2_ids:
                     l2_ids.append(l2_id)
                     l2_clusters.append(self._get_adjacent_clusters(
@@ -XXX,XX +XXX,XX @@ class Image(object):
         def allocate_rfc_blocks(data, size):
             """Return indices of clusters allocated for refcount blocks."""
             cluster_ids = set()
-            diff = block_ids = set([x / size for x in data])
+            diff = block_ids = set([x // size for x in data])
             while len(diff) != 0:
                 # Allocate all yet not allocated clusters
                 new = self._get_available_clusters(data | cluster_ids,
                                                    len(diff))
                 # Indices of new refcount blocks necessary to cover clusters
                 # in 'new'
-                diff = set([x / size for x in new]) - block_ids
+                diff = set([x // size for x in new]) - block_ids
                 cluster_ids |= new
                 block_ids |= diff
             return cluster_ids, block_ids
@@ -XXX,XX +XXX,XX @@ class Image(object):
             blocks = set(init_blocks)
             clusters = set()
             # Number of entries in one cluster of the refcount table
-            size = self.cluster_size / UINT64_S
+            size = self.cluster_size // UINT64_S
             # Number of clusters necessary for the refcount table based on
             # the current number of refcount blocks
             table_size = int(ceil((max(blocks) + 1) / float(size)))
@@ -XXX,XX +XXX,XX @@ class Image(object):
                                                  table_size + 1))
             # New refcount blocks necessary for clusters occupied by the
             # refcount table
-            diff = set([c / block_size for c in table_clusters]) - blocks
+            diff = set([c // block_size for c in table_clusters]) - blocks
             blocks |= diff
             while len(diff) != 0:
                 # Allocate clusters for new refcount blocks
@@ -XXX,XX +XXX,XX @@ class Image(object):
                                                    len(diff))
                 # Indices of new refcount blocks necessary to cover
                 # clusters in 'new'
-                diff = set([x / block_size for x in new]) - blocks
+                diff = set([x // block_size for x in new]) - blocks
                 clusters |= new
                 blocks |= diff
                 # Check if the refcount table needs one more cluster
                 if int(ceil((max(blocks) + 1) / float(size))) > table_size:
-                    new_block_id = (table_start + table_size) / block_size
+                    new_block_id = (table_start + table_size) // block_size
                     # Check if the additional table cluster needs
                     # one more refcount block
                     if new_block_id not in blocks:
@@ -XXX,XX +XXX,XX @@ class Image(object):
         def create_table_entry(table_offset, block_cluster, block_size,
                                cluster):
             """Generate a refcount table entry."""
-            offset = table_offset + UINT64_S * (cluster / block_size)
+            offset = table_offset + UINT64_S * (cluster // block_size)
             return ['>Q', offset, block_cluster * self.cluster_size,
                     'refcount_table_entry']
 
         def create_block_entry(block_cluster, block_size, cluster):
             """Generate a list of entries for the current block."""
-            entry_size = self.cluster_size / block_size
+            entry_size = self.cluster_size // block_size
             offset = block_cluster * self.cluster_size
             entry_offset = offset + entry_size * (cluster % block_size)
             # While snapshots are not supported all refcounts are set to 1
@@ -XXX,XX +XXX,XX @@ class Image(object):
         # Number of refcount entries per refcount block
         # Convert self.cluster_size from bytes to bits to have the same
         # base for the numerator and denominator
-        block_size = self.cluster_size * 8 / refcount_bits
+        block_size = self.cluster_size * 8 // refcount_bits
         meta_data = self._get_metadata()
         if len(self.data_clusters) == 0:
             # All metadata for an empty guest image needs 4 clusters:
@@ -XXX,XX +XXX,XX @@ class Image(object):
         rfc_blocks = []
 
         for cluster in sorted(self.data_clusters | meta_data):
-            if cluster / block_size != block_id:
-                block_id = cluster / block_size
+            if cluster // block_size != block_id:
+                block_id = cluster // block_size
                 block_cluster = block_clusters[block_ids.index(block_id)]
                 rfc_table.append(create_table_entry(table_offset,
                                                     block_cluster,
@@ -XXX,XX +XXX,XX @@ class Image(object):
     def _alloc_data(img_size, cluster_size):
         """Return a set of random indices of clusters allocated for guest data.
         """
-        num_of_cls = img_size/cluster_size
+        num_of_cls = img_size // cluster_size
         return set(random.sample(range(1, num_of_cls + 1),
                                  random.randint(0, num_of_cls)))
 
@@ -XXX,XX +XXX,XX @@ class Image(object):
         """Return indices of clusters allocated for image metadata."""
         ids = set()
         for x in self:
-            ids.add(x.offset/self.cluster_size)
+            ids.add(x.offset // self.cluster_size)
         return ids
 
 
-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

StringIO.StringIO is not available on Python 3, but io.StringIO
is available on both Python 2 and 3.  io.StringIO is slightly
different from the Python 2 StringIO module, though, so we need
bytes coming from subprocess.Popen() to be explicitly decoded.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-5-ehabkost@redhat.com
Message-Id: <20191016192430.25098-5-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/runner.py | 14 +++++++++-----
 1 file changed, 9 insertions(+), 5 deletions(-)

diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
index XXXXXXX..XXXXXXX 100755
--- a/tests/image-fuzzer/runner.py
+++ b/tests/image-fuzzer/runner.py
@@ -XXX,XX +XXX,XX @@ import shutil
 from itertools import count
 import time
 import getopt
-import StringIO
+import io
 import resource
 
 try:
@@ -XXX,XX +XXX,XX @@ def run_app(fd, q_args):
     try:
         out, err = process.communicate()
         signal.alarm(0)
-        fd.write(out)
-        fd.write(err)
+        # fd is a text file, so we need to decode the process output before
+        # writing to it.
+        # We could be simply using the `errors` parameter of subprocess.Popen(),
+        # but this will be possible only after migrating to Python 3
+        fd.write(out.decode(errors='replace'))
+        fd.write(err.decode(errors='replace'))
         fd.flush()
         return process.returncode
 
@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
                                            MAX_BACKING_FILE_SIZE) * (1 << 20)
         cmd = self.qemu_img + ['create', '-f', backing_file_fmt,
                                backing_file_name, str(backing_file_size)]
-        temp_log = StringIO.StringIO()
+        temp_log = io.StringIO()
         retcode = run_app(temp_log, cmd)
         if retcode == 0:
             temp_log.close()
@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
                            "Backing file: %s\n" \
                            % (self.seed, " ".join(current_cmd),
                               self.current_dir, backing_file_name)
-            temp_log = StringIO.StringIO()
+            temp_log = io.StringIO()
             try:
                 retcode = run_app(temp_log, current_cmd)
             except OSError as e:
-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

This makes the formatting code simpler, and safer if we change
the type of self.value from str to bytes.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-6-ehabkost@redhat.com
Message-Id: <20191016192430.25098-6-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/layout.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

From: Eduardo Habkost <ehabkost@redhat.com>

No caller of fuzzer functions is interested in unicode string values,
so replace them with bytes sequences.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-7-ehabkost@redhat.com
Message-Id: <20191016192430.25098-7-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/fuzz.py | 42 ++++++++++++++++----------------
 1 file changed, 21 insertions(+), 21 deletions(-)

diff --git a/tests/image-fuzzer/qcow2/fuzz.py b/tests/image-fuzzer/qcow2/fuzz.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/image-fuzzer/qcow2/fuzz.py
+++ b/tests/image-fuzzer/qcow2/fuzz.py
@@ -XXX,XX +XXX,XX @@ UINT32_V = [0, 0x100, 0x1000, 0x10000, 0x100000, UINT32//4, UINT32//2 - 1,
 UINT64_V = UINT32_V + [0x1000000, 0x10000000, 0x100000000, UINT64//4,
                        UINT64//2 - 1, UINT64//2, UINT64//2 + 1, UINT64 - 1,
                        UINT64]
-STRING_V = ['%s%p%x%d', '.1024d', '%.2049d', '%p%p%p%p', '%x%x%x%x',
-            '%d%d%d%d', '%s%s%s%s', '%99999999999s', '%08x', '%%20d', '%%20n',
-            '%%20x', '%%20s', '%s%s%s%s%s%s%s%s%s%s', '%p%p%p%p%p%p%p%p%p%p',
-            '%#0123456x%08x%x%s%p%d%n%o%u%c%h%l%q%j%z%Z%t%i%e%g%f%a%C%S%08x%%',
-            '%s x 129', '%x x 257']
+BYTES_V = [b'%s%p%x%d', b'.1024d', b'%.2049d', b'%p%p%p%p', b'%x%x%x%x',
+           b'%d%d%d%d', b'%s%s%s%s', b'%99999999999s', b'%08x', b'%%20d', b'%%20n',
+           b'%%20x', b'%%20s', b'%s%s%s%s%s%s%s%s%s%s', b'%p%p%p%p%p%p%p%p%p%p',
+           b'%#0123456x%08x%x%s%p%d%n%o%u%c%h%l%q%j%z%Z%t%i%e%g%f%a%C%S%08x%%',
+           b'%s x 129', b'%x x 257']
 
 
 def random_from_intervals(intervals):
@@ -XXX,XX +XXX,XX @@ def random_bits(bit_ranges):
     return val
 
 
-def truncate_string(strings, length):
-    """Return strings truncated to specified length."""
-    if type(strings) == list:
-        return [s[:length] for s in strings]
+def truncate_bytes(sequences, length):
+    """Return sequences truncated to specified length."""
+    if type(sequences) == list:
+        return [s[:length] for s in sequences]
     else:
-        return strings[:length]
+        return sequences[:length]
 
 
 def validator(current, pick, choices):
@@ -XXX,XX +XXX,XX @@ def bit_validator(current, bit_ranges):
     return validator(current, random_bits, bit_ranges)
 
 
-def string_validator(current, strings):
-    """Return a random string value from the list not equal to the current.
+def bytes_validator(current, sequences):
+    """Return a random bytes value from the list not equal to the current.
 
     This function is useful for selection from valid values except current one.
     """
-    return validator(current, random.choice, strings)
+    return validator(current, random.choice, sequences)
 
 
 def selector(current, constraints, validate=int_validator):
@@ -XXX,XX +XXX,XX @@ def header_length(current):
 def bf_name(current):
     """Fuzz the backing file name."""
     constraints = [
-        truncate_string(STRING_V, len(current))
+        truncate_bytes(BYTES_V, len(current))
     ]
-    return selector(current, constraints, string_validator)
+    return selector(current, constraints, bytes_validator)
 
 
 def ext_magic(current):
@@ -XXX,XX +XXX,XX @@ def ext_length(current):
 def bf_format(current):
     """Fuzz backing file format in the corresponding header extension."""
     constraints = [
-        truncate_string(STRING_V, len(current)),
-        truncate_string(STRING_V, (len(current) + 7) & ~7)  # Fuzz padding
+        truncate_bytes(BYTES_V, len(current)),
+        truncate_bytes(BYTES_V, (len(current) + 7) & ~7)  # Fuzz padding
     ]
-    return selector(current, constraints, string_validator)
+    return selector(current, constraints, bytes_validator)
 
 
 def feature_type(current):
@@ -XXX,XX +XXX,XX @@ def feature_bit_number(current):
 def feature_name(current):
     """Fuzz feature name field of a feature name table header extension."""
     constraints = [
-        truncate_string(STRING_V, len(current)),
-        truncate_string(STRING_V, 46)  # Fuzz padding (field length = 46)
+        truncate_bytes(BYTES_V, len(current)),
+        truncate_bytes(BYTES_V, 46)  # Fuzz padding (field length = 46)
     ]
-    return selector(current, constraints, string_validator)
+    return selector(current, constraints, bytes_validator)
 
 
 def l1_entry(current):
-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

Field values are supposed to be bytes objects, not unicode
strings.  Change two constants that were declared as strings.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-8-ehabkost@redhat.com
Message-Id: <20191016192430.25098-8-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/layout.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/image-fuzzer/qcow2/layout.py
+++ b/tests/image-fuzzer/qcow2/layout.py
@@ -XXX,XX +XXX,XX @@ class Image(object):
     def create_header(self, cluster_bits, backing_file_name=None):
         """Generate a random valid header."""
         meta_header = [
-            ['>4s', 0, "QFI\xfb", 'magic'],
+            ['>4s', 0, b"QFI\xfb", 'magic'],
             ['>I', 4, random.randint(2, 3), 'version'],
             ['>Q', 8, 0, 'backing_file_offset'],
             ['>I', 16, 0, 'backing_file_size'],
@@ -XXX,XX +XXX,XX @@ class Image(object):
             feature_tables = []
             feature_ids = []
             inner_offset = self.ext_offset + ext_header_len
-            feat_name = 'some cool feature'
+            feat_name = b'some cool feature'
             while len(feature_tables) < num_fnt_entries * 3:
                 feat_type, feat_bit = gen_feat_ids()
                 # Remove duplicates
-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

Callers of create_image() will pass strings as arguments, but the
Image class will expect bytes objects to be provided.  Encode
them inside create_image().

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-9-ehabkost@redhat.com
Message-Id: <20191016192430.25098-9-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/layout.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/image-fuzzer/qcow2/layout.py
+++ b/tests/image-fuzzer/qcow2/layout.py
@@ -XXX,XX +XXX,XX @@ class Image(object):
 def create_image(test_img_path, backing_file_name=None, backing_file_fmt=None,
                  fields_to_fuzz=None):
     """Create a fuzzed image and write it to the specified file."""
-    image = Image(backing_file_name)
-    image.set_backing_file_format(backing_file_fmt)
+    image = Image(backing_file_name.encode())
+    image.set_backing_file_format(backing_file_fmt.encode())
     image.create_feature_name_table()
     image.set_end_of_extension_area()
     image.create_l_structures()
-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

image-fuzzer is now supposed to be ready to run using Python 3.
Remove the __future__ imports and change the interpreter line to
"#!/usr/bin/env python3".

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-10-ehabkost@redhat.com
Message-Id: <20191016192430.25098-10-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/qcow2/__init__.py | 1 -
 tests/image-fuzzer/qcow2/layout.py   | 1 -
 tests/image-fuzzer/runner.py         | 3 +--
 3 files changed, 1 insertion(+), 4 deletions(-)

diff --git a/tests/image-fuzzer/qcow2/__init__.py b/tests/image-fuzzer/qcow2/__init__.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/image-fuzzer/qcow2/__init__.py
+++ b/tests/image-fuzzer/qcow2/__init__.py
@@ -1,2 +1 @@
-from __future__ import absolute_import
 from .layout import create_image
diff --git a/tests/image-fuzzer/qcow2/layout.py b/tests/image-fuzzer/qcow2/layout.py
index XXXXXXX..XXXXXXX 100644
--- a/tests/image-fuzzer/qcow2/layout.py
+++ b/tests/image-fuzzer/qcow2/layout.py
@@ -XXX,XX +XXX,XX @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from __future__ import absolute_import
 import random
 import struct
 from . import fuzz
diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
index XXXXXXX..XXXXXXX 100755
--- a/tests/image-fuzzer/runner.py
+++ b/tests/image-fuzzer/runner.py
@@ -XXX,XX +XXX,XX @@
-#!/usr/bin/env python
+#!/usr/bin/env python3
 
 # Tool for running fuzz tests
 #
@@ -XXX,XX +XXX,XX @@
 # along with this program.  If not, see <http://www.gnu.org/licenses/>.
 #
 
-from __future__ import print_function
 import sys
 import os
 import signal
-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

Instead of manually encoding stderr and stdout output, use
`errors` parameter of subprocess.Popen().  This will make
process.communicate() return unicode strings instead of bytes
objects.

Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-id: 20191016192430.25098-11-ehabkost@redhat.com
Message-Id: <20191016192430.25098-11-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/runner.py | 11 ++++-------
 1 file changed, 4 insertions(+), 7 deletions(-)

diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
index XXXXXXX..XXXXXXX 100755
--- a/tests/image-fuzzer/runner.py
+++ b/tests/image-fuzzer/runner.py
@@ -XXX,XX +XXX,XX @@ def run_app(fd, q_args):
     devnull = open('/dev/null', 'r+')
     process = subprocess.Popen(q_args, stdin=devnull,
                                stdout=subprocess.PIPE,
-                               stderr=subprocess.PIPE)
+                               stderr=subprocess.PIPE,
+                               errors='replace')
     try:
         out, err = process.communicate()
         signal.alarm(0)
-        # fd is a text file, so we need to decode the process output before
-        # writing to it.
-        # We could be simply using the `errors` parameter of subprocess.Popen(),
-        # but this will be possible only after migrating to Python 3
-        fd.write(out.decode(errors='replace'))
-        fd.write(err.decode(errors='replace'))
+        fd.write(out)
+        fd.write(err)
         fd.flush()
         return process.returncode
 
-- 
2.23.0

From: Eduardo Habkost <ehabkost@redhat.com>

OSError can't be used like a tuple on Python 3, so change the
code to use `e.sterror` instead of `e[1]`.

Reported-by: John Snow <jsnow@redhat.com>
Signed-off-by: Eduardo Habkost <ehabkost@redhat.com>
Reviewed-by: John Snow <jsnow@redhat.com>
Message-id: 20191021214117.18091-1-ehabkost@redhat.com
Message-Id: <20191021214117.18091-1-ehabkost@redhat.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 tests/image-fuzzer/runner.py | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/tests/image-fuzzer/runner.py b/tests/image-fuzzer/runner.py
index XXXXXXX..XXXXXXX 100755
--- a/tests/image-fuzzer/runner.py
+++ b/tests/image-fuzzer/runner.py
@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
             os.makedirs(self.current_dir)
         except OSError as e:
             print("Error: The working directory '%s' cannot be used. Reason: %s"\
-                % (self.work_dir, e[1]), file=sys.stderr)
+                % (self.work_dir, e.strerror), file=sys.stderr)
             raise TestException
         self.log = open(os.path.join(self.current_dir, "test.log"), "w")
         self.parent_log = open(run_log, "a")
@@ -XXX,XX +XXX,XX @@ class TestEnv(object):
             except OSError as e:
                 multilog("%sError: Start of '%s' failed. Reason: %s\n\n"
                          % (test_summary, os.path.basename(current_cmd[0]),
-                            e[1]),
+                            e.strerror),
                          sys.stderr, self.log, self.parent_log)
                 raise TestException
 
-- 
2.23.0

The following changes since commit 711c0418c8c1ce3a24346f058b001c4c5a2f0f81:

Merge remote-tracking branch 'remotes/philmd/tags/mips-20210702' into staging (2021-07-04 14:04:12 +0100)

are available in the Git repository at:

https://gitlab.com/stefanha/qemu.git tags/block-pull-request

for you to fetch changes up to 9f460c64e13897117f35ffb61f6f5e0102cabc70:

block/io: Merge discard request alignments (2021-07-06 14:28:55 +0100)

----------------------------------------------------------------
Pull request

----------------------------------------------------------------

Akihiko Odaki (3):
  block/file-posix: Optimize for macOS
  block: Add backend_defaults property
  block/io: Merge discard request alignments

Stefan Hajnoczi (2):
  util/async: add a human-readable name to BHs for debugging
  util/async: print leaked BH name when AioContext finalizes

-- 
2.31.1

It can be difficult to debug issues with BHs in production environments.
Although BHs can usually be identified by looking up their ->cb()
function pointer, this requires debug information for the program. It is
also not possible to print human-readable diagnostics about BHs because
they have no identifier.

This patch adds a name to each BH. The name is not unique per instance
but differentiates between cb() functions, which is usually enough. It's
done by changing aio_bh_new() and friends to macros that stringify cb.

The next patch will use the name field when reporting leaked BHs.

Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Message-Id: <20210414200247.917496-2-stefanha@redhat.com>
---
 include/block/aio.h            | 31 ++++++++++++++++++++++++++++---
 include/qemu/main-loop.h       |  4 +++-
 tests/unit/ptimer-test-stubs.c |  2 +-
 util/async.c                   |  9 +++++++--
 util/main-loop.c               |  4 ++--
 5 files changed, 41 insertions(+), 9 deletions(-)

diff --git a/include/block/aio.h b/include/block/aio.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/aio.h
+++ b/include/block/aio.h
@@ -XXX,XX +XXX,XX @@ void aio_context_acquire(AioContext *ctx);
 /* Relinquish ownership of the AioContext. */
 void aio_context_release(AioContext *ctx);
 
+/**
+ * aio_bh_schedule_oneshot_full: Allocate a new bottom half structure that will
+ * run only once and as soon as possible.
+ *
+ * @name: A human-readable identifier for debugging purposes.
+ */
+void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                                  const char *name);
+
 /**
  * aio_bh_schedule_oneshot: Allocate a new bottom half structure that will run
  * only once and as soon as possible.
+ *
+ * A convenience wrapper for aio_bh_schedule_oneshot_full() that uses cb as the
+ * name string.
  */
-void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
+#define aio_bh_schedule_oneshot(ctx, cb, opaque) \
+    aio_bh_schedule_oneshot_full((ctx), (cb), (opaque), (stringify(cb)))
 
 /**
- * aio_bh_new: Allocate a new bottom half structure.
+ * aio_bh_new_full: Allocate a new bottom half structure.
  *
  * Bottom halves are lightweight callbacks whose invocation is guaranteed
  * to be wait-free, thread-safe and signal-safe.  The #QEMUBH structure
  * is opaque and must be allocated prior to its use.
+ *
+ * @name: A human-readable identifier for debugging purposes.
  */
-QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque);
+QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                        const char *name);
+
+/**
+ * aio_bh_new: Allocate a new bottom half structure
+ *
+ * A convenience wrapper for aio_bh_new_full() that uses the cb as the name
+ * string.
+ */
+#define aio_bh_new(ctx, cb, opaque) \
+    aio_bh_new_full((ctx), (cb), (opaque), (stringify(cb)))
 
 /**
  * aio_notify: Force processing of pending events.
diff --git a/include/qemu/main-loop.h b/include/qemu/main-loop.h
index XXXXXXX..XXXXXXX 100644
--- a/include/qemu/main-loop.h
+++ b/include/qemu/main-loop.h
@@ -XXX,XX +XXX,XX @@ void qemu_cond_timedwait_iothread(QemuCond *cond, int ms);
 
 void qemu_fd_register(int fd);
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque);
+#define qemu_bh_new(cb, opaque) \
+    qemu_bh_new_full((cb), (opaque), (stringify(cb)))
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name);
 void qemu_bh_schedule_idle(QEMUBH *bh);
 
 enum {
diff --git a/tests/unit/ptimer-test-stubs.c b/tests/unit/ptimer-test-stubs.c
index XXXXXXX..XXXXXXX 100644
--- a/tests/unit/ptimer-test-stubs.c
+++ b/tests/unit/ptimer-test-stubs.c
@@ -XXX,XX +XXX,XX @@ int64_t qemu_clock_deadline_ns_all(QEMUClockType type, int attr_mask)
     return deadline;
 }
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
 {
     QEMUBH *bh = g_new(QEMUBH, 1);
 
diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ enum {
 
 struct QEMUBH {
     AioContext *ctx;
+    const char *name;
     QEMUBHFunc *cb;
     void *opaque;
     QSLIST_ENTRY(QEMUBH) next;
@@ -XXX,XX +XXX,XX @@ static QEMUBH *aio_bh_dequeue(BHList *head, unsigned *flags)
     return bh;
 }
 
-void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+void aio_bh_schedule_oneshot_full(AioContext *ctx, QEMUBHFunc *cb,
+                                  void *opaque, const char *name)
 {
     QEMUBH *bh;
     bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ void aio_bh_schedule_oneshot(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
         .ctx = ctx,
         .cb = cb,
         .opaque = opaque,
+        .name = name,
     };
     aio_bh_enqueue(bh, BH_SCHEDULED | BH_ONESHOT);
 }
 
-QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
+QEMUBH *aio_bh_new_full(AioContext *ctx, QEMUBHFunc *cb, void *opaque,
+                        const char *name)
 {
     QEMUBH *bh;
     bh = g_new(QEMUBH, 1);
@@ -XXX,XX +XXX,XX @@ QEMUBH *aio_bh_new(AioContext *ctx, QEMUBHFunc *cb, void *opaque)
         .ctx = ctx,
         .cb = cb,
         .opaque = opaque,
+        .name = name,
     };
     return bh;
 }
diff --git a/util/main-loop.c b/util/main-loop.c
index XXXXXXX..XXXXXXX 100644
--- a/util/main-loop.c
+++ b/util/main-loop.c
@@ -XXX,XX +XXX,XX @@ void main_loop_wait(int nonblocking)
 
 /* Functions to operate on the main QEMU AioContext.  */
 
-QEMUBH *qemu_bh_new(QEMUBHFunc *cb, void *opaque)
+QEMUBH *qemu_bh_new_full(QEMUBHFunc *cb, void *opaque, const char *name)
 {
-    return aio_bh_new(qemu_aio_context, cb, opaque);
+    return aio_bh_new_full(qemu_aio_context, cb, opaque, name);
 }
 
 /*
-- 
2.31.1

BHs must be deleted before the AioContext is finalized. If not, it's a
bug and probably indicates that some part of the program still expects
the BH to run in the future. That can lead to memory leaks, inconsistent
state, or just hangs.

Unfortunately the assert(flags & BH_DELETED) call in aio_ctx_finalize()
is difficult to debug because the assertion failure contains no
information about the BH!

Use the QEMUBH name field added in the previous patch to show a useful
error when a leaked BH is detected.

Suggested-by: Eric Ernst <eric.g.ernst@gmail.com>
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
Message-Id: <20210414200247.917496-3-stefanha@redhat.com>
---
 util/async.c | 16 ++++++++++++++--
 1 file changed, 14 insertions(+), 2 deletions(-)

diff --git a/util/async.c b/util/async.c
index XXXXXXX..XXXXXXX 100644
--- a/util/async.c
+++ b/util/async.c
@@ -XXX,XX +XXX,XX @@ aio_ctx_finalize(GSource     *source)
     assert(QSIMPLEQ_EMPTY(&ctx->bh_slice_list));
 
     while ((bh = aio_bh_dequeue(&ctx->bh_list, &flags))) {
-        /* qemu_bh_delete() must have been called on BHs in this AioContext */
-        assert(flags & BH_DELETED);
+        /*
+         * qemu_bh_delete() must have been called on BHs in this AioContext. In
+         * many cases memory leaks, hangs, or inconsistent state occur when a
+         * BH is leaked because something still expects it to run.
+         *
+         * If you hit this, fix the lifecycle of the BH so that
+         * qemu_bh_delete() and any associated cleanup is called before the
+         * AioContext is finalized.
+         */
+        if (unlikely(!(flags & BH_DELETED))) {
+            fprintf(stderr, "%s: BH '%s' leaked, aborting...\n",
+                    __func__, bh->name);
+            abort();
+        }
 
         g_free(bh);
     }
-- 
2.31.1

From: Akihiko Odaki <akihiko.odaki@gmail.com>

This commit introduces "punch hole" operation and optimizes transfer
block size for macOS.

Thanks to Konstantin Nazarov for detailed analysis of a flaw in an
old version of this change:
https://gist.github.com/akihikodaki/87df4149e7ca87f18dc56807ec5a1bc5#gistcomment-3654667

Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Message-id: 20210705130458.97642-1-akihiko.odaki@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 block/file-posix.c | 27 +++++++++++++++++++++++++--
 1 file changed, 25 insertions(+), 2 deletions(-)

diff --git a/block/file-posix.c b/block/file-posix.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-posix.c
+++ b/block/file-posix.c
@@ -XXX,XX +XXX,XX @@
 #if defined(HAVE_HOST_BLOCK_DEVICE)
 #include <paths.h>
 #include <sys/param.h>
+#include <sys/mount.h>
 #include <IOKit/IOKitLib.h>
 #include <IOKit/IOBSD.h>
 #include <IOKit/storage/IOMediaBSDClient.h>
@@ -XXX,XX +XXX,XX @@ static void raw_refresh_limits(BlockDriverState *bs, Error **errp)
         return;
     }
 
+#if defined(__APPLE__) && (__MACH__)
+    struct statfs buf;
+
+    if (!fstatfs(s->fd, &buf)) {
+        bs->bl.opt_transfer = buf.f_iosize;
+        bs->bl.pdiscard_alignment = buf.f_bsize;
+    }
+#endif
+
     if (bs->sg || S_ISBLK(st.st_mode)) {
         int ret = hdev_get_max_hw_transfer(s->fd, &st);
 
@@ -XXX,XX +XXX,XX @@ out:
     }
 }
 
+#if defined(CONFIG_FALLOCATE) || defined(BLKZEROOUT) || defined(BLKDISCARD)
 static int translate_err(int err)
 {
     if (err == -ENODEV || err == -ENOSYS || err == -EOPNOTSUPP ||
@@ -XXX,XX +XXX,XX @@ static int translate_err(int err)
     }
     return err;
 }
+#endif
 
 #ifdef CONFIG_FALLOCATE
 static int do_fallocate(int fd, int mode, off_t offset, off_t len)
@@ -XXX,XX +XXX,XX @@ static int handle_aiocb_discard(void *opaque)
             }
         } while (errno == EINTR);
 
-        ret = -errno;
+        ret = translate_err(-errno);
 #endif
     } else {
 #ifdef CONFIG_FALLOCATE_PUNCH_HOLE
         ret = do_fallocate(s->fd, FALLOC_FL_PUNCH_HOLE | FALLOC_FL_KEEP_SIZE,
                            aiocb->aio_offset, aiocb->aio_nbytes);
+        ret = translate_err(-errno);
+#elif defined(__APPLE__) && (__MACH__)
+        fpunchhole_t fpunchhole;
+        fpunchhole.fp_flags = 0;
+        fpunchhole.reserved = 0;
+        fpunchhole.fp_offset = aiocb->aio_offset;
+        fpunchhole.fp_length = aiocb->aio_nbytes;
+        if (fcntl(s->fd, F_PUNCHHOLE, &fpunchhole) == -1) {
+            ret = errno == ENODEV ? -ENOTSUP : -errno;
+        } else {
+            ret = 0;
+        }
 #endif
     }
 
-    ret = translate_err(ret);
     if (ret == -ENOTSUP) {
         s->has_discard = false;
     }
-- 
2.31.1

From: Akihiko Odaki <akihiko.odaki@gmail.com>

backend_defaults property allow users to control if default block
properties should be decided with backend information.

If it is off, any backend information will be discarded, which is
suitable if you plan to perform live migration to a different disk backend.

If it is on, a block device may utilize backend information more
aggressively.

By default, it is auto, which uses backend information for block
sizes and ignores the others, which is consistent with the older
versions.

Signed-off-by: Akihiko Odaki <akihiko.odaki@gmail.com>
Message-id: 20210705130458.97642-2-akihiko.odaki@gmail.com
Signed-off-by: Stefan Hajnoczi <stefanha@redhat.com>
---
 include/hw/block/block.h   |  3 +++
 hw/block/block.c           | 42 ++++++++++++++++++++++++++++++++++----
 tests/qemu-iotests/172.out | 38 ++++++++++++++++++++++++++++++++++
 3 files changed, 79 insertions(+), 4 deletions(-)

diff --git a/include/hw/block/block.h b/include/hw/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/hw/block/block.h
+++ b/include/hw/block/block.h
@@ -XXX,XX +XXX,XX @@
 
 typedef struct BlockConf {
     BlockBackend *blk;
+    OnOffAuto backend_defaults;
     uint32_t physical_block_size;
     uint32_t logical_block_size;
     uint32_t min_io_size;
@@ -XXX,XX +XXX,XX @@ static inline unsigned int get_physical_block_exp(BlockConf *conf)
 }
 
 #define DEFINE_BLOCK_PROPERTIES_BASE(_state, _conf)                     \
+    DEFINE_PROP_ON_OFF_AUTO("backend_defaults", _state,                 \
+                            _conf.backend_defaults, ON_OFF_AUTO_AUTO),  \
     DEFINE_PROP_BLOCKSIZE("logical_block_size", _state,                 \
                           _conf.logical_block_size),                    \
     DEFINE_PROP_BLOCKSIZE("physical_block_size", _state,                \
diff --git a/hw/block/block.c b/hw/block/block.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/block.c
+++ b/hw/block/block.c
@@ -XXX,XX +XXX,XX @@ bool blkconf_blocksizes(BlockConf *conf, Error **errp)
 {
     BlockBackend *blk = conf->blk;
     BlockSizes blocksizes;
-    int backend_ret;
+    BlockDriverState *bs;
+    bool use_blocksizes;
+    bool use_bs;
+
+    switch (conf->backend_defaults) {
+    case ON_OFF_AUTO_AUTO:
+        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
+        use_bs = false;
+        break;
+
+    case ON_OFF_AUTO_ON:
+        use_blocksizes = !blk_probe_blocksizes(blk, &blocksizes);
+        bs = blk_bs(blk);
+        use_bs = bs;
+        break;
+
+    case ON_OFF_AUTO_OFF:
+        use_blocksizes = false;
+        use_bs = false;
+        break;
+
+    default:
+        abort();
+    }
 
-    backend_ret = blk_probe_blocksizes(blk, &blocksizes);
     /* fill in detected values if they are not defined via qemu command line */
     if (!conf->physical_block_size) {
-        if (!backend_ret) {
+        if (use_blocksizes) {
            conf->physical_block_size = blocksizes.phys;
         } else {
             conf->physical_block_size = BDRV_SECTOR_SIZE;
         }
     }
     if (!conf->logical_block_size) {
-        if (!backend_ret) {
+        if (use_blocksizes) {
             conf->logical_block_size = blocksizes.log;
         } else {
             conf->logical_block_size = BDRV_SECTOR_SIZE;
         }
     }
+    if (use_bs) {
+        if (!conf->opt_io_size) {
+            conf->opt_io_size = bs->bl.opt_transfer;
+        }
+        if (conf->discard_granularity == -1) {
+            if (bs->bl.pdiscard_alignment) {
+                conf->discard_granularity = bs->bl.pdiscard_alignment;
+            } else if (bs->bl.request_alignment != 1) {
+                conf->discard_granularity = bs->bl.request_alignment;
+            }
+        }
+    }
 
     if (conf->logical_block_size > conf->physical_block_size) {
         error_setg(errp,
diff --git a/tests/qemu-iotests/172.out b/tests/qemu-iotests/172.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/172.out
+++ b/tests/qemu-iotests/172.out
@@ -XXX,XX +XXX,XX @@ Testing:
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -fdb TEST_DIR/t.qcow2.2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2,index=1
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=floppy,file=TEST_DIR/t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,unit=1
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qco
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fda TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -fdb TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.qcow2.2 -device fl
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "floppy1"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 1 (0x1)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=floppy,file=TEST_DIR/t.qcow2 -drive if=none,file=TEST_DIR/t.q
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "floppy0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -global floppy.drive=none0 -device
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=120
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=144
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -device floppy,drive-type=288
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = ""
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,drive-t
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,logical
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
@@ -XXX,XX +XXX,XX @@ Testing: -drive if=none,file=TEST_DIR/t.qcow2 -device floppy,drive=none0,physica
               dev: floppy, id ""
                 unit = 0 (0x0)
                 drive = "none0"
+                backend_defaults = "auto"
                 logical_block_size = 512 (512 B)
                 physical_block_size = 512 (512 B)
                 min_io_size = 0 (0 B)
-- 
2.31.1