Series comparison

-[Qemu-devel] [PULL 0/9] Block layer patches
+[PULL 00/30] Block layer patches
-The following changes since commit 9436e082de18b2fb2ceed2e9d1beef641ae64f23:
+The following changes since commit 1b8c45899715d292398152ba97ef755ccaf84680:
-  MAINTAINERS: clarify some of the tags (2018-11-19 11:19:23 +0000)
+  Merge remote-tracking branch 'remotes/dgilbert/tags/pull-migration-20200507a' into staging (2020-05-07 18:43:20 +0100)
 are available in the Git repository at:
   git://repo.or.cz/qemu/kevin.git tags/for-upstream
-for you to fetch changes up to 6d0a4a0fb5c8f10c8eb68b52cfda0082b00ae963:
+for you to fetch changes up to 47e0b38a13935cb666f88964c3096654092f42d6:
-  iotests: Test file-posix locking and reopen (2018-11-19 14:32:04 +0100)
+  block: Drop unused .bdrv_has_zero_init_truncate (2020-05-08 13:26:35 +0200)
 ----------------------------------------------------------------
 Block layer patches:
-- file-posix: Fix shared permission locks after reopen
+- qcow2: Fix preallocation on block devices
-- block: Fix error path for failed .bdrv_reopen_prepare
+- backup: Make sure that source and target size match
-- qcow2: Catch invalid allocations when the image becomes too large
+- vmdk: Fix zero cluster handling
-- vvfat/fdc/nvme: Fix segfaults and leaks
+- Follow-up cleanups and fixes for the truncate changes
 - iotests: Skip more tests if required drivers are missing
 ----------------------------------------------------------------
-Eric Blake (3):
+Alberto Garcia (1):
-      qcow2: Document some maximum size constraints
+      qcow2: Avoid integer wraparound in qcow2_co_truncate()
       qcow2: Don't allow overflow during cluster allocation
       iotests: Add new test 220 for max compressed cluster offset
-Kevin Wolf (1):
+Eric Blake (9):
-      vvfat: Fix memory leak
+      gluster: Drop useless has_zero_init callback
       file-win32: Support BDRV_REQ_ZERO_WRITE for truncate
       nfs: Support BDRV_REQ_ZERO_WRITE for truncate
       rbd: Support BDRV_REQ_ZERO_WRITE for truncate
       sheepdog: Support BDRV_REQ_ZERO_WRITE for truncate
       ssh: Support BDRV_REQ_ZERO_WRITE for truncate
       parallels: Rework truncation logic
       vhdx: Rework truncation logic
       block: Drop unused .bdrv_has_zero_init_truncate
-Li Qiang (1):
+Kevin Wolf (11):
-      nvme: fix oob access issue(CVE-2018-16847)
+      vmdk: Rename VmdkMetaData.valid to new_allocation
       vmdk: Fix zero cluster allocation
       vmdk: Fix partial overwrite of zero cluster
       vmdk: Don't update L2 table for zero write on zero cluster
       vmdk: Flush only once in vmdk_L2update()
       iotests: vmdk: Enable zeroed_grained=on by default
       iotests/283: Use consistent size for source and target
       backup: Improve error for bdrv_getlength() failure
       backup: Make sure that source and target size match
       iotests: Backup with different source/target size
       iotests/055: Use cache.no-flush for vmdk target
-Mark Cave-Ayland (1):
+Max Reitz (1):
-      fdc: fix segfault in fdctrl_stop_transfer() when DMA is disabled
+      qcow2: Fix preallocation on block devices
-Max Reitz (3):
+Vladimir Sementsov-Ogievskiy (8):
-      block: Always abort reopen after prepare succeeded
+      iotests: handle tmpfs
-      file-posix: Fix shared locks on reopen commit
+      iotests/082: require bochs
-      iotests: Test file-posix locking and reopen
+      iotests/148: use skip_if_unsupported
       iotests/041: drop self.assert_no_active_block_jobs()
       iotests/055: refactor compressed backup to vmdk
       iotests/055: skip vmdk target tests if vmdk is not whitelisted
       iotests/109: mark required formats as required to support whitelisting
       iotests/113: mark bochs as required to support whitelisting
- docs/interop/qcow2.txt     | 38 +++++++++++++++++-
+ include/block/block.h        |   1 -
- block/qcow2.h              |  6 +++
+ include/block/block_int.h    |   7 ---
- block.c                    | 12 ++++++
+ block.c                      |  21 --------
- block/file-posix.c         |  2 +-
+ block/backup-top.c           |  14 +++--
- block/qcow2-refcount.c     | 20 ++++++----
+ block/backup.c               |  18 +++++--
- block/vvfat.c              |  6 +--
+ block/file-posix.c           |   1 -
- hw/block/fdc.c             |  2 +-
+ block/file-win32.c           |   4 +-
- hw/block/nvme.c            |  7 ++++
+ block/gluster.c              |  14 -----
- tests/qemu-iotests/182     | 71 ++++++++++++++++++++++++++++++++++
+ block/nfs.c                  |   4 +-
- tests/qemu-iotests/182.out |  9 +++++
+ block/parallels.c            |  25 +++++----
- tests/qemu-iotests/220     | 96 ++++++++++++++++++++++++++++++++++++++++++++++
+ block/qcow2.c                |  23 ++++++---
- tests/qemu-iotests/220.out | 54 ++++++++++++++++++++++++++
+ block/qed.c                  |   1 -
- tests/qemu-iotests/group   |  1 +
+ block/raw-format.c           |   6 ---
-files changed, 310 insertions(+), 14 deletions(-)
+ block/rbd.c                  |   4 +-
- create mode 100755 tests/qemu-iotests/220
+ block/sheepdog.c             |   4 +-
- create mode 100644 tests/qemu-iotests/220.out
+ block/ssh.c                  |   5 +-
  block/vhdx.c                 |  89 ++++++++++++++++++--------------
  block/vmdk.c                 |  47 ++++++++++-------
  tests/qemu-iotests/041       |   8 ---
  tests/qemu-iotests/055       | 120 ++++++++++++++++++++++++++++++-------------
  tests/qemu-iotests/055.out   |   4 +-
  tests/qemu-iotests/059       |   6 +--
  tests/qemu-iotests/082       |   1 +
  tests/qemu-iotests/091       |   2 +-
  tests/qemu-iotests/109       |   1 +
  tests/qemu-iotests/113       |   4 +-
  tests/qemu-iotests/148       |   1 +
  tests/qemu-iotests/283       |   6 ++-
  tests/qemu-iotests/283.out   |   2 +-
  tests/qemu-iotests/292       |  73 ++++++++++++++++++++++++++
  tests/qemu-iotests/292.out   |  24 +++++++++
  tests/qemu-iotests/check     |   3 ++
  tests/qemu-iotests/common.rc |  37 ++++++++++++-
  tests/qemu-iotests/group     |   1 +
 files changed, 386 insertions(+), 195 deletions(-)
  create mode 100755 tests/qemu-iotests/292
  create mode 100644 tests/qemu-iotests/292.out

-New patch
+[PULL 01/30] iotests: handle tmpfs
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Some tests requires O_DIRECT, or want it by default. Introduce smarter
+O_DIRECT handling:
+- Check O_DIRECT in common.rc, if it is requested by selected
+cache-mode.
+- Support second fall-through argument in _default_cache_mode
+Inspired-by: Max's 23e1d054112cec1e
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-2-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/091       |  2 +-
+ tests/qemu-iotests/common.rc | 37 ++++++++++++++++++++++++++++++++++--
+files changed, 36 insertions(+), 3 deletions(-)
+diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/091
++++ b/tests/qemu-iotests/091
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ _supported_fmt qcow2
+ _supported_proto file
+ _supported_os Linux
+-_default_cache_mode none
+ _supported_cache_modes writethrough none writeback
++_default_cache_mode none writeback
+ size=1G
+diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/common.rc
++++ b/tests/qemu-iotests/common.rc
+@@ -XXX,XX +XXX,XX @@ _supported_cache_modes()
+     _notrun "not suitable for cache mode: $CACHEMODE"
+ }
++# Check whether the filesystem supports O_DIRECT
++_check_o_direct()
++{
++    $QEMU_IMG create -f raw "$TEST_IMG".test_o_direct 1M > /dev/null
++    out=$($QEMU_IO -f raw -t none -c quit "$TEST_IMG".test_o_direct 2>&1)
++    rm -f "$TEST_IMG".test_o_direct
++
++    [[ "$out" != *"O_DIRECT"* ]]
++}
++
++_require_o_direct()
++{
++    if ! _check_o_direct; then
++        _notrun "file system on $TEST_DIR does not support O_DIRECT"
++    fi
++}
++
++_check_cache_mode()
++{
++    if [ $CACHEMODE == "none" ] || [ $CACHEMODE == "directsync" ]; then
++        _require_o_direct
++    fi
++}
++
++_check_cache_mode
++
++# $1 - cache mode to use by default
++# $2 - (optional) cache mode to use by default if O_DIRECT is not supported
+ _default_cache_mode()
+ {
+     if $CACHEMODE_IS_DEFAULT; then
+-        CACHEMODE="$1"
+-        QEMU_IO="$QEMU_IO --cache $1"
++        if [ -z "$2" ] || _check_o_direct; then
++            CACHEMODE="$1"
++        else
++            CACHEMODE="$2"
++        fi
++        QEMU_IO="$QEMU_IO --cache $CACHEMODE"
++        _check_cache_mode
+         return
+     fi
+ }
+--
+.25.3

-New patch
+[PULL 02/30] iotests/082: require bochs
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Test fails if bochs not whitelisted, so, skip it in this case.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-3-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/082 | 1 +
+file changed, 1 insertion(+)
+diff --git a/tests/qemu-iotests/082 b/tests/qemu-iotests/082
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/082
++++ b/tests/qemu-iotests/082
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ _supported_fmt qcow2
+ _supported_proto file nfs
++_require_drivers bochs
+ run_qemu_img()
+ {
+--
+.25.3

-New patch
+[PULL 03/30] iotests/148: use skip_if_unsupported
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Skip test-case with quorum if quorum is not whitelisted.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-4-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/148 | 1 +
+file changed, 1 insertion(+)
+diff --git a/tests/qemu-iotests/148 b/tests/qemu-iotests/148
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/148
++++ b/tests/qemu-iotests/148
+@@ -XXX,XX +XXX,XX @@ sector = "%d"
+ ''' % bad_sector)
+         file.close()
++    @iotests.skip_if_unsupported(['quorum'])
+     def setUp(self):
+         driveopts = ['driver=quorum', 'vote-threshold=2']
+         driveopts.append('read-pattern=%s' % self.read_pattern)
+--
+.25.3

-New patch
+[PULL 04/30] iotests/041: drop self.assert_no_active_block_jobs()
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Drop check for no block-jobs: it's obvious that there no jobs
+immediately after vm.launch().
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-5-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/041 | 8 --------
+file changed, 8 deletions(-)
+diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/041
++++ b/tests/qemu-iotests/041
+@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
+                 pass
+     def test_complete(self):
+-        self.assert_no_active_block_jobs()
+-
+         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+                              sync='full', node_name="repair0", replaces="img1",
+                              target=quorum_repair_img, format=iotests.imgfmt)
+@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
+                         'target image does not match source after mirroring')
+     def test_cancel(self):
+-        self.assert_no_active_block_jobs()
+-
+         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+                              sync='full', node_name="repair0", replaces="img1",
+                              target=quorum_repair_img, format=iotests.imgfmt)
+@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
+         self.assert_has_block_node(None, quorum_img3)
+     def test_cancel_after_ready(self):
+-        self.assert_no_active_block_jobs()
+-
+         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+                              sync='full', node_name="repair0", replaces="img1",
+                              target=quorum_repair_img, format=iotests.imgfmt)
+@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
+                         'target image does not match source after mirroring')
+     def test_pause(self):
+-        self.assert_no_active_block_jobs()
+-
+         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
+                              sync='full', node_name="repair0", replaces="img1",
+                              target=quorum_repair_img, format=iotests.imgfmt)
+--
+.25.3

-New patch
+[PULL 05/30] iotests/055: refactor compressed backup to vmdk
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Instead of looping in each test, let's better refactor vmdk target case
+as a subclass.
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-6-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/055     | 70 ++++++++++++++++++++------------------
+ tests/qemu-iotests/055.out |  4 +--
+files changed, 39 insertions(+), 35 deletions(-)
+diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/055
++++ b/tests/qemu-iotests/055
+@@ -XXX,XX +XXX,XX @@ class TestSingleTransaction(iotests.QMPTestCase):
+         self.assert_no_active_block_jobs()
+-class TestDriveCompression(iotests.QMPTestCase):
++class TestCompressedToQcow2(iotests.QMPTestCase):
+     image_len = 64 * 1024 * 1024 # MB
+-    fmt_supports_compression = [{'type': 'qcow2', 'args': ()},
+-                                {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}]
++    target_fmt = {'type': 'qcow2', 'args': ()}
+     def tearDown(self):
+         self.vm.shutdown()
+@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
+         except OSError:
+             pass
+-    def do_prepare_drives(self, fmt, args, attach_target):
++    def do_prepare_drives(self, attach_target):
+         self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
+-        qemu_img('create', '-f', fmt, blockdev_target_img,
+-                 str(TestDriveCompression.image_len), *args)
++        qemu_img('create', '-f', self.target_fmt['type'], blockdev_target_img,
++                 str(self.image_len), *self.target_fmt['args'])
+         if attach_target:
+             self.vm.add_drive(blockdev_target_img,
+-                              img_format=fmt, interface="none")
++                              img_format=self.target_fmt['type'],
++                              interface="none")
+         self.vm.launch()
+-    def do_test_compress_complete(self, cmd, format, attach_target, **args):
+-        self.do_prepare_drives(format['type'], format['args'], attach_target)
++    def do_test_compress_complete(self, cmd, attach_target, **args):
++        self.do_prepare_drives(attach_target)
+         self.assert_no_active_block_jobs()
+@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
+         self.vm.shutdown()
+         self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
+-                                               iotests.imgfmt, format['type']),
++                                               iotests.imgfmt,
++                                               self.target_fmt['type']),
+                         'target image does not match source after backup')
+     def test_complete_compress_drive_backup(self):
+-        for format in TestDriveCompression.fmt_supports_compression:
+-            self.do_test_compress_complete('drive-backup', format, False,
+-                                           target=blockdev_target_img, mode='existing')
++        self.do_test_compress_complete('drive-backup', False,
++                                       target=blockdev_target_img,
++                                       mode='existing')
+     def test_complete_compress_blockdev_backup(self):
+-        for format in TestDriveCompression.fmt_supports_compression:
+-            self.do_test_compress_complete('blockdev-backup', format, True,
+-                                           target='drive1')
++        self.do_test_compress_complete('blockdev-backup',
++                                       True, target='drive1')
+-    def do_test_compress_cancel(self, cmd, format, attach_target, **args):
+-        self.do_prepare_drives(format['type'], format['args'], attach_target)
++    def do_test_compress_cancel(self, cmd, attach_target, **args):
++        self.do_prepare_drives(attach_target)
+         self.assert_no_active_block_jobs()
+@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
+         self.vm.shutdown()
+     def test_compress_cancel_drive_backup(self):
+-        for format in TestDriveCompression.fmt_supports_compression:
+-            self.do_test_compress_cancel('drive-backup', format, False,
+-                                         target=blockdev_target_img, mode='existing')
++        self.do_test_compress_cancel('drive-backup', False,
++                                     target=blockdev_target_img,
++                                     mode='existing')
+     def test_compress_cancel_blockdev_backup(self):
+-       for format in TestDriveCompression.fmt_supports_compression:
+-            self.do_test_compress_cancel('blockdev-backup', format, True,
+-                                         target='drive1')
++        self.do_test_compress_cancel('blockdev-backup', True,
++                                     target='drive1')
+-    def do_test_compress_pause(self, cmd, format, attach_target, **args):
+-        self.do_prepare_drives(format['type'], format['args'], attach_target)
++    def do_test_compress_pause(self, cmd, attach_target, **args):
++        self.do_prepare_drives(attach_target)
+         self.assert_no_active_block_jobs()
+@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
+         self.vm.shutdown()
+         self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
+-                                               iotests.imgfmt, format['type']),
++                                               iotests.imgfmt,
++                                               self.target_fmt['type']),
+                         'target image does not match source after backup')
+     def test_compress_pause_drive_backup(self):
+-        for format in TestDriveCompression.fmt_supports_compression:
+-            self.do_test_compress_pause('drive-backup', format, False,
+-                                        target=blockdev_target_img, mode='existing')
++        self.do_test_compress_pause('drive-backup', False,
++                                    target=blockdev_target_img,
++                                    mode='existing')
+     def test_compress_pause_blockdev_backup(self):
+-        for format in TestDriveCompression.fmt_supports_compression:
+-            self.do_test_compress_pause('blockdev-backup', format, True,
+-                                        target='drive1')
++        self.do_test_compress_pause('blockdev-backup', True,
++                                    target='drive1')
++
++
++class TestCompressedToVmdk(TestCompressedToQcow2):
++    target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}
++
+ if __name__ == '__main__':
+     iotests.main(supported_fmts=['raw', 'qcow2'],
+diff --git a/tests/qemu-iotests/055.out b/tests/qemu-iotests/055.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/055.out
++++ b/tests/qemu-iotests/055.out
+@@ -XXX,XX +XXX,XX @@
+-..............................
++....................................
+ ----------------------------------------------------------------------
+-Ran 30 tests
++Ran 36 tests
+ OK
+--
+.25.3

-New patch
+[PULL 06/30] iotests/055: skip vmdk target tests if vmdk is not whitelisted
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-7-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/055 | 4 ++++
+file changed, 4 insertions(+)
+diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/055
++++ b/tests/qemu-iotests/055
+@@ -XXX,XX +XXX,XX @@ class TestCompressedToQcow2(iotests.QMPTestCase):
+ class TestCompressedToVmdk(TestCompressedToQcow2):
+     target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}
++    @iotests.skip_if_unsupported(['vmdk'])
++    def setUp(self):
++        pass
++
+ if __name__ == '__main__':
+     iotests.main(supported_fmts=['raw', 'qcow2'],
+--
+.25.3

-New patch
+[PULL 07/30] iotests/109: mark required formats as required to support whitelisting
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-8-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/109 | 1 +
+file changed, 1 insertion(+)
+diff --git a/tests/qemu-iotests/109 b/tests/qemu-iotests/109
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/109
++++ b/tests/qemu-iotests/109
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ _supported_fmt raw
+ _supported_proto file
+ _supported_os Linux
++_require_drivers qcow qcow2 qed vdi vmdk vpc
+ qemu_comm_method=qmp
+--
+.25.3

-New patch
+[PULL 08/30] iotests/113: mark bochs as required to support whitelisting
+From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Message-Id: <20200430124713.3067-9-vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/113 | 4 ++--
+file changed, 2 insertions(+), 2 deletions(-)
+diff --git a/tests/qemu-iotests/113 b/tests/qemu-iotests/113
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/113
++++ b/tests/qemu-iotests/113
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ . ./common.rc
+ . ./common.filter
+-# Some of these test cases use bochs, but others do use raw, so this
+-# is only half a lie.
++# Some of these test cases use bochs, but others do use raw
++_require_drivers bochs
+ _supported_fmt raw
+ _supported_proto file
+ _supported_os Linux
+--
+.25.3

-[Qemu-devel] [PULL 6/9] iotests: Add new test 220 for max compressed cluster offset
+[PULL 09/30] qcow2: Avoid integer wraparound in qcow2_co_truncate()
-From: Eric Blake <eblake@redhat.com>
+From: Alberto Garcia <berto@igalia.com>
-If you have a capable file system (tmpfs is good, ext4 not so much;
+After commit f01643fb8b47e8a70c04bbf45e0f12a9e5bc54de when an image is
-run ./check with TEST_DIR pointing to a good location so as not
+extended and BDRV_REQ_ZERO_WRITE is set then the new clusters are
-to skip the test), it's actually possible to create a qcow2 file
+zeroized.
 that expands to a sparse 512T image with just over 38M of content.
 The test is not the world's fastest (qemu crawling through 256M
 bits of refcount table to find the next cluster to allocate takes
 several seconds, as does qemu-img check reporting millions of
 leaked clusters); but it DOES catch the problem that the previous
 patch just fixed where writing a compressed cluster to a full
 image ended up overwriting the wrong cluster.
-Suggested-by: Max Reitz <mreitz@redhat.com>
+The code however does not detect correctly situations when the old and
-Signed-off-by: Eric Blake <eblake@redhat.com>
+the new end of the image are within the same cluster. The problem can
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+be reproduced with these steps:
    qemu-img create -f qcow2 backing.qcow2 1M
    qemu-img create -f qcow2 -F qcow2 -b backing.qcow2 top.qcow2
    qemu-img resize --shrink top.qcow2 520k
    qemu-img resize top.qcow2 567k
 In the last step offset - zero_start causes an integer wraparound.
 Signed-off-by: Alberto Garcia <berto@igalia.com>
 Message-Id: <20200504155217.10325-1-berto@igalia.com>
 Reviewed-by: Eric Blake <eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/220     | 96 ++++++++++++++++++++++++++++++++++++++
+ block/qcow2.c              | 12 ++++---
- tests/qemu-iotests/220.out | 54 +++++++++++++++++++++
+ tests/qemu-iotests/292     | 73 ++++++++++++++++++++++++++++++++++++++
  tests/qemu-iotests/292.out | 24 +++++++++++++
  tests/qemu-iotests/group   |  1 +
-files changed, 151 insertions(+)
+files changed, 105 insertions(+), 5 deletions(-)
- create mode 100755 tests/qemu-iotests/220
+ create mode 100755 tests/qemu-iotests/292
- create mode 100644 tests/qemu-iotests/220.out
+ create mode 100644 tests/qemu-iotests/292.out
-diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220
+diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
           * requires a cluster-aligned start. The end may be unaligned if it is
           * at the end of the image (which it is here).
           */
 -        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
 -        if (ret < 0) {
 -            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
 -            goto fail;
 +        if (offset > zero_start) {
 +            ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
 +            if (ret < 0) {
 +                error_setg_errno(errp, -ret, "Failed to zero out new clusters");
 +                goto fail;
 +            }
          }
          /* Write explicit zeros for the unaligned head */
          if (zero_start > old_length) {
 -            uint64_t len = zero_start - old_length;
 +            uint64_t len = MIN(zero_start, offset) - old_length;
              uint8_t *buf = qemu_blockalign0(bs, len);
              QEMUIOVector qiov;
              qemu_iovec_init_buf(&qiov, buf, len);
 diff --git a/tests/qemu-iotests/292 b/tests/qemu-iotests/292
 new file mode 100755
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/220
++++ b/tests/qemu-iotests/292
 @@ -XXX,XX +XXX,XX @@
-+#!/bin/bash
++#!/usr/bin/env bash
 +#
-+# max limits on compression in huge qcow2 files
++# Test resizing a qcow2 image with a backing file
 +#
-+# Copyright (C) 2018 Red Hat, Inc.
++# Copyright (C) 2020 Igalia, S.L.
 +# Author: Alberto Garcia <berto@igalia.com>
 +#
 +# This program is free software; you can redistribute it and/or modify
 +# it under the terms of the GNU General Public License as published by
 +# the Free Software Foundation; either version 2 of the License, or
 +# (at your option) any later version.
 ...
 +#
 +# You should have received a copy of the GNU General Public License
 +# along with this program.  If not, see <http://www.gnu.org/licenses/>.
 +#
 +
-+seq=$(basename $0)
++# creator
 +owner=berto@igalia.com
 +
 +seq=`basename $0`
 +echo "QA output created by $seq"
 +
 +status=1    # failure is the default!
 +
 +_cleanup()
 ...
 +trap "_cleanup; exit \$status" 0 1 2 3 15
 +
 +# get standard environment, filters and checks
 +. ./common.rc
 +. ./common.filter
-+. ./common.pattern
 +
 +_supported_fmt qcow2
 +_supported_proto file
 +_supported_os Linux
 +
-+echo "== Creating huge file =="
++echo '### Create the backing image'
 +BACKING_IMG="$TEST_IMG.base"
 +TEST_IMG="$BACKING_IMG" _make_test_img 1M
 +
-+# Sanity check: We require a file system that permits the creation
++echo '### Fill the backing image with data (0x11)'
-+# of a HUGE (but very sparse) file.  tmpfs works, ext4 does not.
++$QEMU_IO -c 'write -P 0x11 0 1M' "$BACKING_IMG" | _filter_qemu_io
 +if ! truncate --size=513T "$TEST_IMG"; then
 +    _notrun "file system on $TEST_DIR does not support large enough files"
 +fi
 +rm "$TEST_IMG"
 +IMGOPTS='cluster_size=2M,refcount_bits=1' _make_test_img 513T
 +
-+echo "== Populating refcounts =="
++echo '### Create the top image'
-+# We want an image with 256M refcounts * 2M clusters = 512T referenced.
++_make_test_img -F "$IMGFMT" -b "$BACKING_IMG"
 +# Each 2M cluster holds 16M refcounts; the refcount table initially uses
 +# 1 refblock, so we need to add 15 more.  The refcount table lives at 2M,
 +# first refblock at 4M, L2 at 6M, so our remaining additions start at 8M.
 +# Then, for each refblock, mark it as fully populated.
 +to_hex() {
 +    printf %016x\\n $1 | sed 's/\(..\)/\\x\1/g'
 +}
 +truncate --size=38m "$TEST_IMG"
 +entry=$((0x200000))
 +$QEMU_IO_PROG -f raw -c "w -P 0xff 4m 2m" "$TEST_IMG" | _filter_qemu_io
 +for i in {1..15}; do
 +    offs=$((0x600000 + i*0x200000))
 +    poke_file "$TEST_IMG" $((i*8 + entry)) $(to_hex $offs)
 +    $QEMU_IO_PROG -f raw -c "w -P 0xff $offs 2m" "$TEST_IMG" | _filter_qemu_io
 +done
 +
-+echo "== Checking file before =="
++echo '### Fill the top image with data (0x22)'
-+# FIXME: 'qemu-img check' doesn't diagnose refcounts beyond the end of
++$QEMU_IO -c 'write -P 0x22 0 1M' "$TEST_IMG" | _filter_qemu_io
 +# the file as leaked clusters
 +_check_test_img 2>&1 | sed '/^Leaked cluster/d'
 +stat -c 'image size %s' "$TEST_IMG"
 +
-+echo "== Trying to write compressed cluster =="
++# Both offsets are part of the same cluster.
-+# Given our file size, the next available cluster at 512T lies beyond the
++echo '### Shrink the image to 520k'
-+# maximum offset that a compressed 2M cluster can reside in
++$QEMU_IMG resize --shrink "$TEST_IMG" 520k
-+$QEMU_IO_PROG -c 'w -c 0 2m' "$TEST_IMG" | _filter_qemu_io
++echo '### Grow the image to 567k'
-+# The attempt failed, but ended up allocating a new refblock
++$QEMU_IMG resize "$TEST_IMG" 567k
 +stat -c 'image size %s' "$TEST_IMG"
 +
-+echo "== Writing normal cluster =="
++echo '### Check that the tail of the image reads as zeroes'
-+# The failed write should not corrupt the image, so a normal write succeeds
++$QEMU_IO -c 'read -P 0x22    0 520k' "$TEST_IMG" | _filter_qemu_io
-+$QEMU_IO_PROG -c 'w 0 2m' "$TEST_IMG" | _filter_qemu_io
++$QEMU_IO -c 'read -P 0x00 520k  47k' "$TEST_IMG" | _filter_qemu_io
 +
-+echo "== Checking file after =="
++echo '### Show output of qemu-img map'
-+# qemu-img now sees the millions of leaked clusters, thanks to the allocations
++$QEMU_IMG map "$TEST_IMG" | _filter_testdir
 +# at 512T.  Undo many of our faked references to speed up the check.
 +$QEMU_IO_PROG -f raw -c "w -z 5m 1m" -c "w -z 8m 30m" "$TEST_IMG" |
 +    _filter_qemu_io
 +_check_test_img 2>&1 | sed '/^Leaked cluster/d'
 +
 +# success, all done
 +echo "*** done"
 +rm -f $seq.full
 +status=0
-diff --git a/tests/qemu-iotests/220.out b/tests/qemu-iotests/220.out
+diff --git a/tests/qemu-iotests/292.out b/tests/qemu-iotests/292.out
 new file mode 100644
 index XXXXXXX..XXXXXXX
 --- /dev/null
-+++ b/tests/qemu-iotests/220.out
++++ b/tests/qemu-iotests/292.out
 @@ -XXX,XX +XXX,XX @@
-+QA output created by 220
++QA output created by 292
-+== Creating huge file ==
++### Create the backing image
-+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=564049465049088
++Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576
-+== Populating refcounts ==
++### Fill the backing image with data (0x11)
-+wrote 2097152/2097152 bytes at offset 4194304
++wrote 1048576/1048576 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 8388608
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 10485760
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 12582912
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 14680064
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 16777216
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 18874368
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 20971520
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 23068672
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 25165824
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 27262976
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 29360128
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 31457280
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 33554432
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 35651584
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +wrote 2097152/2097152 bytes at offset 37748736
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +== Checking file before ==
 +No errors were found on the image.
 +image size 39845888
 +== Trying to write compressed cluster ==
 +write failed: Input/output error
 +image size 562949957615616
 +== Writing normal cluster ==
 +wrote 2097152/2097152 bytes at offset 0
 +2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +== Checking file after ==
 +wrote 1048576/1048576 bytes at offset 5242880
 +1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
-+wrote 31457280/31457280 bytes at offset 8388608
++### Create the top image
-+30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
++Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.base backing_fmt=IMGFMT
-+
++### Fill the top image with data (0x22)
-+8388589 leaked clusters were found on the image.
++wrote 1048576/1048576 bytes at offset 0
-+This means waste of disk space, but no harm to data.
++1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +### Shrink the image to 520k
 +Image resized.
 +### Grow the image to 567k
 +Image resized.
 +### Check that the tail of the image reads as zeroes
 +read 532480/532480 bytes at offset 0
 +520 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +read 48128/48128 bytes at offset 532480
 +47 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
 +### Show output of qemu-img map
 +Offset          Length          Mapped to       File
 +0               0x8dc00         0x50000         TEST_DIR/t.qcow2
 +*** done
 diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/group
 +++ b/tests/qemu-iotests/group
 @@ -XXX,XX +XXX,XX @@
-rw auto quick
+quick
-rw auto quick
+rw quick
-rw auto
+rw auto quick
-+220 rw auto
++292 rw auto quick
 rw auto quick
 rw auto quick
 rw auto quick
 --
-.19.1
+.25.3

-New patch
+[PULL 10/30] vmdk: Rename VmdkMetaData.valid to new_allocation
+m_data is used for zero clusters even though valid == 0. It really only
+means that a new cluster was allocated in the image file. Rename it to
+reflect this.
+While at it, change it from int to bool, too.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430133007.170335-2-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/vmdk.c | 8 ++++----
+file changed, 4 insertions(+), 4 deletions(-)
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ typedef struct VmdkMetaData {
+     unsigned int l1_index;
+     unsigned int l2_index;
+     unsigned int l2_offset;
+-    int valid;
++    bool new_allocation;
+     uint32_t *l2_cache_entry;
+ } VmdkMetaData;
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+     unsigned int l2_size_bytes = extent->l2_size * extent->entry_size;
+     if (m_data) {
+-        m_data->valid = 0;
++        m_data->new_allocation = false;
+     }
+     if (extent->flat) {
+         *cluster_offset = extent->flat_start_offset;
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+             return ret;
+         }
+         if (m_data) {
+-            m_data->valid = 1;
++            m_data->new_allocation = true;
+             m_data->l1_index = l1_index;
+             m_data->l2_index = l2_index;
+             m_data->l2_offset = l2_offset;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
+             if (ret) {
+                 return ret;
+             }
+-            if (m_data.valid) {
++            if (m_data.new_allocation) {
+                 /* update L2 tables */
+                 if (vmdk_L2update(extent, &m_data,
+                                   cluster_offset >> BDRV_SECTOR_BITS)
+--
+.25.3

-New patch
+[PULL 11/30] vmdk: Fix zero cluster allocation
+m_data must contain valid data even for zero clusters when no cluster
+was allocated in the image file. Without this, zero writes segfault with
+images that have zeroed_grain=on.
+For zero writes, we don't want to allocate a cluster in the image file
+even in compressed files.
+Fixes: 524089bce43fd1cd3daaca979872451efa2cf7c6
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430133007.170335-3-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/vmdk.c | 12 +++++++-----
+file changed, 7 insertions(+), 5 deletions(-)
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+     extent->l2_cache_counts[min_index] = 1;
+  found:
+     l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;
++    if (m_data) {
++        m_data->l1_index = l1_index;
++        m_data->l2_index = l2_index;
++        m_data->l2_offset = l2_offset;
++        m_data->l2_cache_entry = ((uint32_t *)l2_table) + l2_index;
++    }
+     if (extent->sesparse) {
+         cluster_sector = le64_to_cpu(((uint64_t *)l2_table)[l2_index]);
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+         }
+         if (m_data) {
+             m_data->new_allocation = true;
+-            m_data->l1_index = l1_index;
+-            m_data->l2_index = l2_index;
+-            m_data->l2_offset = l2_offset;
+-            m_data->l2_cache_entry = ((uint32_t *)l2_table) + l2_index;
+         }
+     }
+     *cluster_offset = cluster_sector << BDRV_SECTOR_BITS;
+@@ -XXX,XX +XXX,XX @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
+                 error_report("Could not write to allocated cluster"
+                               " for streamOptimized");
+                 return -EIO;
+-            } else {
++            } else if (!zeroed) {
+                 /* allocate */
+                 ret = get_cluster_offset(bs, extent, &m_data, offset,
+                                          true, &cluster_offset, 0, 0);
+--
+.25.3

-New patch
+[PULL 12/30] vmdk: Fix partial overwrite of zero cluster
+When overwriting a zero cluster, we must not perform copy-on-write from
+the backing file, but from a zeroed buffer.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430133007.170335-4-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/vmdk.c | 18 ++++++++++++------
+file changed, 12 insertions(+), 6 deletions(-)
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ static void vmdk_refresh_limits(BlockDriverState *bs, Error **errp)
+  * get_whole_cluster
+  *
+  * Copy backing file's cluster that covers @sector_num, otherwise write zero,
+- * to the cluster at @cluster_sector_num.
++ * to the cluster at @cluster_sector_num. If @zeroed is true, we're overwriting
++ * a zeroed cluster in the current layer and must not copy data from the
++ * backing file.
+  *
+  * If @skip_start_sector < @skip_end_sector, the relative range
+  * [@skip_start_sector, @skip_end_sector) is not copied or written, and leave
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+                              uint64_t cluster_offset,
+                              uint64_t offset,
+                              uint64_t skip_start_bytes,
+-                             uint64_t skip_end_bytes)
++                             uint64_t skip_end_bytes,
++                             bool zeroed)
+ {
+     int ret = VMDK_OK;
+     int64_t cluster_bytes;
+     uint8_t *whole_grain;
++    bool copy_from_backing;
+     /* For COW, align request sector_num to cluster start */
+     cluster_bytes = extent->cluster_sectors << BDRV_SECTOR_BITS;
+     offset = QEMU_ALIGN_DOWN(offset, cluster_bytes);
+     whole_grain = qemu_blockalign(bs, cluster_bytes);
++    copy_from_backing = bs->backing && !zeroed;
+-    if (!bs->backing) {
++    if (!copy_from_backing) {
+         memset(whole_grain, 0, skip_start_bytes);
+         memset(whole_grain + skip_end_bytes, 0, cluster_bytes - skip_end_bytes);
+     }
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+     /* Read backing data before skip range */
+     if (skip_start_bytes > 0) {
+-        if (bs->backing) {
++        if (copy_from_backing) {
+             /* qcow2 emits this on bs->file instead of bs->backing */
+             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+             ret = bdrv_pread(bs->backing, offset, whole_grain,
+@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
+     }
+     /* Read backing data after skip range */
+     if (skip_end_bytes < cluster_bytes) {
+-        if (bs->backing) {
++        if (copy_from_backing) {
+             /* qcow2 emits this on bs->file instead of bs->backing */
+             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
+             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
+@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
+          * or inappropriate VM shutdown.
+          */
+         ret = get_whole_cluster(bs, extent, cluster_sector * BDRV_SECTOR_SIZE,
+-                                offset, skip_start_bytes, skip_end_bytes);
++                                offset, skip_start_bytes, skip_end_bytes,
++                                zeroed);
+         if (ret) {
+             return ret;
+         }
+--
+.25.3

-New patch
+[PULL 13/30] vmdk: Don't update L2 table for zero write on zero cluster
+If a cluster is already zeroed, we don't have to call vmdk_L2update(),
+which is rather slow because it flushes the image file.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430133007.170335-5-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/vmdk.c | 2 +-
+file changed, 1 insertion(+), 1 deletion(-)
+diff --git a/block/vmdk.c b/block/vmdk.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/vmdk.c
++++ b/block/vmdk.c
+@@ -XXX,XX +XXX,XX @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
+                     offset_in_cluster == 0 &&
+                     n_bytes >= extent->cluster_sectors * BDRV_SECTOR_SIZE) {
+                 n_bytes = extent->cluster_sectors * BDRV_SECTOR_SIZE;
+-                if (!zero_dry_run) {
++                if (!zero_dry_run && ret != VMDK_ZEROED) {
+                     /* update L2 tables */
+                     if (vmdk_L2update(extent, &m_data, VMDK_GTE_ZEROED)
+                             != VMDK_OK) {
+--
+.25.3

-[Qemu-devel] [PULL 2/9] fdc: fix segfault in fdctrl_stop_transfer() when DMA is disabled
+[PULL 14/30] vmdk: Flush only once in vmdk_L2update()
-From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
+If we have a backup L2 table, we currently flush once after writing to
 the active L2 table and again after writing to the backup table. A
 single flush is enough and makes things a little less slow.
-Commit c8a35f1cf0f "fdc: use IsaDma interface instead of global DMA_*
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-functions" accidentally introduced a segfault in fdctrl_stop_transfer() for
+Message-Id: <20200430133007.170335-6-kwolf@redhat.com>
-non-DMA transfers.
+Reviewed-by: Eric Blake <eblake@redhat.com>
 If fdctrl->dma_chann has not been configured then the fdctrl->dma interface
 reference isn't initialised during isabus_fdc_realize(). Unfortunately
 fdctrl_stop_transfer() unconditionally references the DMA interface when
 finishing the transfer causing a NULL pointer dereference.
 Fix the issue by adding a check in fdctrl_stop_transfer() so that the DMA
 interface reference and release method is only invoked if fdctrl->dma_chann
 has been set.
 (This issue was discovered by Martin testing a recent change in the NetBSD
 installer under qemu-system-sparc)
 Cc: qemu-stable@nongnu.org
 Reported-by: Martin Husemann <martin@duskware.de>
 Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
 Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
 Reviewed-by: Hervé Poussineau <hpoussin@reactos.org>
 Reviewed-by: John Snow <jsnow@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- hw/block/fdc.c | 2 +-
+ block/vmdk.c | 7 +++++--
-file changed, 1 insertion(+), 1 deletion(-)
+file changed, 5 insertions(+), 2 deletions(-)
-diff --git a/hw/block/fdc.c b/hw/block/fdc.c
+diff --git a/block/vmdk.c b/block/vmdk.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/fdc.c
+--- a/block/vmdk.c
-+++ b/hw/block/fdc.c
++++ b/block/vmdk.c
-@@ -XXX,XX +XXX,XX @@ static void fdctrl_stop_transfer(FDCtrl *fdctrl, uint8_t status0,
+@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
-     fdctrl->fifo[5] = cur_drv->sect;
+     offset = cpu_to_le32(offset);
-     fdctrl->fifo[6] = FD_SECTOR_SC;
+     /* update L2 table */
-     fdctrl->data_dir = FD_DIR_READ;
+     BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE);
--    if (!(fdctrl->msr & FD_MSR_NONDMA)) {
+-    if (bdrv_pwrite_sync(extent->file,
-+    if (fdctrl->dma_chann != -1 && !(fdctrl->msr & FD_MSR_NONDMA)) {
++    if (bdrv_pwrite(extent->file,
-         IsaDmaClass *k = ISADMA_GET_CLASS(fdctrl->dma);
+                 ((int64_t)m_data->l2_offset * 512)
-         k->release_DREQ(fdctrl->dma, fdctrl->dma_chann);
+                     + (m_data->l2_index * sizeof(offset)),
                  &offset, sizeof(offset)) < 0) {
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
      /* update backup L2 table */
      if (extent->l1_backup_table_offset != 0) {
          m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];
 -        if (bdrv_pwrite_sync(extent->file,
 +        if (bdrv_pwrite(extent->file,
                      ((int64_t)m_data->l2_offset * 512)
                          + (m_data->l2_index * sizeof(offset)),
                      &offset, sizeof(offset)) < 0) {
              return VMDK_ERROR;
          }
      }
 +    if (bdrv_flush(extent->file->bs) < 0) {
 +        return VMDK_ERROR;
 +    }
      if (m_data->l2_cache_entry) {
          *m_data->l2_cache_entry = offset;
      }
 --
-.19.1
+.25.3

-New patch
+[PULL 15/30] iotests: vmdk: Enable zeroed_grained=on by default
+In order to avoid bitrot in the zero cluster code in VMDK, enable
+zeroed_grain=on by default for the tests.
+now unsets the default options because zeroed_grain=on works only
+with some subformats and the test case tests many different subformats,
+including those for which it doesn't work.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430133007.170335-7-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/059   | 6 +++---
+ tests/qemu-iotests/check | 3 +++
+files changed, 6 insertions(+), 3 deletions(-)
+diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/059
++++ b/tests/qemu-iotests/059
+@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
+ _supported_fmt vmdk
+ _supported_proto file
+ _supported_os Linux
+-_unsupported_imgopts "subformat=monolithicFlat" \
+-                     "subformat=twoGbMaxExtentFlat" \
+-                     "subformat=twoGbMaxExtentSparse"
++
++# We test all kinds of VMDK options here, so ignore user-specified options
++IMGOPTS=""
+ capacity_offset=16
+ granularity_offset=20
+diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/check
++++ b/tests/qemu-iotests/check
+@@ -XXX,XX +XXX,XX @@ fi
+ if [ "$IMGFMT" == "luks" ] && ! (echo "$IMGOPTS" | grep "iter-time=" > /dev/null); then
+     IMGOPTS=$(_optstr_add "$IMGOPTS" "iter-time=10")
+ fi
++if [ "$IMGFMT" == "vmdk" ] && ! (echo "$IMGOPTS" | grep "zeroed_grain=" > /dev/null); then
++    IMGOPTS=$(_optstr_add "$IMGOPTS" "zeroed_grain=on")
++fi
+ if [ -z "$SAMPLE_IMG_DIR" ]; then
+         SAMPLE_IMG_DIR="$source_iotests/sample_images"
+--
+.25.3

-New patch
+[PULL 16/30] iotests/283: Use consistent size for source and target
+The test case forgot to specify the null-co size for the target node.
+When adding a check to backup that both sizes match, this would fail
+because of the size mismatch and not the behaviour that the test really
+wanted to test.
+Fixes: a541fcc27c98b96da187c7d4573f3270f3ddd283
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430142755.315494-2-kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/283     | 6 +++++-
+ tests/qemu-iotests/283.out | 2 +-
+files changed, 6 insertions(+), 2 deletions(-)
+diff --git a/tests/qemu-iotests/283 b/tests/qemu-iotests/283
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/283
++++ b/tests/qemu-iotests/283
+@@ -XXX,XX +XXX,XX @@ to check that crash is fixed :)
+ vm = iotests.VM()
+ vm.launch()
+-vm.qmp_log('blockdev-add', **{'node-name': 'target', 'driver': 'null-co'})
++vm.qmp_log('blockdev-add', **{
++    'node-name': 'target',
++    'driver': 'null-co',
++    'size': size,
++})
+ vm.qmp_log('blockdev-add', **{
+     'node-name': 'source',
+diff --git a/tests/qemu-iotests/283.out b/tests/qemu-iotests/283.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/283.out
++++ b/tests/qemu-iotests/283.out
+@@ -XXX,XX +XXX,XX @@
+-{"execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "target"}}
++{"execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "target", "size": 1048576}}
+ {"return": {}}
+ {"execute": "blockdev-add", "arguments": {"driver": "blkdebug", "image": {"driver": "null-co", "node-name": "base", "size": 1048576}, "node-name": "source"}}
+ {"return": {}}
+--
+.25.3

-New patch
+[PULL 17/30] backup: Improve error for bdrv_getlength() failure
+bdrv_get_device_name() will be an empty string with modern management
+tools that don't use -drive. Use bdrv_get_device_or_node_name() instead
+so that the node name is used if the BlockBackend is anonymous.
+While at it, start with upper case to make the message consistent with
+the rest of the function.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
+Message-Id: <20200430142755.315494-3-kwolf@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/backup.c | 4 ++--
+file changed, 2 insertions(+), 2 deletions(-)
+diff --git a/block/backup.c b/block/backup.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/backup.c
++++ b/block/backup.c
+@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
+     len = bdrv_getlength(bs);
+     if (len < 0) {
+-        error_setg_errno(errp, -len, "unable to get length for '%s'",
+-                         bdrv_get_device_name(bs));
++        error_setg_errno(errp, -len, "Unable to get length for '%s'",
++                         bdrv_get_device_or_node_name(bs));
+         goto error;
+     }
+--
+.25.3

-New patch
+[PULL 18/30] backup: Make sure that source and target size match
+Since the introduction of a backup filter node in commit 00e30f05d, the
+backup block job crashes when the target image is smaller than the
+source image because it will try to write after the end of the target
+node without having BLK_PERM_RESIZE. (Previously, the BlockBackend layer
+would have caught this and errored out gracefully.)
+We can fix this and even do better than the old behaviour: Check that
+source and target have the same image size at the start of the block job
+and unshare BLK_PERM_RESIZE. (This permission was already unshared
+before the same commit 00e30f05d, but the BlockBackend that was used to
+make the restriction was removed without a replacement.) This will
+immediately error out when starting the job instead of only when writing
+to a block that doesn't exist in the target.
+Longer target than source would technically work because we would never
+write to blocks that don't exist, but semantically these are invalid,
+too, because a backup is supposed to create a copy, not just an image
+that starts with a copy.
+Fixes: 00e30f05de1d19586345ec373970ef4c192c6270
+Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1778593
+Cc: qemu-stable@nongnu.org
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430142755.315494-4-kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/backup-top.c | 14 +++++++++-----
+ block/backup.c     | 14 +++++++++++++-
+files changed, 22 insertions(+), 6 deletions(-)
+diff --git a/block/backup-top.c b/block/backup-top.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/backup-top.c
++++ b/block/backup-top.c
+@@ -XXX,XX +XXX,XX @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
+          *
+          * Share write to target (child_file), to not interfere
+          * with guest writes to its disk which may be in target backing chain.
++         * Can't resize during a backup block job because we check the size
++         * only upfront.
+          */
+-        *nshared = BLK_PERM_ALL;
++        *nshared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
+         *nperm = BLK_PERM_WRITE;
+     } else {
+         /* Source child */
+@@ -XXX,XX +XXX,XX @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
+         if (perm & BLK_PERM_WRITE) {
+             *nperm = *nperm | BLK_PERM_CONSISTENT_READ;
+         }
+-        *nshared &= ~BLK_PERM_WRITE;
++        *nshared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
+     }
+ }
+@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
+ {
+     Error *local_err = NULL;
+     BDRVBackupTopState *state;
+-    BlockDriverState *top = bdrv_new_open_driver(&bdrv_backup_top_filter,
+-                                                 filter_node_name,
+-                                                 BDRV_O_RDWR, errp);
++    BlockDriverState *top;
+     bool appended = false;
++    assert(source->total_sectors == target->total_sectors);
++
++    top = bdrv_new_open_driver(&bdrv_backup_top_filter, filter_node_name,
++                               BDRV_O_RDWR, errp);
+     if (!top) {
+         return NULL;
+     }
+diff --git a/block/backup.c b/block/backup.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/backup.c
++++ b/block/backup.c
+@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
+                   BlockCompletionFunc *cb, void *opaque,
+                   JobTxn *txn, Error **errp)
+ {
+-    int64_t len;
++    int64_t len, target_len;
+     BackupBlockJob *job = NULL;
+     int64_t cluster_size;
+     BdrvRequestFlags write_flags;
+@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
+         goto error;
+     }
++    target_len = bdrv_getlength(target);
++    if (target_len < 0) {
++        error_setg_errno(errp, -target_len, "Unable to get length for '%s'",
++                         bdrv_get_device_or_node_name(bs));
++        goto error;
++    }
++
++    if (target_len != len) {
++        error_setg(errp, "Source and target image have different sizes");
++        goto error;
++    }
++
+     cluster_size = backup_calculate_cluster_size(target, errp);
+     if (cluster_size < 0) {
+         goto error;
+--
+.25.3

-New patch
+[PULL 19/30] iotests: Backup with different source/target size
+This tests that the backup job catches situations where the target node
+has a different size than the source node. It must also forbid resize
+operations when the job is already running.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200430142755.315494-5-kwolf@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/055     | 41 ++++++++++++++++++++++++++++++++++++--
+ tests/qemu-iotests/055.out |  4 ++--
+files changed, 41 insertions(+), 4 deletions(-)
+diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/055
++++ b/tests/qemu-iotests/055
+@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
+     def setUp(self):
+         qemu_img('create', '-f', iotests.imgfmt, blockdev_target_img, str(image_len))
+-        self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
+-        self.vm.add_drive(blockdev_target_img, interface="none")
++        self.vm = iotests.VM()
++        self.vm.add_drive('blkdebug::' + test_img, 'node-name=source')
++        self.vm.add_drive(blockdev_target_img, 'node-name=target',
++                          interface="none")
+         if iotests.qemu_default_machine == 'pc':
+             self.vm.add_drive(None, 'media=cdrom', 'ide')
+         self.vm.launch()
+@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
+     def test_pause_blockdev_backup(self):
+         self.do_test_pause('blockdev-backup', 'drive1', blockdev_target_img)
++    def do_test_resize_blockdev_backup(self, device, node):
++        def pre_finalize():
++            result = self.vm.qmp('block_resize', device=device, size=65536)
++            self.assert_qmp(result, 'error/class', 'GenericError')
++
++            result = self.vm.qmp('block_resize', node_name=node, size=65536)
++            self.assert_qmp(result, 'error/class', 'GenericError')
++
++        result = self.vm.qmp('blockdev-backup', job_id='job0', device='drive0',
++                             target='drive1', sync='full', auto_finalize=False,
++                             auto_dismiss=False)
++        self.assert_qmp(result, 'return', {})
++
++        self.vm.run_job('job0', auto_finalize=False, pre_finalize=pre_finalize)
++
++    def test_source_resize_blockdev_backup(self):
++        self.do_test_resize_blockdev_backup('drive0', 'source')
++
++    def test_target_resize_blockdev_backup(self):
++        self.do_test_resize_blockdev_backup('drive1', 'target')
++
++    def do_test_target_size(self, size):
++        result = self.vm.qmp('block_resize', device='drive1', size=size)
++        self.assert_qmp(result, 'return', {})
++
++        result = self.vm.qmp('blockdev-backup', job_id='job0', device='drive0',
++                             target='drive1', sync='full')
++        self.assert_qmp(result, 'error/class', 'GenericError')
++
++    def test_small_target(self):
++        self.do_test_target_size(image_len // 2)
++
++    def test_large_target(self):
++        self.do_test_target_size(image_len * 2)
++
+     def test_medium_not_found(self):
+         if iotests.qemu_default_machine != 'pc':
+             return
+diff --git a/tests/qemu-iotests/055.out b/tests/qemu-iotests/055.out
+index XXXXXXX..XXXXXXX 100644
+--- a/tests/qemu-iotests/055.out
++++ b/tests/qemu-iotests/055.out
+@@ -XXX,XX +XXX,XX @@
+-....................................
++........................................
+ ----------------------------------------------------------------------
+-Ran 36 tests
++Ran 40 tests
+ OK
+--
+.25.3

-New patch
+[PULL 20/30] iotests/055: Use cache.no-flush for vmdk target
+uses the backup block job to create a compressed backup of an
+$IMGFMT image with both qcow2 and vmdk targets. However, cluster
+allocation in vmdk is very slow because it flushes the image file after
+each L2 update.
+There is no reason why we need this level of safety in this test, so
+let's disable flushes for vmdk. For the blockdev-backup tests this is
+achieved by simply adding the cache.no-flush=on to the drive_add() for
+the target. For drive-backup, the caching flags are copied from the
+source node, so we'll also add the flag to the source node, even though
+it is not vmdk.
+This can make the test run significantly faster (though it doesn't make
+a difference on tmpfs). In my usual setup it goes from ~45s to ~15s.
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+Message-Id: <20200505064618.16267-1-kwolf@redhat.com>
+Reviewed-by: Eric Blake <eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ tests/qemu-iotests/055 | 11 +++++++----
+file changed, 7 insertions(+), 4 deletions(-)
+diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
+index XXXXXXX..XXXXXXX 100755
+--- a/tests/qemu-iotests/055
++++ b/tests/qemu-iotests/055
+@@ -XXX,XX +XXX,XX @@ class TestSingleTransaction(iotests.QMPTestCase):
+ class TestCompressedToQcow2(iotests.QMPTestCase):
+     image_len = 64 * 1024 * 1024 # MB
+-    target_fmt = {'type': 'qcow2', 'args': ()}
++    target_fmt = {'type': 'qcow2', 'args': (), 'drive-opts': ''}
+     def tearDown(self):
+         self.vm.shutdown()
+@@ -XXX,XX +XXX,XX @@ class TestCompressedToQcow2(iotests.QMPTestCase):
+             pass
+     def do_prepare_drives(self, attach_target):
+-        self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
++        self.vm = iotests.VM().add_drive('blkdebug::' + test_img,
++                                         opts=self.target_fmt['drive-opts'])
+         qemu_img('create', '-f', self.target_fmt['type'], blockdev_target_img,
+                  str(self.image_len), *self.target_fmt['args'])
+         if attach_target:
+             self.vm.add_drive(blockdev_target_img,
+                               img_format=self.target_fmt['type'],
+-                              interface="none")
++                              interface="none",
++                              opts=self.target_fmt['drive-opts'])
+         self.vm.launch()
+@@ -XXX,XX +XXX,XX @@ class TestCompressedToQcow2(iotests.QMPTestCase):
+ class TestCompressedToVmdk(TestCompressedToQcow2):
+-    target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}
++    target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized'),
++                  'drive-opts': 'cache.no-flush=on'}
+     @iotests.skip_if_unsupported(['vmdk'])
+     def setUp(self):
+--
+.25.3

-[Qemu-devel] [PULL 9/9] iotests: Test file-posix locking and reopen
+[PULL 21/30] qcow2: Fix preallocation on block devices
 From: Max Reitz <mreitz@redhat.com>
+Calling bdrv_getlength() to get the pre-truncate file size will not
+really work on block devices, because they have always the same length,
+and trying to write beyond it will fail with a rather cryptic error
+message.
+Instead, we should use qcow2_get_last_cluster() and bdrv_getlength()
+only as a fallback.
+Before this patch:
+$ truncate -s 1G test.img
+$ sudo losetup -f --show test.img
+/dev/loop0
+$ sudo qemu-img create -f qcow2 -o preallocation=full /dev/loop0 64M
+Formatting '/dev/loop0', fmt=qcow2 size=67108864 cluster_size=65536
+preallocation=full lazy_refcounts=off refcount_bits=16
+qemu-img: /dev/loop0: Could not resize image: Failed to resize refcount
+structures: No space left on device
+With this patch:
+$ sudo qemu-img create -f qcow2 -o preallocation=full /dev/loop0 64M
+Formatting '/dev/loop0', fmt=qcow2 size=67108864 cluster_size=65536
+preallocation=full lazy_refcounts=off refcount_bits=16
+qemu-img: /dev/loop0: Could not resize image: Failed to resize
+underlying file: Preallocation mode 'full' unsupported for this
+non-regular file
+So as you can see, it still fails, but now the problem is missing
+support on the block device level, so we at least get a better error
+message.
+Note that we cannot preallocate block devices on truncate by design,
+because we do not know what area to preallocate.  Their length is always
+the same, the truncate operation does not change it.
 Signed-off-by: Max Reitz <mreitz@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+Message-Id: <20200505141801.1096763-1-mreitz@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- tests/qemu-iotests/182     | 71 ++++++++++++++++++++++++++++++++++++++
+ block/qcow2.c | 10 ++++++++--
- tests/qemu-iotests/182.out |  9 +++++
+file changed, 8 insertions(+), 2 deletions(-)
 files changed, 80 insertions(+)
-diff --git a/tests/qemu-iotests/182 b/tests/qemu-iotests/182
+diff --git a/block/qcow2.c b/block/qcow2.c
-index XXXXXXX..XXXXXXX 100755
+index XXXXXXX..XXXXXXX 100644
---- a/tests/qemu-iotests/182
+--- a/block/qcow2.c
-+++ b/tests/qemu-iotests/182
++++ b/block/qcow2.c
-@@ -XXX,XX +XXX,XX @@ status=1    # failure is the default!
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
- _cleanup()
+     {
- {
+         int64_t allocation_start, host_offset, guest_offset;
-     _cleanup_test_img
+         int64_t clusters_allocated;
-+    rm -f "$TEST_IMG.overlay"
+-        int64_t old_file_size, new_file_size;
- }
++        int64_t old_file_size, last_cluster, new_file_size;
- trap "_cleanup; exit \$status" 0 1 2 3 15
+         uint64_t nb_new_data_clusters, nb_new_l2_tables;
-@@ -XXX,XX +XXX,XX @@ echo 'quit' | $QEMU -nographic -monitor stdio \
+         /* With a data file, preallocation means just allocating the metadata
+@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
- _cleanup_qemu
+             ret = old_file_size;
+             goto fail;
-+echo
+         }
-+echo '=== Testing reopen ==='
+-        old_file_size = ROUND_UP(old_file_size, s->cluster_size);
 +echo
 +
-+# This tests that reopening does not unshare any permissions it should
++        last_cluster = qcow2_get_last_cluster(bs, old_file_size);
-+# not unshare
++        if (last_cluster >= 0) {
-+# (There was a bug where reopening shared exactly the opposite of the
++            old_file_size = (last_cluster + 1) * s->cluster_size;
-+# permissions it was supposed to share)
++        } else {
-+
++            old_file_size = ROUND_UP(old_file_size, s->cluster_size);
-+_launch_qemu
++        }
-+
-+_send_qemu_cmd $QEMU_HANDLE \
+         nb_new_data_clusters = DIV_ROUND_UP(offset - old_length,
-+    "{'execute': 'qmp_capabilities'}" \
+                                             s->cluster_size);
 +    'return'
 +
 +# Open the image without any format layer (we are not going to access
 +# it, so that is fine)
 +# This should keep all permissions shared.
 +success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'blockdev-add',
 +      'arguments': {
 +          'node-name': 'node0',
 +          'driver': 'file',
 +          'filename': '$TEST_IMG',
 +          'locking': 'on'
 +          } }" \
 +    'return' \
 +    'error'
 +
 +# This snapshot will perform a reopen to drop R/W to RO.
 +# It should still keep all permissions shared.
 +success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'blockdev-snapshot-sync',
 +      'arguments': {
 +          'node-name': 'node0',
 +          'snapshot-file': '$TEST_IMG.overlay',
 +          'snapshot-node-name': 'node1'
 +      } }" \
 +    'return' \
 +    'error'
 +
 +# Now open the same file again
 +# This does not require any permissions (and does not unshare any), so
 +# this will not conflict with node0.
 +success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'blockdev-add',
 +      'arguments': {
 +          'node-name': 'node1',
 +          'driver': 'file',
 +          'filename': '$TEST_IMG',
 +          'locking': 'on'
 +          } }" \
 +    'return' \
 +    'error'
 +
 +# Now we attach the image to a virtio-blk device.  This device does
 +# require some permissions (at least WRITE and READ_CONSISTENT), so if
 +# reopening node0 unshared any (which it should not have), this will
 +# fail (but it should not).
 +success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
 +    "{'execute': 'device_add',
 +      'arguments': {
 +          'driver': 'virtio-blk',
 +          'drive': 'node1'
 +      } }" \
 +    'return' \
 +    'error'
 +
 +_cleanup_qemu
 +
  # success, all done
  echo "*** done"
  rm -f $seq.full
 diff --git a/tests/qemu-iotests/182.out b/tests/qemu-iotests/182.out
 index XXXXXXX..XXXXXXX 100644
 --- a/tests/qemu-iotests/182.out
 +++ b/tests/qemu-iotests/182.out
@@ -XXX,XX +XXX,XX @@ Starting QEMU
  Starting a second QEMU using the same image should fail
  QEMU_PROG: -drive file=TEST_DIR/t.qcow2,if=none,id=drive0,file.locking=on: Failed to get "write" lock
  Is another process using the image [TEST_DIR/t.qcow2]?
 +
 +=== Testing reopen ===
 +
 +{"return": {}}
 +{"return": {}}
 +Formatting 'TEST_DIR/t.qcow2.overlay', fmt=qcow2 size=197120 backing_file=TEST_DIR/t.qcow2 backing_fmt=file cluster_size=65536 lazy_refcounts=off refcount_bits=16
 +{"return": {}}
 +{"return": {}}
 +{"return": {}}
  *** done
 --
-.19.1
+.25.3

-[Qemu-devel] [PULL 1/9] nvme: fix oob access issue(CVE-2018-16847)
+[PULL 22/30] gluster: Drop useless has_zero_init callback
-From: Li Qiang <liq3ea@gmail.com>
+From: Eric Blake <eblake@redhat.com>
-Currently, the nvme_cmb_ops mr doesn't check the addr and size.
+block.c already defaults to 0 if we don't provide a callback; there's
-This can lead an oob access issue. This is triggerable in the guest.
+no need to write a callback that always fails.
 Add check to avoid this issue.
-Fixes CVE-2018-16847.
+Signed-off-by: Eric Blake <eblake@redhat.com>
+Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
-Reported-by: Li Qiang <liq3ea@gmail.com>
+Reviewed-by: Alberto Garcia <berto@igalia.com>
-Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
+Message-Id: <20200428202905.770727-2-eblake@redhat.com>
 Signed-off-by: Li Qiang <liq3ea@gmail.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- hw/block/nvme.c | 7 +++++++
+ block/gluster.c | 14 --------------
-file changed, 7 insertions(+)
+file changed, 14 deletions(-)
-diff --git a/hw/block/nvme.c b/hw/block/nvme.c
+diff --git a/block/gluster.c b/block/gluster.c
 index XXXXXXX..XXXXXXX 100644
---- a/hw/block/nvme.c
+--- a/block/gluster.c
-+++ b/hw/block/nvme.c
++++ b/block/gluster.c
-@@ -XXX,XX +XXX,XX @@ static void nvme_cmb_write(void *opaque, hwaddr addr, uint64_t data,
+@@ -XXX,XX +XXX,XX @@ static int64_t qemu_gluster_allocated_file_size(BlockDriverState *bs)
-     unsigned size)
+     }
  {
      NvmeCtrl *n = (NvmeCtrl *)opaque;
 +
 +    if (addr + size > NVME_CMBSZ_GETSIZE(n->bar.cmbsz)) {
 +        return;
 +    }
      memcpy(&n->cmbuf[addr], &data, size);
  }
-@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_cmb_read(void *opaque, hwaddr addr, unsigned size)
+-static int qemu_gluster_has_zero_init(BlockDriverState *bs)
-     uint64_t val;
+-{
-     NvmeCtrl *n = (NvmeCtrl *)opaque;
+-    /* GlusterFS volume could be backed by a block device */
+-    return 0;
-+    if (addr + size > NVME_CMBSZ_GETSIZE(n->bar.cmbsz)) {
+-}
-+        return 0;
+-
-+    }
+ /*
-     memcpy(&val, &n->cmbuf[addr], size);
+  * Find allocation range in @bs around offset @start.
-     return val;
+  * May change underlying file descriptor's file offset.
- }
+@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster = {
      .bdrv_co_readv                = qemu_gluster_co_readv,
      .bdrv_co_writev               = qemu_gluster_co_writev,
      .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
 -    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
 -    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
  #ifdef CONFIG_GLUSTERFS_DISCARD
      .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
  #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_tcp = {
      .bdrv_co_readv                = qemu_gluster_co_readv,
      .bdrv_co_writev               = qemu_gluster_co_writev,
      .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
 -    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
 -    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
  #ifdef CONFIG_GLUSTERFS_DISCARD
      .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
  #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_unix = {
      .bdrv_co_readv                = qemu_gluster_co_readv,
      .bdrv_co_writev               = qemu_gluster_co_writev,
      .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
 -    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
 -    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
  #ifdef CONFIG_GLUSTERFS_DISCARD
      .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
  #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_rdma = {
      .bdrv_co_readv                = qemu_gluster_co_readv,
      .bdrv_co_writev               = qemu_gluster_co_writev,
      .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
 -    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
 -    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
  #ifdef CONFIG_GLUSTERFS_DISCARD
      .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
  #endif
 --
-.19.1
+.25.3

-New patch
+[PULL 23/30] file-win32: Support BDRV_REQ_ZERO_WRITE for truncate
+From: Eric Blake <eblake@redhat.com>
+When using bdrv_file, .bdrv_has_zero_init_truncate always returns 1;
+therefore, we can behave just like file-posix, and always implement
+BDRV_REQ_ZERO_WRITE by ignoring it since the OS gives it to us for
+free (note that file-posix.c had to use an 'if' because it shared code
+between regular files and block devices, but in file-win32.c,
+bdrv_host_device uses a separate .bdrv_file_open).
+Signed-off-by: Eric Blake <eblake@redhat.com>
+Message-Id: <20200428202905.770727-3-eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/file-win32.c | 3 +++
+file changed, 3 insertions(+)
+diff --git a/block/file-win32.c b/block/file-win32.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/file-win32.c
++++ b/block/file-win32.c
+@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
+         win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));
+     }
++    /* When extending regular files, we get zeros from the OS */
++    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
++
+     ret = 0;
+ fail:
+     qemu_opts_del(opts);
+--
+.25.3

-[Qemu-devel] [PULL 5/9] qcow2: Don't allow overflow during cluster allocation
+[PULL 24/30] nfs: Support BDRV_REQ_ZERO_WRITE for truncate
 From: Eric Blake <eblake@redhat.com>
-Our code was already checking that we did not attempt to
+Our .bdrv_has_zero_init_truncate returns 1 if we detect that the OS
-allocate more clusters than what would fit in an INT64 (the
+always 0-fills; we can use that same knowledge to implement
-physical maximimum if we can access a full off_t's worth of
+BDRV_REQ_ZERO_WRITE by ignoring it when the OS gives it to us for
-data).  But this does not catch smaller limits enforced by
+free.
 various spots in the qcow2 image description: L1 and normal
 clusters of L2 are documented as having bits 63-56 reserved
 for other purposes, capping our maximum offset at 64PB (bit
 is the maximum bit set).  And for compressed images with
 M clusters, the cap drops the maximum offset to bit 48, or
 a maximum offset of 512TB.  If we overflow that offset, we
 would write compressed data into one place, but try to
 decompress from another, which won't work.
 It's actually possible to prove that overflow can cause image
 corruption without this patch; I'll add the iotests separately
 in the next commit.
 Signed-off-by: Eric Blake <eblake@redhat.com>
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+Message-Id: <20200428202905.770727-4-eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/qcow2.h          |  6 ++++++
+ block/nfs.c | 3 +++
- block/qcow2-refcount.c | 20 +++++++++++++-------
+file changed, 3 insertions(+)
 files changed, 19 insertions(+), 7 deletions(-)
-diff --git a/block/qcow2.h b/block/qcow2.h
+diff --git a/block/nfs.c b/block/nfs.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/qcow2.h
+--- a/block/nfs.c
-+++ b/block/qcow2.h
++++ b/block/nfs.c
-@@ -XXX,XX +XXX,XX @@
+@@ -XXX,XX +XXX,XX @@ static int nfs_file_open(BlockDriverState *bs, QDict *options, int flags,
  #define QCOW_MAX_CRYPT_CLUSTERS 32
  #define QCOW_MAX_SNAPSHOTS 65536
 +/* Field widths in qcow2 mean normal cluster offsets cannot reach
 + * 64PB; depending on cluster size, compressed clusters can have a
 + * smaller limit (64PB for up to 16k clusters, then ramps down to
 + * 512TB for 2M clusters).  */
 +#define QCOW_MAX_CLUSTER_OFFSET ((1ULL << 56) - 1)
 +
  /* 8 MB refcount table is enough for 2 PB images at 64k cluster size
   * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */
  #define QCOW_MAX_REFTABLE_SIZE S_8MiB
 diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2-refcount.c
 +++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@
  #include "qemu/bswap.h"
  #include "qemu/cutils.h"
 -static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size);
 +static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size,
 +                                    uint64_t max);
  static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
                              int64_t offset, int64_t length, uint64_t addend,
                              bool decrease, enum qcow2_discard_type type);
@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
      }
-     /* Allocate the refcount block itself and mark it as used */
+     bs->total_sectors = ret;
--    int64_t new_block = alloc_clusters_noref(bs, s->cluster_size);
++    if (client->has_zero_init) {
-+    int64_t new_block = alloc_clusters_noref(bs, s->cluster_size, INT64_MAX);
++        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
-     if (new_block < 0) {
++    }
-         return new_block;
+     return 0;
-     }
+ }
-@@ -XXX,XX +XXX,XX @@ int qcow2_update_cluster_refcount(BlockDriverState *bs,
  /* return < 0 if error */
 -static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size)
 +static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size,
 +                                    uint64_t max)
  {
      BDRVQcow2State *s = bs->opaque;
      uint64_t i, nb_clusters, refcount;
@@ -XXX,XX +XXX,XX @@ retry:
      }
      /* Make sure that all offsets in the "allocated" range are representable
 -     * in an int64_t */
 +     * in the requested max */
      if (s->free_cluster_index > 0 &&
 -        s->free_cluster_index - 1 > (INT64_MAX >> s->cluster_bits))
 +        s->free_cluster_index - 1 > (max >> s->cluster_bits))
      {
          return -EFBIG;
      }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size)
      BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
      do {
 -        offset = alloc_clusters_noref(bs, size);
 +        offset = alloc_clusters_noref(bs, size, QCOW_MAX_CLUSTER_OFFSET);
          if (offset < 0) {
              return offset;
          }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)
      free_in_cluster = s->cluster_size - offset_into_cluster(s, offset);
      do {
          if (!offset || free_in_cluster < size) {
 -            int64_t new_cluster = alloc_clusters_noref(bs, s->cluster_size);
 +            int64_t new_cluster;
 +
 +            new_cluster = alloc_clusters_noref(bs, s->cluster_size,
 +                                               MIN(s->cluster_offset_mask,
 +                                                   QCOW_MAX_CLUSTER_OFFSET));
              if (new_cluster < 0) {
                  return new_cluster;
              }
 --
-.19.1
+.25.3

-[Qemu-devel] [PULL 3/9] vvfat: Fix memory leak
+[PULL 25/30] rbd: Support BDRV_REQ_ZERO_WRITE for truncate
-Don't leak 'cluster' in the mapping == NULL case. Found by Coverity
+From: Eric Blake <eblake@redhat.com>
 (CID 1055918).
-Fixes: 8d9401c2791ee2d2805b741b1ee3006041edcd3e
+Our .bdrv_has_zero_init_truncate always returns 1 because rbd always
 -fills; we can use that same knowledge to implement
 BDRV_REQ_ZERO_WRITE by ignoring it.
 Signed-off-by: Eric Blake <eblake@redhat.com>
 Message-Id: <20200428202905.770727-5-eblake@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
-Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
-Reviewed-by: Liam Merwick <liam.merwick@oracle.com>
-Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
 ---
- block/vvfat.c | 6 +++---
+ block/rbd.c | 3 +++
-file changed, 3 insertions(+), 3 deletions(-)
+file changed, 3 insertions(+)
-diff --git a/block/vvfat.c b/block/vvfat.c
+diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
---- a/block/vvfat.c
+--- a/block/rbd.c
-+++ b/block/vvfat.c
++++ b/block/rbd.c
-@@ -XXX,XX +XXX,XX @@ static int commit_one_file(BDRVVVFATState* s,
+@@ -XXX,XX +XXX,XX @@ static int qemu_rbd_open(BlockDriverState *bs, QDict *options, int flags,
      uint32_t first_cluster = c;
      mapping_t* mapping = find_mapping_for_cluster(s, c);
      uint32_t size = filesize_of_direntry(direntry);
 -    char* cluster = g_malloc(s->cluster_size);
 +    char *cluster;
      uint32_t i;
      int fd = 0;
@@ -XXX,XX +XXX,XX @@ static int commit_one_file(BDRVVVFATState* s,
      if (fd < 0) {
          fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
                  strerror(errno), errno);
 -        g_free(cluster);
          return fd;
      }
      if (offset > 0) {
          if (lseek(fd, offset, SEEK_SET) != offset) {
              qemu_close(fd);
 -            g_free(cluster);
              return -3;
          }
      }
-+    cluster = g_malloc(s->cluster_size);
++    /* When extending regular files, we get zeros from the OS */
 +    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
 +
-     while (offset < size) {
+     r = 0;
-         uint32_t c1;
+     goto out;
-         int rest_size = (size - offset > s->cluster_size ?
 --
-.19.1
+.25.3

-New patch
+[PULL 26/30] sheepdog: Support BDRV_REQ_ZERO_WRITE for truncate
+From: Eric Blake <eblake@redhat.com>
+Our .bdrv_has_zero_init_truncate always returns 1 because sheepdog
+always 0-fills; we can use that same knowledge to implement
+BDRV_REQ_ZERO_WRITE by ignoring it.
+Signed-off-by: Eric Blake <eblake@redhat.com>
+Message-Id: <20200428202905.770727-6-eblake@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/sheepdog.c | 1 +
+file changed, 1 insertion(+)
+diff --git a/block/sheepdog.c b/block/sheepdog.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/sheepdog.c
++++ b/block/sheepdog.c
+@@ -XXX,XX +XXX,XX @@ static int sd_open(BlockDriverState *bs, QDict *options, int flags,
+     memcpy(&s->inode, buf, sizeof(s->inode));
+     bs->total_sectors = s->inode.vdi_size / BDRV_SECTOR_SIZE;
++    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
+     pstrcpy(s->name, sizeof(s->name), vdi);
+     qemu_co_mutex_init(&s->lock);
+     qemu_co_mutex_init(&s->queue_lock);
+--
+.25.3

-New patch
+[PULL 27/30] ssh: Support BDRV_REQ_ZERO_WRITE for truncate
+From: Eric Blake <eblake@redhat.com>
+Our .bdrv_has_zero_init_truncate can detect when the remote side
+always zero fills; we can reuse that same knowledge to implement
+BDRV_REQ_ZERO_WRITE by ignoring it when the server gives it to us for
+free.
+Signed-off-by: Eric Blake <eblake@redhat.com>
+Message-Id: <20200428202905.770727-7-eblake@redhat.com>
+Reviewed-by: Richard W.M. Jones <rjones@redhat.com>
+Signed-off-by: Kevin Wolf <kwolf@redhat.com>
+---
+ block/ssh.c | 4 ++++
+file changed, 4 insertions(+)
+diff --git a/block/ssh.c b/block/ssh.c
+index XXXXXXX..XXXXXXX 100644
+--- a/block/ssh.c
++++ b/block/ssh.c
+@@ -XXX,XX +XXX,XX @@ static int ssh_file_open(BlockDriverState *bs, QDict *options, int bdrv_flags,
+     /* Go non-blocking. */
+     ssh_set_blocking(s->session, 0);
++    if (s->attrs->type == SSH_FILEXFER_TYPE_REGULAR) {
++        bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
++    }
++
+     qapi_free_BlockdevOptionsSsh(opts);
+     return 0;
+--
+.25.3

-[Qemu-devel] [PULL 4/9] qcow2: Document some maximum size constraints
+[PULL 28/30] parallels: Rework truncation logic
 From: Eric Blake <eblake@redhat.com>
-Although off_t permits up to 63 bits (8EB) of file offsets, in
+The parallels driver tries to use truncation for image growth, but can
-practice, we're going to hit other limits first.  Document some
+only do so when reads are guaranteed as zero.  Now that we have a way
-of those limits in the qcow2 spec (some are inherent, others are
+to request zero contents from truncation, we can defer the decision to
-implementation choices of qemu), and how choice of cluster size
+actual allocation attempts rather than up front, reducing the number
-can influence some of the limits.
+of places that still use bdrv_has_zero_init_truncate.
 While we cannot map any uncompressed virtual cluster to any
 address higher than 64 PB (56 bits) (due to the current L1/L2
 field encoding stopping at bit 55), qemu's cap of 8M for the
 refcount table can still access larger host addresses for some
 combinations of large clusters and small refcount_order.  For
 comparison, ext4 with 4k blocks caps files at 16PB.
 Another interesting limit: for compressed clusters, the L2 layout
 requires an ever-smaller maximum host offset as cluster size gets
 larger, down to a 512 TB maximum with 2M clusters.  In particular,
 note that with a cluster size of 8k or smaller, the L2 entry for
 a compressed cluster could technically point beyond the 64PB mark,
 but when you consider that with 8k clusters and refcount_order = 0,
 you cannot access beyond 512T without exceeding qemu's limit of an
 M cap on the refcount table, it is unlikely that any image in the
 wild has attempted to do so.  To be safe, let's document that bits
 beyond 55 in a compressed cluster must be 0.
 Signed-off-by: Eric Blake <eblake@redhat.com>
+Message-Id: <20200428202905.770727-8-eblake@redhat.com>
+Reviewed-by: Denis V. Lunev <den@openvz.org>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- docs/interop/qcow2.txt | 38 ++++++++++++++++++++++++++++++++++++--
+ block/parallels.c | 25 ++++++++++++++++---------
-file changed, 36 insertions(+), 2 deletions(-)
+file changed, 16 insertions(+), 9 deletions(-)
-diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
+diff --git a/block/parallels.c b/block/parallels.c
 index XXXXXXX..XXXXXXX 100644
---- a/docs/interop/qcow2.txt
+--- a/block/parallels.c
-+++ b/docs/interop/qcow2.txt
++++ b/block/parallels.c
-@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
+@@ -XXX,XX +XXX,XX @@ static int64_t block_status(BDRVParallelsState *s, int64_t sector_num,
-                     with larger cluster sizes.
+ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
+                                  int nb_sectors, int *pnum)
-- 31:   size
+ {
--                    Virtual disk size in bytes
+-    int ret;
-+                    Virtual disk size in bytes.
++    int ret = 0;
-+
+     BDRVParallelsState *s = bs->opaque;
-+                    Note: qemu has an implementation limit of 32 MB as
+     int64_t pos, space, idx, to_allocate, i, len;
-+                    the maximum L1 table size.  With a 2 MB cluster
-+                    size, it is unable to populate a virtual cluster
+@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
-+                    beyond 2 EB (61 bits); with a 512 byte cluster
+     }
-+                    size, it is unable to populate a virtual size
+     if (s->data_end + space > (len >> BDRV_SECTOR_BITS)) {
-+                    larger than 128 GB (37 bits).  Meanwhile, L1/L2
+         space += s->prealloc_size;
-+                    table layouts limit an image to no more than 64 PB
++        /*
-+                    (56 bits) of populated clusters, and an image may
++         * We require the expanded size to read back as zero. If the
-+                    hit other limits first (such as a file system's
++         * user permitted truncation, we try that; but if it fails, we
-+                    maximum size).
++         * force the safer-but-slower fallocate.
++         */
-- 35:   crypt_method
++        if (s->prealloc_mode == PRL_PREALLOC_MODE_TRUNCATE) {
-for no encryption
++            ret = bdrv_truncate(bs->file,
-@@ -XXX,XX +XXX,XX @@ in the image file.
++                                (s->data_end + space) << BDRV_SECTOR_BITS,
- It contains pointers to the second level structures which are called refcount
++                                false, PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE,
- blocks and are exactly one cluster in size.
++                                NULL);
++            if (ret == -ENOTSUP) {
-+Although a large enough refcount table can reserve clusters past 64 PB
++                s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
-+(56 bits) (assuming the underlying protocol can even be sized that
++            }
-+large), note that some qcow2 metadata such as L1/L2 tables must point
++        }
-+to clusters prior to that point.
+         if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {
-+
+             ret = bdrv_pwrite_zeroes(bs->file,
-+Note: qemu has an implementation limit of 8 MB as the maximum refcount
+                                      s->data_end << BDRV_SECTOR_BITS,
-+table size.  With a 2 MB cluster size and a default refcount_order of
+                                      space << BDRV_SECTOR_BITS, 0);
-+4, it is unable to reference host resources beyond 2 EB (61 bits); in
+-        } else {
-+the worst case, with a 512 cluster size and refcount_order of 6, it is
+-            ret = bdrv_truncate(bs->file,
-+unable to access beyond 32 GB (35 bits).
+-                                (s->data_end + space) << BDRV_SECTOR_BITS,
-+
+-                                false, PREALLOC_MODE_OFF, 0, NULL);
- Given an offset into the image file, the refcount of its cluster can be
+         }
- obtained as follows:
+         if (ret < 0) {
+             return ret;
-@@ -XXX,XX +XXX,XX @@ The L1 table has a variable size (stored in the header) and may use multiple
+@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
- clusters, however it must be contiguous in the image file. L2 tables are
+         qemu_opt_get_size_del(opts, PARALLELS_OPT_PREALLOC_SIZE, 0);
- exactly one cluster in size.
+     s->prealloc_size = MAX(s->tracks, s->prealloc_size >> BDRV_SECTOR_BITS);
+     buf = qemu_opt_get_del(opts, PARALLELS_OPT_PREALLOC_MODE);
-+The L1 and L2 tables have implications on the maximum virtual file
++    /* prealloc_mode can be downgraded later during allocate_clusters */
-+size; for a given L1 table size, a larger cluster size is required for
+     s->prealloc_mode = qapi_enum_parse(&prealloc_mode_lookup, buf,
-+the guest to have access to more space.  Furthermore, a virtual
+                                        PRL_PREALLOC_MODE_FALLOCATE,
-+cluster must currently map to a host offset below 64 PB (56 bits)
+                                        &local_err);
-+(although this limit could be relaxed by putting reserved bits into
+@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
-+use).  Additionally, as cluster size increases, the maximum host
+         goto fail_options;
-+offset for a compressed cluster is reduced (a 2M cluster size requires
+     }
-+compressed clusters to reside below 512 TB (49 bits), and this limit
-+cannot be relaxed without an incompatible layout change).
+-    if (!bdrv_has_zero_init_truncate(bs->file->bs)) {
-+
+-        s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
- Given an offset into the virtual disk, the offset into the image file can be
+-    }
- obtained as follows:
+-
+     if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_INACTIVE)) {
-@@ -XXX,XX +XXX,XX @@ Standard Cluster Descriptor:
+         s->header->inuse = cpu_to_le32(HEADER_INUSE_MAGIC);
- Compressed Clusters Descriptor (x = 62 - (cluster_bits - 8)):
+         ret = parallels_update_header(bs);
      Bit  0 - x-1:   Host cluster offset. This is usually _not_ aligned to a
 -                    cluster or sector boundary!
 +                    cluster or sector boundary!  If cluster_bits is
 +                    small enough that this field includes bits beyond
 +                    55, those upper bits must be set to 0.
           x - 61:    Number of additional 512-byte sectors used for the
                      compressed data, beyond the sector containing the offset
 --
-.19.1
+.25.3

-[Qemu-devel] [PULL 7/9] block: Always abort reopen after prepare succeeded
+[PULL 29/30] vhdx: Rework truncation logic
-From: Max Reitz <mreitz@redhat.com>
+From: Eric Blake <eblake@redhat.com>
-bdrv_reopen_multiple() does not invoke bdrv_reopen_abort() for the
+The vhdx driver uses truncation for image growth, with a special case
-element of the reopen queue for which bdrv_reopen_prepare() failed,
+for blocks that already read as zero but which are only being
-because it assumes that the prepare function will have rolled back all
+partially written.  But with a bit of rearranging, it's just as easy
-changes already.
+to defer the decision on whether truncation resulted in zeroes to the
 actual allocation attempt, reducing the number of places that still
 use bdrv_has_zero_init_truncate.
-However, bdrv_reopen_prepare() does not do this in every case: It may
+Signed-off-by: Eric Blake <eblake@redhat.com>
-notice an error after BlockDriver.bdrv_reopen_prepare() succeeded, and
+Message-Id: <20200428202905.770727-9-eblake@redhat.com>
 it will not invoke BlockDriver.bdrv_reopen_abort() then; and neither
 will bdrv_reopen_multiple(), as explained above.
 This is wrong because we must always call .bdrv_reopen_commit() or
 .bdrv_reopen_abort() after .bdrv_reopen_prepare() has succeeded.
 Otherwise, the block driver has no chance to undo what it has done in
 its implementation of .bdrv_reopen_prepare().
 To fix this, bdrv_reopen_prepare() has to call .bdrv_reopen_abort() if
 it wants to return an error after .bdrv_reopen_prepare() has succeeded.
 Signed-off-by: Max Reitz <mreitz@redhat.com>
 Reviewed-by: Alberto Garcia <berto@igalia.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block.c | 12 ++++++++++++
+ block/vhdx.c | 89 ++++++++++++++++++++++++++++++----------------------
-file changed, 12 insertions(+)
+file changed, 51 insertions(+), 38 deletions(-)
-diff --git a/block.c b/block.c
+diff --git a/block/vhdx.c b/block/vhdx.c
 index XXXXXXX..XXXXXXX 100644
---- a/block.c
+--- a/block/vhdx.c
-+++ b/block.c
++++ b/block/vhdx.c
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
+@@ -XXX,XX +XXX,XX @@ exit:
-     QDict *orig_reopen_opts;
+ /*
-     char *discard = NULL;
+  * Allocate a new payload block at the end of the file.
-     bool read_only;
+  *
-+    bool drv_prepared = false;
+- * Allocation will happen at 1MB alignment inside the file
++ * Allocation will happen at 1MB alignment inside the file.
-     assert(reopen_state != NULL);
++ *
-     assert(reopen_state->bs->drv != NULL);
++ * If @need_zero is set on entry but not cleared on return, then truncation
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
++ * could not guarantee that the new portion reads as zero, and the caller
-         goto error;
++ * will take care of it instead.
   *
   * Returns the file offset start of the new payload block
   */
  static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
 -                                    uint64_t *new_offset)
 +                               uint64_t *new_offset, bool *need_zero)
  {
      int64_t current_len;
@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
          return -EINVAL;
      }
-+    drv_prepared = true;
++    if (*need_zero) {
 +        int ret;
 +
-     /* Options that are not handled are only okay if they are unchanged
++        ret = bdrv_truncate(bs->file, *new_offset + s->block_size, false,
-      * compared to the old state. It is expected that some options are only
++                            PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE, NULL);
-      * used for the initial open, but not reopen (e.g. filename) */
++        if (ret != -ENOTSUP) {
-@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
++            *need_zero = false;
-     reopen_state->options = qobject_ref(orig_reopen_opts);
++            return ret;
  error:
 +    if (ret < 0 && drv_prepared) {
 +        /* drv->bdrv_reopen_prepare() has succeeded, so we need to
 +         * call drv->bdrv_reopen_abort() before signaling an error
 +         * (bdrv_reopen_multiple() will not call bdrv_reopen_abort()
 +         * when the respective bdrv_reopen_prepare() has failed) */
 +        if (drv->bdrv_reopen_abort) {
 +            drv->bdrv_reopen_abort(reopen_state);
 +        }
 +    }
-     qemu_opts_del(opts);
++
-     qobject_unref(orig_reopen_opts);
+     return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
-     g_free(discard);
+                          PREALLOC_MODE_OFF, 0, NULL);
  }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
                  /* in this case, we need to preserve zero writes for
                   * data that is not part of this write, so we must pad
                   * the rest of the buffer to zeroes */
 -
 -                /* if we are on a posix system with ftruncate() that extends
 -                 * a file, then it is zero-filled for us.  On Win32, the raw
 -                 * layer uses SetFilePointer and SetFileEnd, which does not
 -                 * zero fill AFAIK */
 -
 -                /* Queue another write of zero buffers if the underlying file
 -                 * does not zero-fill on file extension */
 -
 -                if (bdrv_has_zero_init_truncate(bs->file->bs) == 0) {
 -                    use_zero_buffers = true;
 -
 +                use_zero_buffers = true;
 +                /* fall through */
 +            case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */
 +            case PAYLOAD_BLOCK_UNMAPPED:
 +            case PAYLOAD_BLOCK_UNMAPPED_v095:
 +            case PAYLOAD_BLOCK_UNDEFINED:
 +                bat_prior_offset = sinfo.file_offset;
 +                ret = vhdx_allocate_block(bs, s, &sinfo.file_offset,
 +                                          &use_zero_buffers);
 +                if (ret < 0) {
 +                    goto exit;
 +                }
 +                /*
 +                 * once we support differencing files, this may also be
 +                 * partially present
 +                 */
 +                /* update block state to the newly specified state */
 +                vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
 +                                            &bat_entry_offset,
 +                                            PAYLOAD_BLOCK_FULLY_PRESENT);
 +                bat_update = true;
 +                /*
 +                 * Since we just allocated a block, file_offset is the
 +                 * beginning of the payload block. It needs to be the
 +                 * write address, which includes the offset into the
 +                 * block, unless the entire block needs to read as
 +                 * zeroes but truncation was not able to provide them,
 +                 * in which case we need to fill in the rest.
 +                 */
 +                if (!use_zero_buffers) {
 +                    sinfo.file_offset += sinfo.block_offset;
 +                } else {
                      /* zero fill the front, if any */
                      if (sinfo.block_offset) {
                          iov1.iov_len = sinfo.block_offset;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
                      }
                      /* our actual data */
 -                    qemu_iovec_concat(&hd_qiov, qiov,  bytes_done,
 +                    qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
                                        sinfo.bytes_avail);
                      /* zero fill the back, if any */
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
                          sectors_to_write += iov2.iov_len >> BDRV_SECTOR_BITS;
                      }
                  }
 -                /* fall through */
 -            case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */
 -            case PAYLOAD_BLOCK_UNMAPPED:
 -            case PAYLOAD_BLOCK_UNMAPPED_v095:
 -            case PAYLOAD_BLOCK_UNDEFINED:
 -                bat_prior_offset = sinfo.file_offset;
 -                ret = vhdx_allocate_block(bs, s, &sinfo.file_offset);
 -                if (ret < 0) {
 -                    goto exit;
 -                }
 -                /* once we support differencing files, this may also be
 -                 * partially present */
 -                /* update block state to the newly specified state */
 -                vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
 -                                            &bat_entry_offset,
 -                                            PAYLOAD_BLOCK_FULLY_PRESENT);
 -                bat_update = true;
 -                /* since we just allocated a block, file_offset is the
 -                 * beginning of the payload block. It needs to be the
 -                 * write address, which includes the offset into the block */
 -                if (!use_zero_buffers) {
 -                    sinfo.file_offset += sinfo.block_offset;
 -                }
 +
                  /* fall through */
              case PAYLOAD_BLOCK_FULLY_PRESENT:
                  /* if the file offset address is in the header zone,
 --
-.19.1
+.25.3

-[Qemu-devel] [PULL 8/9] file-posix: Fix shared locks on reopen commit
+[PULL 30/30] block: Drop unused .bdrv_has_zero_init_truncate
-From: Max Reitz <mreitz@redhat.com>
+From: Eric Blake <eblake@redhat.com>
-s->locked_shared_perm is the set of bits locked in the file, which is
+Now that there are no clients of bdrv_has_zero_init_truncate, none of
-the inverse of the permissions actually shared.  So we need to pass them
+the drivers need to worry about providing it.
-as they are to raw_apply_lock_bytes() instead of inverting them again.
+What's more, this eliminates a source of some confusion: a literal
-Reported-by: Alberto Garcia <berto@igalia.com>
+reading of the documentation as written in ceaca56f and implemented in
-Signed-off-by: Max Reitz <mreitz@redhat.com>
+commit 1dcaf527 claims that a driver which returns 0 for
-Reviewed-by: Alberto Garcia <berto@igalia.com>
+bdrv_has_zero_init_truncate() must not return 1 for
 bdrv_has_zero_init(); this condition was violated for parallels, qcow,
 and sometimes for vdi, although in practice it did not matter since
 those drivers also lacked .bdrv_co_truncate.
 Signed-off-by: Eric Blake <eblake@redhat.com>
 Message-Id: <20200428202905.770727-10-eblake@redhat.com>
 Acked-by: Richard W.M. Jones <rjones@redhat.com>
 Signed-off-by: Kevin Wolf <kwolf@redhat.com>
 ---
- block/file-posix.c | 2 +-
+ include/block/block.h     |  1 -
-file changed, 1 insertion(+), 1 deletion(-)
+ include/block/block_int.h |  7 -------
+ block.c                   | 21 ---------------------
  block/file-posix.c        |  1 -
  block/file-win32.c        |  1 -
  block/nfs.c               |  1 -
  block/qcow2.c             |  1 -
  block/qed.c               |  1 -
  block/raw-format.c        |  6 ------
  block/rbd.c               |  1 -
  block/sheepdog.c          |  3 ---
  block/ssh.c               |  1 -
 files changed, 45 deletions(-)
 diff --git a/include/block/block.h b/include/block/block.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block.h
 +++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
  int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
  int bdrv_has_zero_init_1(BlockDriverState *bs);
  int bdrv_has_zero_init(BlockDriverState *bs);
 -int bdrv_has_zero_init_truncate(BlockDriverState *bs);
  bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
  bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
  int bdrv_block_status(BlockDriverState *bs, int64_t offset,
 diff --git a/include/block/block_int.h b/include/block/block_int.h
 index XXXXXXX..XXXXXXX 100644
 --- a/include/block/block_int.h
 +++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
      /*
       * Returns 1 if newly created images are guaranteed to contain only
       * zeros, 0 otherwise.
 -     * Must return 0 if .bdrv_has_zero_init_truncate() returns 0.
       */
      int (*bdrv_has_zero_init)(BlockDriverState *bs);
 -    /*
 -     * Returns 1 if new areas added by growing the image with
 -     * PREALLOC_MODE_OFF contain only zeros, 0 otherwise.
 -     */
 -    int (*bdrv_has_zero_init_truncate)(BlockDriverState *bs);
 -
      /* Remove fd handlers, timers, and other event loop callbacks so the event
       * loop is no longer in use.  Called with no in-flight requests and in
       * depth-first traversal order with parents before child nodes.
 diff --git a/block.c b/block.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block.c
 +++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_has_zero_init(BlockDriverState *bs)
      return 0;
  }
 -int bdrv_has_zero_init_truncate(BlockDriverState *bs)
 -{
 -    if (!bs->drv) {
 -        return 0;
 -    }
 -
 -    if (bs->backing) {
 -        /* Depends on the backing image length, but better safe than sorry */
 -        return 0;
 -    }
 -    if (bs->drv->bdrv_has_zero_init_truncate) {
 -        return bs->drv->bdrv_has_zero_init_truncate(bs);
 -    }
 -    if (bs->file && bs->drv->is_filter) {
 -        return bdrv_has_zero_init_truncate(bs->file->bs);
 -    }
 -
 -    /* safe default */
 -    return 0;
 -}
 -
  bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
  {
      BlockDriverInfo bdi;
 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 @@ static void raw_reopen_commit(BDRVReopenState *state)
+@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {
+     .bdrv_co_create = raw_co_create,
-     /* Copy locks to the new fd before closing the old one. */
+     .bdrv_co_create_opts = raw_co_create_opts,
-     raw_apply_lock_bytes(NULL, rs->fd, s->locked_perm,
+     .bdrv_has_zero_init = bdrv_has_zero_init_1,
--                         ~s->locked_shared_perm, false, &local_err);
+-    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
-+                         s->locked_shared_perm, false, &local_err);
+     .bdrv_co_block_status = raw_co_block_status,
-     if (local_err) {
+     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
-         /* shouldn't fail in a sane host, but report it just in case. */
+     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
-         error_report_err(local_err);
+diff --git a/block/file-win32.c b/block/file-win32.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/file-win32.c
 +++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {
      .bdrv_close         = raw_close,
      .bdrv_co_create_opts = raw_co_create_opts,
      .bdrv_has_zero_init = bdrv_has_zero_init_1,
 -    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
      .bdrv_aio_preadv    = raw_aio_preadv,
      .bdrv_aio_pwritev   = raw_aio_pwritev,
 diff --git a/block/nfs.c b/block/nfs.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/nfs.c
 +++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nfs = {
      .create_opts                    = &nfs_create_opts,
      .bdrv_has_zero_init             = nfs_has_zero_init,
 -    .bdrv_has_zero_init_truncate    = nfs_has_zero_init,
      .bdrv_get_allocated_file_size   = nfs_get_allocated_file_size,
      .bdrv_co_truncate               = nfs_file_co_truncate,
 diff --git a/block/qcow2.c b/block/qcow2.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qcow2.c
 +++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
      .bdrv_co_create_opts  = qcow2_co_create_opts,
      .bdrv_co_create       = qcow2_co_create,
      .bdrv_has_zero_init   = qcow2_has_zero_init,
 -    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
      .bdrv_co_block_status = qcow2_co_block_status,
      .bdrv_co_preadv_part    = qcow2_co_preadv_part,
 diff --git a/block/qed.c b/block/qed.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/qed.c
 +++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qed = {
      .bdrv_co_create           = bdrv_qed_co_create,
      .bdrv_co_create_opts      = bdrv_qed_co_create_opts,
      .bdrv_has_zero_init       = bdrv_has_zero_init_1,
 -    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
      .bdrv_co_block_status     = bdrv_qed_co_block_status,
      .bdrv_co_readv            = bdrv_qed_co_readv,
      .bdrv_co_writev           = bdrv_qed_co_writev,
 diff --git a/block/raw-format.c b/block/raw-format.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/raw-format.c
 +++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int raw_has_zero_init(BlockDriverState *bs)
      return bdrv_has_zero_init(bs->file->bs);
  }
 -static int raw_has_zero_init_truncate(BlockDriverState *bs)
 -{
 -    return bdrv_has_zero_init_truncate(bs->file->bs);
 -}
 -
  static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
                                             const char *filename,
                                             QemuOpts *opts,
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
      .bdrv_co_ioctl        = &raw_co_ioctl,
      .create_opts          = &raw_create_opts,
      .bdrv_has_zero_init   = &raw_has_zero_init,
 -    .bdrv_has_zero_init_truncate = &raw_has_zero_init_truncate,
      .strong_runtime_opts  = raw_strong_runtime_opts,
      .mutable_opts         = mutable_opts,
  };
 diff --git a/block/rbd.c b/block/rbd.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/rbd.c
 +++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {
      .bdrv_co_create         = qemu_rbd_co_create,
      .bdrv_co_create_opts    = qemu_rbd_co_create_opts,
      .bdrv_has_zero_init     = bdrv_has_zero_init_1,
 -    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
      .bdrv_get_info          = qemu_rbd_getinfo,
      .create_opts            = &qemu_rbd_create_opts,
      .bdrv_getlength         = qemu_rbd_getlength,
 diff --git a/block/sheepdog.c b/block/sheepdog.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/sheepdog.c
 +++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog = {
      .bdrv_co_create               = sd_co_create,
      .bdrv_co_create_opts          = sd_co_create_opts,
      .bdrv_has_zero_init           = bdrv_has_zero_init_1,
 -    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
      .bdrv_getlength               = sd_getlength,
      .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
      .bdrv_co_truncate             = sd_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog_tcp = {
      .bdrv_co_create               = sd_co_create,
      .bdrv_co_create_opts          = sd_co_create_opts,
      .bdrv_has_zero_init           = bdrv_has_zero_init_1,
 -    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
      .bdrv_getlength               = sd_getlength,
      .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
      .bdrv_co_truncate             = sd_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog_unix = {
      .bdrv_co_create               = sd_co_create,
      .bdrv_co_create_opts          = sd_co_create_opts,
      .bdrv_has_zero_init           = bdrv_has_zero_init_1,
 -    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
      .bdrv_getlength               = sd_getlength,
      .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
      .bdrv_co_truncate             = sd_co_truncate,
 diff --git a/block/ssh.c b/block/ssh.c
 index XXXXXXX..XXXXXXX 100644
 --- a/block/ssh.c
 +++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_ssh = {
      .bdrv_co_create_opts          = ssh_co_create_opts,
      .bdrv_close                   = ssh_close,
      .bdrv_has_zero_init           = ssh_has_zero_init,
 -    .bdrv_has_zero_init_truncate  = ssh_has_zero_init,
      .bdrv_co_readv                = ssh_co_readv,
      .bdrv_co_writev               = ssh_co_writev,
      .bdrv_getlength               = ssh_getlength,
 --
-.19.1
+.25.3

The following changes since commit 9436e082de18b2fb2ceed2e9d1beef641ae64f23:

MAINTAINERS: clarify some of the tags (2018-11-19 11:19:23 +0000)

are available in the Git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to 6d0a4a0fb5c8f10c8eb68b52cfda0082b00ae963:

iotests: Test file-posix locking and reopen (2018-11-19 14:32:04 +0100)

----------------------------------------------------------------
Block layer patches:

- file-posix: Fix shared permission locks after reopen
- block: Fix error path for failed .bdrv_reopen_prepare
- qcow2: Catch invalid allocations when the image becomes too large
- vvfat/fdc/nvme: Fix segfaults and leaks

----------------------------------------------------------------
Eric Blake (3):
      qcow2: Document some maximum size constraints
      qcow2: Don't allow overflow during cluster allocation
      iotests: Add new test 220 for max compressed cluster offset

Kevin Wolf (1):
      vvfat: Fix memory leak

Li Qiang (1):
      nvme: fix oob access issue(CVE-2018-16847)

Mark Cave-Ayland (1):
      fdc: fix segfault in fdctrl_stop_transfer() when DMA is disabled

Max Reitz (3):
      block: Always abort reopen after prepare succeeded
      file-posix: Fix shared locks on reopen commit
      iotests: Test file-posix locking and reopen

docs/interop/qcow2.txt     | 38 +++++++++++++++++-
 block/qcow2.h              |  6 +++
 block.c                    | 12 ++++++
 block/file-posix.c         |  2 +-
 block/qcow2-refcount.c     | 20 ++++++----
 block/vvfat.c              |  6 +--
 hw/block/fdc.c             |  2 +-
 hw/block/nvme.c            |  7 ++++
 tests/qemu-iotests/182     | 71 ++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/182.out |  9 +++++
 tests/qemu-iotests/220     | 96 ++++++++++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/220.out | 54 ++++++++++++++++++++++++++
 tests/qemu-iotests/group   |  1 +
 13 files changed, 310 insertions(+), 14 deletions(-)
 create mode 100755 tests/qemu-iotests/220
 create mode 100644 tests/qemu-iotests/220.out

From: Li Qiang <liq3ea@gmail.com>

Currently, the nvme_cmb_ops mr doesn't check the addr and size.
This can lead an oob access issue. This is triggerable in the guest.
Add check to avoid this issue.

Fixes CVE-2018-16847.

Reported-by: Li Qiang <liq3ea@gmail.com>
Reviewed-by: Paolo Bonzini <pbonzini@redhat.com>
Signed-off-by: Li Qiang <liq3ea@gmail.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/nvme.c | 7 +++++++
 1 file changed, 7 insertions(+)

diff --git a/hw/block/nvme.c b/hw/block/nvme.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/nvme.c
+++ b/hw/block/nvme.c
@@ -XXX,XX +XXX,XX @@ static void nvme_cmb_write(void *opaque, hwaddr addr, uint64_t data,
     unsigned size)
 {
     NvmeCtrl *n = (NvmeCtrl *)opaque;
+
+    if (addr + size > NVME_CMBSZ_GETSIZE(n->bar.cmbsz)) {
+        return;
+    }
     memcpy(&n->cmbuf[addr], &data, size);
 }
 
@@ -XXX,XX +XXX,XX @@ static uint64_t nvme_cmb_read(void *opaque, hwaddr addr, unsigned size)
     uint64_t val;
     NvmeCtrl *n = (NvmeCtrl *)opaque;
 
+    if (addr + size > NVME_CMBSZ_GETSIZE(n->bar.cmbsz)) {
+        return 0;
+    }
     memcpy(&val, &n->cmbuf[addr], size);
     return val;
 }
-- 
2.19.1

From: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>

Commit c8a35f1cf0f "fdc: use IsaDma interface instead of global DMA_*
functions" accidentally introduced a segfault in fdctrl_stop_transfer() for
non-DMA transfers.

If fdctrl->dma_chann has not been configured then the fdctrl->dma interface
reference isn't initialised during isabus_fdc_realize(). Unfortunately
fdctrl_stop_transfer() unconditionally references the DMA interface when
finishing the transfer causing a NULL pointer dereference.

Fix the issue by adding a check in fdctrl_stop_transfer() so that the DMA
interface reference and release method is only invoked if fdctrl->dma_chann
has been set.

(This issue was discovered by Martin testing a recent change in the NetBSD
installer under qemu-system-sparc)

Cc: qemu-stable@nongnu.org
Reported-by: Martin Husemann <martin@duskware.de>
Signed-off-by: Mark Cave-Ayland <mark.cave-ayland@ilande.co.uk>
Reviewed-by: Philippe Mathieu-Daudé <f4bug@amsat.org>
Reviewed-by: Hervé Poussineau <hpoussin@reactos.org>
Reviewed-by: John Snow <jsnow@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 hw/block/fdc.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/hw/block/fdc.c b/hw/block/fdc.c
index XXXXXXX..XXXXXXX 100644
--- a/hw/block/fdc.c
+++ b/hw/block/fdc.c
@@ -XXX,XX +XXX,XX @@ static void fdctrl_stop_transfer(FDCtrl *fdctrl, uint8_t status0,
     fdctrl->fifo[5] = cur_drv->sect;
     fdctrl->fifo[6] = FD_SECTOR_SC;
     fdctrl->data_dir = FD_DIR_READ;
-    if (!(fdctrl->msr & FD_MSR_NONDMA)) {
+    if (fdctrl->dma_chann != -1 && !(fdctrl->msr & FD_MSR_NONDMA)) {
         IsaDmaClass *k = ISADMA_GET_CLASS(fdctrl->dma);
         k->release_DREQ(fdctrl->dma, fdctrl->dma_chann);
     }
-- 
2.19.1

Don't leak 'cluster' in the mapping == NULL case. Found by Coverity
(CID 1055918).

Fixes: 8d9401c2791ee2d2805b741b1ee3006041edcd3e
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Philippe Mathieu-Daudé <philmd@redhat.com>
Reviewed-by: Liam Merwick <liam.merwick@oracle.com>
Tested-by: Philippe Mathieu-Daudé <philmd@redhat.com>
---
 block/vvfat.c | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/block/vvfat.c b/block/vvfat.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vvfat.c
+++ b/block/vvfat.c
@@ -XXX,XX +XXX,XX @@ static int commit_one_file(BDRVVVFATState* s,
     uint32_t first_cluster = c;
     mapping_t* mapping = find_mapping_for_cluster(s, c);
     uint32_t size = filesize_of_direntry(direntry);
-    char* cluster = g_malloc(s->cluster_size);
+    char *cluster;
     uint32_t i;
     int fd = 0;
 
@@ -XXX,XX +XXX,XX @@ static int commit_one_file(BDRVVVFATState* s,
     if (fd < 0) {
         fprintf(stderr, "Could not open %s... (%s, %d)\n", mapping->path,
                 strerror(errno), errno);
-        g_free(cluster);
         return fd;
     }
     if (offset > 0) {
         if (lseek(fd, offset, SEEK_SET) != offset) {
             qemu_close(fd);
-            g_free(cluster);
             return -3;
         }
     }
 
+    cluster = g_malloc(s->cluster_size);
+
     while (offset < size) {
         uint32_t c1;
         int rest_size = (size - offset > s->cluster_size ?
-- 
2.19.1

From: Eric Blake <eblake@redhat.com>

Although off_t permits up to 63 bits (8EB) of file offsets, in
practice, we're going to hit other limits first.  Document some
of those limits in the qcow2 spec (some are inherent, others are
implementation choices of qemu), and how choice of cluster size
can influence some of the limits.

While we cannot map any uncompressed virtual cluster to any
address higher than 64 PB (56 bits) (due to the current L1/L2
field encoding stopping at bit 55), qemu's cap of 8M for the
refcount table can still access larger host addresses for some
combinations of large clusters and small refcount_order.  For
comparison, ext4 with 4k blocks caps files at 16PB.

Another interesting limit: for compressed clusters, the L2 layout
requires an ever-smaller maximum host offset as cluster size gets
larger, down to a 512 TB maximum with 2M clusters.  In particular,
note that with a cluster size of 8k or smaller, the L2 entry for
a compressed cluster could technically point beyond the 64PB mark,
but when you consider that with 8k clusters and refcount_order = 0,
you cannot access beyond 512T without exceeding qemu's limit of an
8M cap on the refcount table, it is unlikely that any image in the
wild has attempted to do so.  To be safe, let's document that bits
beyond 55 in a compressed cluster must be 0.

Signed-off-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 docs/interop/qcow2.txt | 38 ++++++++++++++++++++++++++++++++++++--
 1 file changed, 36 insertions(+), 2 deletions(-)

diff --git a/docs/interop/qcow2.txt b/docs/interop/qcow2.txt
index XXXXXXX..XXXXXXX 100644
--- a/docs/interop/qcow2.txt
+++ b/docs/interop/qcow2.txt
@@ -XXX,XX +XXX,XX @@ The first cluster of a qcow2 image contains the file header:
                     with larger cluster sizes.
 
          24 - 31:   size
-                    Virtual disk size in bytes
+                    Virtual disk size in bytes.
+
+                    Note: qemu has an implementation limit of 32 MB as
+                    the maximum L1 table size.  With a 2 MB cluster
+                    size, it is unable to populate a virtual cluster
+                    beyond 2 EB (61 bits); with a 512 byte cluster
+                    size, it is unable to populate a virtual size
+                    larger than 128 GB (37 bits).  Meanwhile, L1/L2
+                    table layouts limit an image to no more than 64 PB
+                    (56 bits) of populated clusters, and an image may
+                    hit other limits first (such as a file system's
+                    maximum size).
 
          32 - 35:   crypt_method
                     0 for no encryption
@@ -XXX,XX +XXX,XX @@ in the image file.
 It contains pointers to the second level structures which are called refcount
 blocks and are exactly one cluster in size.
 
+Although a large enough refcount table can reserve clusters past 64 PB
+(56 bits) (assuming the underlying protocol can even be sized that
+large), note that some qcow2 metadata such as L1/L2 tables must point
+to clusters prior to that point.
+
+Note: qemu has an implementation limit of 8 MB as the maximum refcount
+table size.  With a 2 MB cluster size and a default refcount_order of
+4, it is unable to reference host resources beyond 2 EB (61 bits); in
+the worst case, with a 512 cluster size and refcount_order of 6, it is
+unable to access beyond 32 GB (35 bits).
+
 Given an offset into the image file, the refcount of its cluster can be
 obtained as follows:
 
@@ -XXX,XX +XXX,XX @@ The L1 table has a variable size (stored in the header) and may use multiple
 clusters, however it must be contiguous in the image file. L2 tables are
 exactly one cluster in size.
 
+The L1 and L2 tables have implications on the maximum virtual file
+size; for a given L1 table size, a larger cluster size is required for
+the guest to have access to more space.  Furthermore, a virtual
+cluster must currently map to a host offset below 64 PB (56 bits)
+(although this limit could be relaxed by putting reserved bits into
+use).  Additionally, as cluster size increases, the maximum host
+offset for a compressed cluster is reduced (a 2M cluster size requires
+compressed clusters to reside below 512 TB (49 bits), and this limit
+cannot be relaxed without an incompatible layout change).
+
 Given an offset into the virtual disk, the offset into the image file can be
 obtained as follows:
 
@@ -XXX,XX +XXX,XX @@ Standard Cluster Descriptor:
 Compressed Clusters Descriptor (x = 62 - (cluster_bits - 8)):
 
     Bit  0 - x-1:   Host cluster offset. This is usually _not_ aligned to a
-                    cluster or sector boundary!
+                    cluster or sector boundary!  If cluster_bits is
+                    small enough that this field includes bits beyond
+                    55, those upper bits must be set to 0.
 
          x - 61:    Number of additional 512-byte sectors used for the
                     compressed data, beyond the sector containing the offset
-- 
2.19.1

From: Eric Blake <eblake@redhat.com>

Our code was already checking that we did not attempt to
allocate more clusters than what would fit in an INT64 (the
physical maximimum if we can access a full off_t's worth of
data).  But this does not catch smaller limits enforced by
various spots in the qcow2 image description: L1 and normal
clusters of L2 are documented as having bits 63-56 reserved
for other purposes, capping our maximum offset at 64PB (bit
55 is the maximum bit set).  And for compressed images with
2M clusters, the cap drops the maximum offset to bit 48, or
a maximum offset of 512TB.  If we overflow that offset, we
would write compressed data into one place, but try to
decompress from another, which won't work.

It's actually possible to prove that overflow can cause image
corruption without this patch; I'll add the iotests separately
in the next commit.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.h          |  6 ++++++
 block/qcow2-refcount.c | 20 +++++++++++++-------
 2 files changed, 19 insertions(+), 7 deletions(-)

diff --git a/block/qcow2.h b/block/qcow2.h
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.h
+++ b/block/qcow2.h
@@ -XXX,XX +XXX,XX @@
 #define QCOW_MAX_CRYPT_CLUSTERS 32
 #define QCOW_MAX_SNAPSHOTS 65536
 
+/* Field widths in qcow2 mean normal cluster offsets cannot reach
+ * 64PB; depending on cluster size, compressed clusters can have a
+ * smaller limit (64PB for up to 16k clusters, then ramps down to
+ * 512TB for 2M clusters).  */
+#define QCOW_MAX_CLUSTER_OFFSET ((1ULL << 56) - 1)
+
 /* 8 MB refcount table is enough for 2 PB images at 64k cluster size
  * (128 GB for 512 byte clusters, 2 EB for 2 MB clusters) */
 #define QCOW_MAX_REFTABLE_SIZE S_8MiB
diff --git a/block/qcow2-refcount.c b/block/qcow2-refcount.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2-refcount.c
+++ b/block/qcow2-refcount.c
@@ -XXX,XX +XXX,XX @@
 #include "qemu/bswap.h"
 #include "qemu/cutils.h"
 
-static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size);
+static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size,
+                                    uint64_t max);
 static int QEMU_WARN_UNUSED_RESULT update_refcount(BlockDriverState *bs,
                             int64_t offset, int64_t length, uint64_t addend,
                             bool decrease, enum qcow2_discard_type type);
@@ -XXX,XX +XXX,XX @@ static int alloc_refcount_block(BlockDriverState *bs,
     }
 
     /* Allocate the refcount block itself and mark it as used */
-    int64_t new_block = alloc_clusters_noref(bs, s->cluster_size);
+    int64_t new_block = alloc_clusters_noref(bs, s->cluster_size, INT64_MAX);
     if (new_block < 0) {
         return new_block;
     }
@@ -XXX,XX +XXX,XX @@ int qcow2_update_cluster_refcount(BlockDriverState *bs,
 
 
 /* return < 0 if error */
-static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size)
+static int64_t alloc_clusters_noref(BlockDriverState *bs, uint64_t size,
+                                    uint64_t max)
 {
     BDRVQcow2State *s = bs->opaque;
     uint64_t i, nb_clusters, refcount;
@@ -XXX,XX +XXX,XX @@ retry:
     }
 
     /* Make sure that all offsets in the "allocated" range are representable
-     * in an int64_t */
+     * in the requested max */
     if (s->free_cluster_index > 0 &&
-        s->free_cluster_index - 1 > (INT64_MAX >> s->cluster_bits))
+        s->free_cluster_index - 1 > (max >> s->cluster_bits))
     {
         return -EFBIG;
     }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_alloc_clusters(BlockDriverState *bs, uint64_t size)
 
     BLKDBG_EVENT(bs->file, BLKDBG_CLUSTER_ALLOC);
     do {
-        offset = alloc_clusters_noref(bs, size);
+        offset = alloc_clusters_noref(bs, size, QCOW_MAX_CLUSTER_OFFSET);
         if (offset < 0) {
             return offset;
         }
@@ -XXX,XX +XXX,XX @@ int64_t qcow2_alloc_bytes(BlockDriverState *bs, int size)
     free_in_cluster = s->cluster_size - offset_into_cluster(s, offset);
     do {
         if (!offset || free_in_cluster < size) {
-            int64_t new_cluster = alloc_clusters_noref(bs, s->cluster_size);
+            int64_t new_cluster;
+
+            new_cluster = alloc_clusters_noref(bs, s->cluster_size,
+                                               MIN(s->cluster_offset_mask,
+                                                   QCOW_MAX_CLUSTER_OFFSET));
             if (new_cluster < 0) {
                 return new_cluster;
             }
-- 
2.19.1

From: Eric Blake <eblake@redhat.com>

If you have a capable file system (tmpfs is good, ext4 not so much;
run ./check with TEST_DIR pointing to a good location so as not
to skip the test), it's actually possible to create a qcow2 file
that expands to a sparse 512T image with just over 38M of content.
The test is not the world's fastest (qemu crawling through 256M
bits of refcount table to find the next cluster to allocate takes
several seconds, as does qemu-img check reporting millions of
leaked clusters); but it DOES catch the problem that the previous
patch just fixed where writing a compressed cluster to a full
image ended up overwriting the wrong cluster.

Suggested-by: Max Reitz <mreitz@redhat.com>
Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/220     | 96 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/220.out | 54 +++++++++++++++++++++
 tests/qemu-iotests/group   |  1 +
 3 files changed, 151 insertions(+)
 create mode 100755 tests/qemu-iotests/220
 create mode 100644 tests/qemu-iotests/220.out

diff --git a/tests/qemu-iotests/220 b/tests/qemu-iotests/220
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/220
@@ -XXX,XX +XXX,XX @@
+#!/bin/bash
+#
+# max limits on compression in huge qcow2 files
+#
+# Copyright (C) 2018 Red Hat, Inc.
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+seq=$(basename $0)
+echo "QA output created by $seq"
+
+status=1    # failure is the default!
+
+_cleanup()
+{
+    _cleanup_test_img
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+. ./common.pattern
+
+_supported_fmt qcow2
+_supported_proto file
+_supported_os Linux
+
+echo "== Creating huge file =="
+
+# Sanity check: We require a file system that permits the creation
+# of a HUGE (but very sparse) file.  tmpfs works, ext4 does not.
+if ! truncate --size=513T "$TEST_IMG"; then
+    _notrun "file system on $TEST_DIR does not support large enough files"
+fi
+rm "$TEST_IMG"
+IMGOPTS='cluster_size=2M,refcount_bits=1' _make_test_img 513T
+
+echo "== Populating refcounts =="
+# We want an image with 256M refcounts * 2M clusters = 512T referenced.
+# Each 2M cluster holds 16M refcounts; the refcount table initially uses
+# 1 refblock, so we need to add 15 more.  The refcount table lives at 2M,
+# first refblock at 4M, L2 at 6M, so our remaining additions start at 8M.
+# Then, for each refblock, mark it as fully populated.
+to_hex() {
+    printf %016x\\n $1 | sed 's/$..$/\\x\1/g'
+}
+truncate --size=38m "$TEST_IMG"
+entry=$((0x200000))
+$QEMU_IO_PROG -f raw -c "w -P 0xff 4m 2m" "$TEST_IMG" | _filter_qemu_io
+for i in {1..15}; do
+    offs=$((0x600000 + i*0x200000))
+    poke_file "$TEST_IMG" $((i*8 + entry)) $(to_hex $offs)
+    $QEMU_IO_PROG -f raw -c "w -P 0xff $offs 2m" "$TEST_IMG" | _filter_qemu_io
+done
+
+echo "== Checking file before =="
+# FIXME: 'qemu-img check' doesn't diagnose refcounts beyond the end of
+# the file as leaked clusters
+_check_test_img 2>&1 | sed '/^Leaked cluster/d'
+stat -c 'image size %s' "$TEST_IMG"
+
+echo "== Trying to write compressed cluster =="
+# Given our file size, the next available cluster at 512T lies beyond the
+# maximum offset that a compressed 2M cluster can reside in
+$QEMU_IO_PROG -c 'w -c 0 2m' "$TEST_IMG" | _filter_qemu_io
+# The attempt failed, but ended up allocating a new refblock
+stat -c 'image size %s' "$TEST_IMG"
+
+echo "== Writing normal cluster =="
+# The failed write should not corrupt the image, so a normal write succeeds
+$QEMU_IO_PROG -c 'w 0 2m' "$TEST_IMG" | _filter_qemu_io
+
+echo "== Checking file after =="
+# qemu-img now sees the millions of leaked clusters, thanks to the allocations
+# at 512T.  Undo many of our faked references to speed up the check.
+$QEMU_IO_PROG -f raw -c "w -z 5m 1m" -c "w -z 8m 30m" "$TEST_IMG" |
+    _filter_qemu_io
+_check_test_img 2>&1 | sed '/^Leaked cluster/d'
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/220.out b/tests/qemu-iotests/220.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/220.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 220
+== Creating huge file ==
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=564049465049088
+== Populating refcounts ==
+wrote 2097152/2097152 bytes at offset 4194304
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 8388608
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 10485760
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 12582912
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 14680064
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 16777216
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 18874368
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 20971520
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 23068672
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 25165824
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 27262976
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 29360128
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 31457280
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 33554432
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 35651584
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 2097152/2097152 bytes at offset 37748736
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+== Checking file before ==
+No errors were found on the image.
+image size 39845888
+== Trying to write compressed cluster ==
+write failed: Input/output error
+image size 562949957615616
+== Writing normal cluster ==
+wrote 2097152/2097152 bytes at offset 0
+2 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+== Checking file after ==
+wrote 1048576/1048576 bytes at offset 5242880
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+wrote 31457280/31457280 bytes at offset 8388608
+30 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+
+8388589 leaked clusters were found on the image.
+This means waste of disk space, but no harm to data.
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 217 rw auto quick
 218 rw auto quick
 219 rw auto
+220 rw auto
 221 rw auto quick
 222 rw auto quick
 223 rw auto quick
-- 
2.19.1

From: Max Reitz <mreitz@redhat.com>

bdrv_reopen_multiple() does not invoke bdrv_reopen_abort() for the
element of the reopen queue for which bdrv_reopen_prepare() failed,
because it assumes that the prepare function will have rolled back all
changes already.

However, bdrv_reopen_prepare() does not do this in every case: It may
notice an error after BlockDriver.bdrv_reopen_prepare() succeeded, and
it will not invoke BlockDriver.bdrv_reopen_abort() then; and neither
will bdrv_reopen_multiple(), as explained above.

This is wrong because we must always call .bdrv_reopen_commit() or
.bdrv_reopen_abort() after .bdrv_reopen_prepare() has succeeded.
Otherwise, the block driver has no chance to undo what it has done in
its implementation of .bdrv_reopen_prepare().

To fix this, bdrv_reopen_prepare() has to call .bdrv_reopen_abort() if
it wants to return an error after .bdrv_reopen_prepare() has succeeded.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block.c | 12 ++++++++++++
 1 file changed, 12 insertions(+)

diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
     QDict *orig_reopen_opts;
     char *discard = NULL;
     bool read_only;
+    bool drv_prepared = false;
 
     assert(reopen_state != NULL);
     assert(reopen_state->bs->drv != NULL);
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
         goto error;
     }
 
+    drv_prepared = true;
+
     /* Options that are not handled are only okay if they are unchanged
      * compared to the old state. It is expected that some options are only
      * used for the initial open, but not reopen (e.g. filename) */
@@ -XXX,XX +XXX,XX @@ int bdrv_reopen_prepare(BDRVReopenState *reopen_state, BlockReopenQueue *queue,
     reopen_state->options = qobject_ref(orig_reopen_opts);
 
 error:
+    if (ret < 0 && drv_prepared) {
+        /* drv->bdrv_reopen_prepare() has succeeded, so we need to
+         * call drv->bdrv_reopen_abort() before signaling an error
+         * (bdrv_reopen_multiple() will not call bdrv_reopen_abort()
+         * when the respective bdrv_reopen_prepare() has failed) */
+        if (drv->bdrv_reopen_abort) {
+            drv->bdrv_reopen_abort(reopen_state);
+        }
+    }
     qemu_opts_del(opts);
     qobject_unref(orig_reopen_opts);
     g_free(discard);
-- 
2.19.1

From: Max Reitz <mreitz@redhat.com>

s->locked_shared_perm is the set of bits locked in the file, which is
the inverse of the permissions actually shared.  So we need to pass them
as they are to raw_apply_lock_bytes() instead of inverting them again.

Reported-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-posix.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

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 @@ static void raw_reopen_commit(BDRVReopenState *state)
 
     /* Copy locks to the new fd before closing the old one. */
     raw_apply_lock_bytes(NULL, rs->fd, s->locked_perm,
-                         ~s->locked_shared_perm, false, &local_err);
+                         s->locked_shared_perm, false, &local_err);
     if (local_err) {
         /* shouldn't fail in a sane host, but report it just in case. */
         error_report_err(local_err);
-- 
2.19.1

From: Max Reitz <mreitz@redhat.com>

Signed-off-by: Max Reitz <mreitz@redhat.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/182     | 71 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/182.out |  9 +++++
 2 files changed, 80 insertions(+)

diff --git a/tests/qemu-iotests/182 b/tests/qemu-iotests/182
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/182
+++ b/tests/qemu-iotests/182
@@ -XXX,XX +XXX,XX @@ status=1	# failure is the default!
 _cleanup()
 {
     _cleanup_test_img
+    rm -f "$TEST_IMG.overlay"
 }
 trap "_cleanup; exit \$status" 0 1 2 3 15
 
@@ -XXX,XX +XXX,XX @@ echo 'quit' | $QEMU -nographic -monitor stdio \
 
 _cleanup_qemu
 
+echo
+echo '=== Testing reopen ==='
+echo
+
+# This tests that reopening does not unshare any permissions it should
+# not unshare
+# (There was a bug where reopening shared exactly the opposite of the
+# permissions it was supposed to share)
+
+_launch_qemu
+
+_send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'qmp_capabilities'}" \
+    'return'
+
+# Open the image without any format layer (we are not going to access
+# it, so that is fine)
+# This should keep all permissions shared.
+success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'blockdev-add',
+      'arguments': {
+          'node-name': 'node0',
+          'driver': 'file',
+          'filename': '$TEST_IMG',
+          'locking': 'on'
+          } }" \
+    'return' \
+    'error'
+
+# This snapshot will perform a reopen to drop R/W to RO.
+# It should still keep all permissions shared.
+success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'blockdev-snapshot-sync',
+      'arguments': {
+          'node-name': 'node0',
+          'snapshot-file': '$TEST_IMG.overlay',
+          'snapshot-node-name': 'node1'
+      } }" \
+    'return' \
+    'error'
+
+# Now open the same file again
+# This does not require any permissions (and does not unshare any), so
+# this will not conflict with node0.
+success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'blockdev-add',
+      'arguments': {
+          'node-name': 'node1',
+          'driver': 'file',
+          'filename': '$TEST_IMG',
+          'locking': 'on'
+          } }" \
+    'return' \
+    'error'
+
+# Now we attach the image to a virtio-blk device.  This device does
+# require some permissions (at least WRITE and READ_CONSISTENT), so if
+# reopening node0 unshared any (which it should not have), this will
+# fail (but it should not).
+success_or_failure=y _send_qemu_cmd $QEMU_HANDLE \
+    "{'execute': 'device_add',
+      'arguments': {
+          'driver': 'virtio-blk',
+          'drive': 'node1'
+      } }" \
+    'return' \
+    'error'
+
+_cleanup_qemu
+
 # success, all done
 echo "*** done"
 rm -f $seq.full
diff --git a/tests/qemu-iotests/182.out b/tests/qemu-iotests/182.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/182.out
+++ b/tests/qemu-iotests/182.out
@@ -XXX,XX +XXX,XX @@ Starting QEMU
 Starting a second QEMU using the same image should fail
 QEMU_PROG: -drive file=TEST_DIR/t.qcow2,if=none,id=drive0,file.locking=on: Failed to get "write" lock
 Is another process using the image [TEST_DIR/t.qcow2]?
+
+=== Testing reopen ===
+
+{"return": {}}
+{"return": {}}
+Formatting 'TEST_DIR/t.qcow2.overlay', fmt=qcow2 size=197120 backing_file=TEST_DIR/t.qcow2 backing_fmt=file cluster_size=65536 lazy_refcounts=off refcount_bits=16
+{"return": {}}
+{"return": {}}
+{"return": {}}
 *** done
-- 
2.19.1

The following changes since commit 1b8c45899715d292398152ba97ef755ccaf84680:

Merge remote-tracking branch 'remotes/dgilbert/tags/pull-migration-20200507a' into staging (2020-05-07 18:43:20 +0100)

are available in the Git repository at:

git://repo.or.cz/qemu/kevin.git tags/for-upstream

for you to fetch changes up to 47e0b38a13935cb666f88964c3096654092f42d6:

block: Drop unused .bdrv_has_zero_init_truncate (2020-05-08 13:26:35 +0200)

----------------------------------------------------------------
Block layer patches:

- qcow2: Fix preallocation on block devices
- backup: Make sure that source and target size match
- vmdk: Fix zero cluster handling
- Follow-up cleanups and fixes for the truncate changes
- iotests: Skip more tests if required drivers are missing

----------------------------------------------------------------
Alberto Garcia (1):
      qcow2: Avoid integer wraparound in qcow2_co_truncate()

Eric Blake (9):
      gluster: Drop useless has_zero_init callback
      file-win32: Support BDRV_REQ_ZERO_WRITE for truncate
      nfs: Support BDRV_REQ_ZERO_WRITE for truncate
      rbd: Support BDRV_REQ_ZERO_WRITE for truncate
      sheepdog: Support BDRV_REQ_ZERO_WRITE for truncate
      ssh: Support BDRV_REQ_ZERO_WRITE for truncate
      parallels: Rework truncation logic
      vhdx: Rework truncation logic
      block: Drop unused .bdrv_has_zero_init_truncate

Kevin Wolf (11):
      vmdk: Rename VmdkMetaData.valid to new_allocation
      vmdk: Fix zero cluster allocation
      vmdk: Fix partial overwrite of zero cluster
      vmdk: Don't update L2 table for zero write on zero cluster
      vmdk: Flush only once in vmdk_L2update()
      iotests: vmdk: Enable zeroed_grained=on by default
      iotests/283: Use consistent size for source and target
      backup: Improve error for bdrv_getlength() failure
      backup: Make sure that source and target size match
      iotests: Backup with different source/target size
      iotests/055: Use cache.no-flush for vmdk target

Max Reitz (1):
      qcow2: Fix preallocation on block devices

Vladimir Sementsov-Ogievskiy (8):
      iotests: handle tmpfs
      iotests/082: require bochs
      iotests/148: use skip_if_unsupported
      iotests/041: drop self.assert_no_active_block_jobs()
      iotests/055: refactor compressed backup to vmdk
      iotests/055: skip vmdk target tests if vmdk is not whitelisted
      iotests/109: mark required formats as required to support whitelisting
      iotests/113: mark bochs as required to support whitelisting

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Some tests requires O_DIRECT, or want it by default. Introduce smarter
O_DIRECT handling:

- Check O_DIRECT in common.rc, if it is requested by selected
cache-mode.

- Support second fall-through argument in _default_cache_mode

Inspired-by: Max's 23e1d054112cec1e
Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200430124713.3067-2-vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/091       |  2 +-
 tests/qemu-iotests/common.rc | 37 ++++++++++++++++++++++++++++++++++--
 2 files changed, 36 insertions(+), 3 deletions(-)

diff --git a/tests/qemu-iotests/091 b/tests/qemu-iotests/091
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/091
+++ b/tests/qemu-iotests/091
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt qcow2
 _supported_proto file
 _supported_os Linux
-_default_cache_mode none
 _supported_cache_modes writethrough none writeback
+_default_cache_mode none writeback
 
 size=1G
 
diff --git a/tests/qemu-iotests/common.rc b/tests/qemu-iotests/common.rc
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/common.rc
+++ b/tests/qemu-iotests/common.rc
@@ -XXX,XX +XXX,XX @@ _supported_cache_modes()
     _notrun "not suitable for cache mode: $CACHEMODE"
 }
 
+# Check whether the filesystem supports O_DIRECT
+_check_o_direct()
+{
+    $QEMU_IMG create -f raw "$TEST_IMG".test_o_direct 1M > /dev/null
+    out=$($QEMU_IO -f raw -t none -c quit "$TEST_IMG".test_o_direct 2>&1)
+    rm -f "$TEST_IMG".test_o_direct
+
+    [[ "$out" != *"O_DIRECT"* ]]
+}
+
+_require_o_direct()
+{
+    if ! _check_o_direct; then
+        _notrun "file system on $TEST_DIR does not support O_DIRECT"
+    fi
+}
+
+_check_cache_mode()
+{
+    if [ $CACHEMODE == "none" ] || [ $CACHEMODE == "directsync" ]; then
+        _require_o_direct
+    fi
+}
+
+_check_cache_mode
+
+# $1 - cache mode to use by default
+# $2 - (optional) cache mode to use by default if O_DIRECT is not supported
 _default_cache_mode()
 {
     if $CACHEMODE_IS_DEFAULT; then
-        CACHEMODE="$1"
-        QEMU_IO="$QEMU_IO --cache $1"
+        if [ -z "$2" ] || _check_o_direct; then
+            CACHEMODE="$1"
+        else
+            CACHEMODE="$2"
+        fi
+        QEMU_IO="$QEMU_IO --cache $CACHEMODE"
+        _check_cache_mode
         return
     fi
 }
-- 
2.25.3

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Drop check for no block-jobs: it's obvious that there no jobs
immediately after vm.launch().

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200430124713.3067-5-vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/041 | 8 --------
 1 file changed, 8 deletions(-)

diff --git a/tests/qemu-iotests/041 b/tests/qemu-iotests/041
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/041
+++ b/tests/qemu-iotests/041
@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
                 pass
 
     def test_complete(self):
-        self.assert_no_active_block_jobs()
-
         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
                              sync='full', node_name="repair0", replaces="img1",
                              target=quorum_repair_img, format=iotests.imgfmt)
@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
                         'target image does not match source after mirroring')
 
     def test_cancel(self):
-        self.assert_no_active_block_jobs()
-
         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
                              sync='full', node_name="repair0", replaces="img1",
                              target=quorum_repair_img, format=iotests.imgfmt)
@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
         self.assert_has_block_node(None, quorum_img3)
 
     def test_cancel_after_ready(self):
-        self.assert_no_active_block_jobs()
-
         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
                              sync='full', node_name="repair0", replaces="img1",
                              target=quorum_repair_img, format=iotests.imgfmt)
@@ -XXX,XX +XXX,XX @@ class TestRepairQuorum(iotests.QMPTestCase):
                         'target image does not match source after mirroring')
 
     def test_pause(self):
-        self.assert_no_active_block_jobs()
-
         result = self.vm.qmp('drive-mirror', job_id='job0', device='quorum0',
                              sync='full', node_name="repair0", replaces="img1",
                              target=quorum_repair_img, format=iotests.imgfmt)
-- 
2.25.3

From: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>

Instead of looping in each test, let's better refactor vmdk target case
as a subclass.

Signed-off-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Message-Id: <20200430124713.3067-6-vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/055     | 70 ++++++++++++++++++++------------------
 tests/qemu-iotests/055.out |  4 +--
 2 files changed, 39 insertions(+), 35 deletions(-)

diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/055
+++ b/tests/qemu-iotests/055
@@ -XXX,XX +XXX,XX @@ class TestSingleTransaction(iotests.QMPTestCase):
         self.assert_no_active_block_jobs()
 
 
-class TestDriveCompression(iotests.QMPTestCase):
+class TestCompressedToQcow2(iotests.QMPTestCase):
     image_len = 64 * 1024 * 1024 # MB
-    fmt_supports_compression = [{'type': 'qcow2', 'args': ()},
-                                {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}]
+    target_fmt = {'type': 'qcow2', 'args': ()}
 
     def tearDown(self):
         self.vm.shutdown()
@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
         except OSError:
             pass
 
-    def do_prepare_drives(self, fmt, args, attach_target):
+    def do_prepare_drives(self, attach_target):
         self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
 
-        qemu_img('create', '-f', fmt, blockdev_target_img,
-                 str(TestDriveCompression.image_len), *args)
+        qemu_img('create', '-f', self.target_fmt['type'], blockdev_target_img,
+                 str(self.image_len), *self.target_fmt['args'])
         if attach_target:
             self.vm.add_drive(blockdev_target_img,
-                              img_format=fmt, interface="none")
+                              img_format=self.target_fmt['type'],
+                              interface="none")
 
         self.vm.launch()
 
-    def do_test_compress_complete(self, cmd, format, attach_target, **args):
-        self.do_prepare_drives(format['type'], format['args'], attach_target)
+    def do_test_compress_complete(self, cmd, attach_target, **args):
+        self.do_prepare_drives(attach_target)
 
         self.assert_no_active_block_jobs()
 
@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
 
         self.vm.shutdown()
         self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
-                                               iotests.imgfmt, format['type']),
+                                               iotests.imgfmt,
+                                               self.target_fmt['type']),
                         'target image does not match source after backup')
 
     def test_complete_compress_drive_backup(self):
-        for format in TestDriveCompression.fmt_supports_compression:
-            self.do_test_compress_complete('drive-backup', format, False,
-                                           target=blockdev_target_img, mode='existing')
+        self.do_test_compress_complete('drive-backup', False,
+                                       target=blockdev_target_img,
+                                       mode='existing')
 
     def test_complete_compress_blockdev_backup(self):
-        for format in TestDriveCompression.fmt_supports_compression:
-            self.do_test_compress_complete('blockdev-backup', format, True,
-                                           target='drive1')
+        self.do_test_compress_complete('blockdev-backup',
+                                       True, target='drive1')
 
-    def do_test_compress_cancel(self, cmd, format, attach_target, **args):
-        self.do_prepare_drives(format['type'], format['args'], attach_target)
+    def do_test_compress_cancel(self, cmd, attach_target, **args):
+        self.do_prepare_drives(attach_target)
 
         self.assert_no_active_block_jobs()
 
@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
         self.vm.shutdown()
 
     def test_compress_cancel_drive_backup(self):
-        for format in TestDriveCompression.fmt_supports_compression:
-            self.do_test_compress_cancel('drive-backup', format, False,
-                                         target=blockdev_target_img, mode='existing')
+        self.do_test_compress_cancel('drive-backup', False,
+                                     target=blockdev_target_img,
+                                     mode='existing')
 
     def test_compress_cancel_blockdev_backup(self):
-       for format in TestDriveCompression.fmt_supports_compression:
-            self.do_test_compress_cancel('blockdev-backup', format, True,
-                                         target='drive1')
+        self.do_test_compress_cancel('blockdev-backup', True,
+                                     target='drive1')
 
-    def do_test_compress_pause(self, cmd, format, attach_target, **args):
-        self.do_prepare_drives(format['type'], format['args'], attach_target)
+    def do_test_compress_pause(self, cmd, attach_target, **args):
+        self.do_prepare_drives(attach_target)
 
         self.assert_no_active_block_jobs()
 
@@ -XXX,XX +XXX,XX @@ class TestDriveCompression(iotests.QMPTestCase):
 
         self.vm.shutdown()
         self.assertTrue(iotests.compare_images(test_img, blockdev_target_img,
-                                               iotests.imgfmt, format['type']),
+                                               iotests.imgfmt,
+                                               self.target_fmt['type']),
                         'target image does not match source after backup')
 
     def test_compress_pause_drive_backup(self):
-        for format in TestDriveCompression.fmt_supports_compression:
-            self.do_test_compress_pause('drive-backup', format, False,
-                                        target=blockdev_target_img, mode='existing')
+        self.do_test_compress_pause('drive-backup', False,
+                                    target=blockdev_target_img,
+                                    mode='existing')
 
     def test_compress_pause_blockdev_backup(self):
-        for format in TestDriveCompression.fmt_supports_compression:
-            self.do_test_compress_pause('blockdev-backup', format, True,
-                                        target='drive1')
+        self.do_test_compress_pause('blockdev-backup', True,
+                                    target='drive1')
+
+
+class TestCompressedToVmdk(TestCompressedToQcow2):
+    target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}
+
 
 if __name__ == '__main__':
     iotests.main(supported_fmts=['raw', 'qcow2'],
diff --git a/tests/qemu-iotests/055.out b/tests/qemu-iotests/055.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/055.out
+++ b/tests/qemu-iotests/055.out
@@ -XXX,XX +XXX,XX @@
-..............................
+....................................
 ----------------------------------------------------------------------
-Ran 30 tests
+Ran 36 tests
 
 OK
-- 
2.25.3

From: Alberto Garcia <berto@igalia.com>

After commit f01643fb8b47e8a70c04bbf45e0f12a9e5bc54de when an image is
extended and BDRV_REQ_ZERO_WRITE is set then the new clusters are
zeroized.

The code however does not detect correctly situations when the old and
the new end of the image are within the same cluster. The problem can
be reproduced with these steps:

qemu-img create -f qcow2 backing.qcow2 1M
   qemu-img create -f qcow2 -F qcow2 -b backing.qcow2 top.qcow2
   qemu-img resize --shrink top.qcow2 520k
   qemu-img resize top.qcow2 567k

In the last step offset - zero_start causes an integer wraparound.

Signed-off-by: Alberto Garcia <berto@igalia.com>
Message-Id: <20200504155217.10325-1-berto@igalia.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c              | 12 ++++---
 tests/qemu-iotests/292     | 73 ++++++++++++++++++++++++++++++++++++++
 tests/qemu-iotests/292.out | 24 +++++++++++++
 tests/qemu-iotests/group   |  1 +
 4 files changed, 105 insertions(+), 5 deletions(-)
 create mode 100755 tests/qemu-iotests/292
 create mode 100644 tests/qemu-iotests/292.out

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
          * requires a cluster-aligned start. The end may be unaligned if it is
          * at the end of the image (which it is here).
          */
-        ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
-        if (ret < 0) {
-            error_setg_errno(errp, -ret, "Failed to zero out new clusters");
-            goto fail;
+        if (offset > zero_start) {
+            ret = qcow2_cluster_zeroize(bs, zero_start, offset - zero_start, 0);
+            if (ret < 0) {
+                error_setg_errno(errp, -ret, "Failed to zero out new clusters");
+                goto fail;
+            }
         }
 
         /* Write explicit zeros for the unaligned head */
         if (zero_start > old_length) {
-            uint64_t len = zero_start - old_length;
+            uint64_t len = MIN(zero_start, offset) - old_length;
             uint8_t *buf = qemu_blockalign0(bs, len);
             QEMUIOVector qiov;
             qemu_iovec_init_buf(&qiov, buf, len);
diff --git a/tests/qemu-iotests/292 b/tests/qemu-iotests/292
new file mode 100755
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/292
@@ -XXX,XX +XXX,XX @@
+#!/usr/bin/env bash
+#
+# Test resizing a qcow2 image with a backing file
+#
+# Copyright (C) 2020 Igalia, S.L.
+# Author: Alberto Garcia <berto@igalia.com>
+#
+# This program is free software; you can redistribute it and/or modify
+# it under the terms of the GNU General Public License as published by
+# the Free Software Foundation; either version 2 of the License, or
+# (at your option) any later version.
+#
+# This program is distributed in the hope that it will be useful,
+# but WITHOUT ANY WARRANTY; without even the implied warranty of
+# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+# GNU General Public License for more details.
+#
+# You should have received a copy of the GNU General Public License
+# along with this program.  If not, see <http://www.gnu.org/licenses/>.
+#
+
+# creator
+owner=berto@igalia.com
+
+seq=`basename $0`
+echo "QA output created by $seq"
+
+status=1    # failure is the default!
+
+_cleanup()
+{
+    _cleanup_test_img
+}
+trap "_cleanup; exit \$status" 0 1 2 3 15
+
+# get standard environment, filters and checks
+. ./common.rc
+. ./common.filter
+
+_supported_fmt qcow2
+_supported_proto file
+_supported_os Linux
+
+echo '### Create the backing image'
+BACKING_IMG="$TEST_IMG.base"
+TEST_IMG="$BACKING_IMG" _make_test_img 1M
+
+echo '### Fill the backing image with data (0x11)'
+$QEMU_IO -c 'write -P 0x11 0 1M' "$BACKING_IMG" | _filter_qemu_io
+
+echo '### Create the top image'
+_make_test_img -F "$IMGFMT" -b "$BACKING_IMG"
+
+echo '### Fill the top image with data (0x22)'
+$QEMU_IO -c 'write -P 0x22 0 1M' "$TEST_IMG" | _filter_qemu_io
+
+# Both offsets are part of the same cluster.
+echo '### Shrink the image to 520k'
+$QEMU_IMG resize --shrink "$TEST_IMG" 520k
+echo '### Grow the image to 567k'
+$QEMU_IMG resize "$TEST_IMG" 567k
+
+echo '### Check that the tail of the image reads as zeroes'
+$QEMU_IO -c 'read -P 0x22    0 520k' "$TEST_IMG" | _filter_qemu_io
+$QEMU_IO -c 'read -P 0x00 520k  47k' "$TEST_IMG" | _filter_qemu_io
+
+echo '### Show output of qemu-img map'
+$QEMU_IMG map "$TEST_IMG" | _filter_testdir
+
+# success, all done
+echo "*** done"
+rm -f $seq.full
+status=0
diff --git a/tests/qemu-iotests/292.out b/tests/qemu-iotests/292.out
new file mode 100644
index XXXXXXX..XXXXXXX
--- /dev/null
+++ b/tests/qemu-iotests/292.out
@@ -XXX,XX +XXX,XX @@
+QA output created by 292
+### Create the backing image
+Formatting 'TEST_DIR/t.IMGFMT.base', fmt=IMGFMT size=1048576
+### Fill the backing image with data (0x11)
+wrote 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+### Create the top image
+Formatting 'TEST_DIR/t.IMGFMT', fmt=IMGFMT size=1048576 backing_file=TEST_DIR/t.IMGFMT.base backing_fmt=IMGFMT
+### Fill the top image with data (0x22)
+wrote 1048576/1048576 bytes at offset 0
+1 MiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+### Shrink the image to 520k
+Image resized.
+### Grow the image to 567k
+Image resized.
+### Check that the tail of the image reads as zeroes
+read 532480/532480 bytes at offset 0
+520 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+read 48128/48128 bytes at offset 532480
+47 KiB, X ops; XX:XX:XX.X (XXX YYY/sec and XXX ops/sec)
+### Show output of qemu-img map
+Offset          Length          Mapped to       File
+0               0x8dc00         0x50000         TEST_DIR/t.qcow2
+*** done
diff --git a/tests/qemu-iotests/group b/tests/qemu-iotests/group
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/group
+++ b/tests/qemu-iotests/group
@@ -XXX,XX +XXX,XX @@
 288 quick
 289 rw quick
 290 rw auto quick
+292 rw auto quick
-- 
2.25.3

m_data is used for zero clusters even though valid == 0. It really only
means that a new cluster was allocated in the image file. Rename it to
reflect this.

While at it, change it from int to bool, too.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430133007.170335-2-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vmdk.c | 8 ++++----
 1 file changed, 4 insertions(+), 4 deletions(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ typedef struct VmdkMetaData {
     unsigned int l1_index;
     unsigned int l2_index;
     unsigned int l2_offset;
-    int valid;
+    bool new_allocation;
     uint32_t *l2_cache_entry;
 } VmdkMetaData;
 
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
     unsigned int l2_size_bytes = extent->l2_size * extent->entry_size;
 
     if (m_data) {
-        m_data->valid = 0;
+        m_data->new_allocation = false;
     }
     if (extent->flat) {
         *cluster_offset = extent->flat_start_offset;
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
             return ret;
         }
         if (m_data) {
-            m_data->valid = 1;
+            m_data->new_allocation = true;
             m_data->l1_index = l1_index;
             m_data->l2_index = l2_index;
             m_data->l2_offset = l2_offset;
@@ -XXX,XX +XXX,XX @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
             if (ret) {
                 return ret;
             }
-            if (m_data.valid) {
+            if (m_data.new_allocation) {
                 /* update L2 tables */
                 if (vmdk_L2update(extent, &m_data,
                                   cluster_offset >> BDRV_SECTOR_BITS)
-- 
2.25.3

m_data must contain valid data even for zero clusters when no cluster
was allocated in the image file. Without this, zero writes segfault with
images that have zeroed_grain=on.

For zero writes, we don't want to allocate a cluster in the image file
even in compressed files.

Fixes: 524089bce43fd1cd3daaca979872451efa2cf7c6
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430133007.170335-3-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vmdk.c | 12 +++++++-----
 1 file changed, 7 insertions(+), 5 deletions(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
     extent->l2_cache_counts[min_index] = 1;
  found:
     l2_index = ((offset >> 9) / extent->cluster_sectors) % extent->l2_size;
+    if (m_data) {
+        m_data->l1_index = l1_index;
+        m_data->l2_index = l2_index;
+        m_data->l2_offset = l2_offset;
+        m_data->l2_cache_entry = ((uint32_t *)l2_table) + l2_index;
+    }
 
     if (extent->sesparse) {
         cluster_sector = le64_to_cpu(((uint64_t *)l2_table)[l2_index]);
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
         }
         if (m_data) {
             m_data->new_allocation = true;
-            m_data->l1_index = l1_index;
-            m_data->l2_index = l2_index;
-            m_data->l2_offset = l2_offset;
-            m_data->l2_cache_entry = ((uint32_t *)l2_table) + l2_index;
         }
     }
     *cluster_offset = cluster_sector << BDRV_SECTOR_BITS;
@@ -XXX,XX +XXX,XX @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
                 error_report("Could not write to allocated cluster"
                               " for streamOptimized");
                 return -EIO;
-            } else {
+            } else if (!zeroed) {
                 /* allocate */
                 ret = get_cluster_offset(bs, extent, &m_data, offset,
                                          true, &cluster_offset, 0, 0);
-- 
2.25.3

When overwriting a zero cluster, we must not perform copy-on-write from
the backing file, but from a zeroed buffer.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430133007.170335-4-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vmdk.c | 18 ++++++++++++------
 1 file changed, 12 insertions(+), 6 deletions(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static void vmdk_refresh_limits(BlockDriverState *bs, Error **errp)
  * get_whole_cluster
  *
  * Copy backing file's cluster that covers @sector_num, otherwise write zero,
- * to the cluster at @cluster_sector_num.
+ * to the cluster at @cluster_sector_num. If @zeroed is true, we're overwriting
+ * a zeroed cluster in the current layer and must not copy data from the
+ * backing file.
  *
  * If @skip_start_sector < @skip_end_sector, the relative range
  * [@skip_start_sector, @skip_end_sector) is not copied or written, and leave
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
                              uint64_t cluster_offset,
                              uint64_t offset,
                              uint64_t skip_start_bytes,
-                             uint64_t skip_end_bytes)
+                             uint64_t skip_end_bytes,
+                             bool zeroed)
 {
     int ret = VMDK_OK;
     int64_t cluster_bytes;
     uint8_t *whole_grain;
+    bool copy_from_backing;
 
     /* For COW, align request sector_num to cluster start */
     cluster_bytes = extent->cluster_sectors << BDRV_SECTOR_BITS;
     offset = QEMU_ALIGN_DOWN(offset, cluster_bytes);
     whole_grain = qemu_blockalign(bs, cluster_bytes);
+    copy_from_backing = bs->backing && !zeroed;
 
-    if (!bs->backing) {
+    if (!copy_from_backing) {
         memset(whole_grain, 0, skip_start_bytes);
         memset(whole_grain + skip_end_bytes, 0, cluster_bytes - skip_end_bytes);
     }
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
 
     /* Read backing data before skip range */
     if (skip_start_bytes > 0) {
-        if (bs->backing) {
+        if (copy_from_backing) {
             /* qcow2 emits this on bs->file instead of bs->backing */
             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_pread(bs->backing, offset, whole_grain,
@@ -XXX,XX +XXX,XX @@ static int get_whole_cluster(BlockDriverState *bs,
     }
     /* Read backing data after skip range */
     if (skip_end_bytes < cluster_bytes) {
-        if (bs->backing) {
+        if (copy_from_backing) {
             /* qcow2 emits this on bs->file instead of bs->backing */
             BLKDBG_EVENT(extent->file, BLKDBG_COW_READ);
             ret = bdrv_pread(bs->backing, offset + skip_end_bytes,
@@ -XXX,XX +XXX,XX @@ static int get_cluster_offset(BlockDriverState *bs,
          * or inappropriate VM shutdown.
          */
         ret = get_whole_cluster(bs, extent, cluster_sector * BDRV_SECTOR_SIZE,
-                                offset, skip_start_bytes, skip_end_bytes);
+                                offset, skip_start_bytes, skip_end_bytes,
+                                zeroed);
         if (ret) {
             return ret;
         }
-- 
2.25.3

If a cluster is already zeroed, we don't have to call vmdk_L2update(),
which is rather slow because it flushes the image file.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430133007.170335-5-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vmdk.c | 2 +-
 1 file changed, 1 insertion(+), 1 deletion(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_pwritev(BlockDriverState *bs, uint64_t offset,
                     offset_in_cluster == 0 &&
                     n_bytes >= extent->cluster_sectors * BDRV_SECTOR_SIZE) {
                 n_bytes = extent->cluster_sectors * BDRV_SECTOR_SIZE;
-                if (!zero_dry_run) {
+                if (!zero_dry_run && ret != VMDK_ZEROED) {
                     /* update L2 tables */
                     if (vmdk_L2update(extent, &m_data, VMDK_GTE_ZEROED)
                             != VMDK_OK) {
-- 
2.25.3

If we have a backup L2 table, we currently flush once after writing to
the active L2 table and again after writing to the backup table. A
single flush is enough and makes things a little less slow.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430133007.170335-6-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vmdk.c | 7 +++++--
 1 file changed, 5 insertions(+), 2 deletions(-)

diff --git a/block/vmdk.c b/block/vmdk.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vmdk.c
+++ b/block/vmdk.c
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
     offset = cpu_to_le32(offset);
     /* update L2 table */
     BLKDBG_EVENT(extent->file, BLKDBG_L2_UPDATE);
-    if (bdrv_pwrite_sync(extent->file,
+    if (bdrv_pwrite(extent->file,
                 ((int64_t)m_data->l2_offset * 512)
                     + (m_data->l2_index * sizeof(offset)),
                 &offset, sizeof(offset)) < 0) {
@@ -XXX,XX +XXX,XX @@ static int vmdk_L2update(VmdkExtent *extent, VmdkMetaData *m_data,
     /* update backup L2 table */
     if (extent->l1_backup_table_offset != 0) {
         m_data->l2_offset = extent->l1_backup_table[m_data->l1_index];
-        if (bdrv_pwrite_sync(extent->file,
+        if (bdrv_pwrite(extent->file,
                     ((int64_t)m_data->l2_offset * 512)
                         + (m_data->l2_index * sizeof(offset)),
                     &offset, sizeof(offset)) < 0) {
             return VMDK_ERROR;
         }
     }
+    if (bdrv_flush(extent->file->bs) < 0) {
+        return VMDK_ERROR;
+    }
     if (m_data->l2_cache_entry) {
         *m_data->l2_cache_entry = offset;
     }
-- 
2.25.3

In order to avoid bitrot in the zero cluster code in VMDK, enable
zeroed_grain=on by default for the tests.

059 now unsets the default options because zeroed_grain=on works only
with some subformats and the test case tests many different subformats,
including those for which it doesn't work.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430133007.170335-7-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/059   | 6 +++---
 tests/qemu-iotests/check | 3 +++
 2 files changed, 6 insertions(+), 3 deletions(-)

diff --git a/tests/qemu-iotests/059 b/tests/qemu-iotests/059
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/059
+++ b/tests/qemu-iotests/059
@@ -XXX,XX +XXX,XX @@ trap "_cleanup; exit \$status" 0 1 2 3 15
 _supported_fmt vmdk
 _supported_proto file
 _supported_os Linux
-_unsupported_imgopts "subformat=monolithicFlat" \
-                     "subformat=twoGbMaxExtentFlat" \
-                     "subformat=twoGbMaxExtentSparse"
+
+# We test all kinds of VMDK options here, so ignore user-specified options
+IMGOPTS=""
 
 capacity_offset=16
 granularity_offset=20
diff --git a/tests/qemu-iotests/check b/tests/qemu-iotests/check
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/check
+++ b/tests/qemu-iotests/check
@@ -XXX,XX +XXX,XX @@ fi
 if [ "$IMGFMT" == "luks" ] && ! (echo "$IMGOPTS" | grep "iter-time=" > /dev/null); then
     IMGOPTS=$(_optstr_add "$IMGOPTS" "iter-time=10")
 fi
+if [ "$IMGFMT" == "vmdk" ] && ! (echo "$IMGOPTS" | grep "zeroed_grain=" > /dev/null); then
+    IMGOPTS=$(_optstr_add "$IMGOPTS" "zeroed_grain=on")
+fi
 
 if [ -z "$SAMPLE_IMG_DIR" ]; then
         SAMPLE_IMG_DIR="$source_iotests/sample_images"
-- 
2.25.3

The test case forgot to specify the null-co size for the target node.
When adding a check to backup that both sizes match, this would fail
because of the size mismatch and not the behaviour that the test really
wanted to test.

Fixes: a541fcc27c98b96da187c7d4573f3270f3ddd283
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430142755.315494-2-kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/283     | 6 +++++-
 tests/qemu-iotests/283.out | 2 +-
 2 files changed, 6 insertions(+), 2 deletions(-)

diff --git a/tests/qemu-iotests/283 b/tests/qemu-iotests/283
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/283
+++ b/tests/qemu-iotests/283
@@ -XXX,XX +XXX,XX @@ to check that crash is fixed :)
 vm = iotests.VM()
 vm.launch()
 
-vm.qmp_log('blockdev-add', **{'node-name': 'target', 'driver': 'null-co'})
+vm.qmp_log('blockdev-add', **{
+    'node-name': 'target',
+    'driver': 'null-co',
+    'size': size,
+})
 
 vm.qmp_log('blockdev-add', **{
     'node-name': 'source',
diff --git a/tests/qemu-iotests/283.out b/tests/qemu-iotests/283.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/283.out
+++ b/tests/qemu-iotests/283.out
@@ -XXX,XX +XXX,XX @@
-{"execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "target"}}
+{"execute": "blockdev-add", "arguments": {"driver": "null-co", "node-name": "target", "size": 1048576}}
 {"return": {}}
 {"execute": "blockdev-add", "arguments": {"driver": "blkdebug", "image": {"driver": "null-co", "node-name": "base", "size": 1048576}, "node-name": "source"}}
 {"return": {}}
-- 
2.25.3

bdrv_get_device_name() will be an empty string with modern management
tools that don't use -drive. Use bdrv_get_device_or_node_name() instead
so that the node name is used if the BlockBackend is anonymous.

While at it, start with upper case to make the message consistent with
the rest of the function.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-Id: <20200430142755.315494-3-kwolf@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/backup.c | 4 ++--
 1 file changed, 2 insertions(+), 2 deletions(-)

diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
 
     len = bdrv_getlength(bs);
     if (len < 0) {
-        error_setg_errno(errp, -len, "unable to get length for '%s'",
-                         bdrv_get_device_name(bs));
+        error_setg_errno(errp, -len, "Unable to get length for '%s'",
+                         bdrv_get_device_or_node_name(bs));
         goto error;
     }
 
-- 
2.25.3

Since the introduction of a backup filter node in commit 00e30f05d, the
backup block job crashes when the target image is smaller than the
source image because it will try to write after the end of the target
node without having BLK_PERM_RESIZE. (Previously, the BlockBackend layer
would have caught this and errored out gracefully.)

We can fix this and even do better than the old behaviour: Check that
source and target have the same image size at the start of the block job
and unshare BLK_PERM_RESIZE. (This permission was already unshared
before the same commit 00e30f05d, but the BlockBackend that was used to
make the restriction was removed without a replacement.) This will
immediately error out when starting the job instead of only when writing
to a block that doesn't exist in the target.

Longer target than source would technically work because we would never
write to blocks that don't exist, but semantically these are invalid,
too, because a backup is supposed to create a copy, not just an image
that starts with a copy.

Fixes: 00e30f05de1d19586345ec373970ef4c192c6270
Fixes: https://bugzilla.redhat.com/show_bug.cgi?id=1778593
Cc: qemu-stable@nongnu.org
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430142755.315494-4-kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/backup-top.c | 14 +++++++++-----
 block/backup.c     | 14 +++++++++++++-
 2 files changed, 22 insertions(+), 6 deletions(-)

diff --git a/block/backup-top.c b/block/backup-top.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup-top.c
+++ b/block/backup-top.c
@@ -XXX,XX +XXX,XX @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
          *
          * Share write to target (child_file), to not interfere
          * with guest writes to its disk which may be in target backing chain.
+         * Can't resize during a backup block job because we check the size
+         * only upfront.
          */
-        *nshared = BLK_PERM_ALL;
+        *nshared = BLK_PERM_ALL & ~BLK_PERM_RESIZE;
         *nperm = BLK_PERM_WRITE;
     } else {
         /* Source child */
@@ -XXX,XX +XXX,XX @@ static void backup_top_child_perm(BlockDriverState *bs, BdrvChild *c,
         if (perm & BLK_PERM_WRITE) {
             *nperm = *nperm | BLK_PERM_CONSISTENT_READ;
         }
-        *nshared &= ~BLK_PERM_WRITE;
+        *nshared &= ~(BLK_PERM_WRITE | BLK_PERM_RESIZE);
     }
 }
 
@@ -XXX,XX +XXX,XX @@ BlockDriverState *bdrv_backup_top_append(BlockDriverState *source,
 {
     Error *local_err = NULL;
     BDRVBackupTopState *state;
-    BlockDriverState *top = bdrv_new_open_driver(&bdrv_backup_top_filter,
-                                                 filter_node_name,
-                                                 BDRV_O_RDWR, errp);
+    BlockDriverState *top;
     bool appended = false;
 
+    assert(source->total_sectors == target->total_sectors);
+
+    top = bdrv_new_open_driver(&bdrv_backup_top_filter, filter_node_name,
+                               BDRV_O_RDWR, errp);
     if (!top) {
         return NULL;
     }
diff --git a/block/backup.c b/block/backup.c
index XXXXXXX..XXXXXXX 100644
--- a/block/backup.c
+++ b/block/backup.c
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
                   BlockCompletionFunc *cb, void *opaque,
                   JobTxn *txn, Error **errp)
 {
-    int64_t len;
+    int64_t len, target_len;
     BackupBlockJob *job = NULL;
     int64_t cluster_size;
     BdrvRequestFlags write_flags;
@@ -XXX,XX +XXX,XX @@ BlockJob *backup_job_create(const char *job_id, BlockDriverState *bs,
         goto error;
     }
 
+    target_len = bdrv_getlength(target);
+    if (target_len < 0) {
+        error_setg_errno(errp, -target_len, "Unable to get length for '%s'",
+                         bdrv_get_device_or_node_name(bs));
+        goto error;
+    }
+
+    if (target_len != len) {
+        error_setg(errp, "Source and target image have different sizes");
+        goto error;
+    }
+
     cluster_size = backup_calculate_cluster_size(target, errp);
     if (cluster_size < 0) {
         goto error;
-- 
2.25.3

This tests that the backup job catches situations where the target node
has a different size than the source node. It must also forbid resize
operations when the job is already running.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200430142755.315494-5-kwolf@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/055     | 41 ++++++++++++++++++++++++++++++++++++--
 tests/qemu-iotests/055.out |  4 ++--
 2 files changed, 41 insertions(+), 4 deletions(-)

diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/055
+++ b/tests/qemu-iotests/055
@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
     def setUp(self):
         qemu_img('create', '-f', iotests.imgfmt, blockdev_target_img, str(image_len))
 
-        self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
-        self.vm.add_drive(blockdev_target_img, interface="none")
+        self.vm = iotests.VM()
+        self.vm.add_drive('blkdebug::' + test_img, 'node-name=source')
+        self.vm.add_drive(blockdev_target_img, 'node-name=target',
+                          interface="none")
         if iotests.qemu_default_machine == 'pc':
             self.vm.add_drive(None, 'media=cdrom', 'ide')
         self.vm.launch()
@@ -XXX,XX +XXX,XX @@ class TestSingleDrive(iotests.QMPTestCase):
     def test_pause_blockdev_backup(self):
         self.do_test_pause('blockdev-backup', 'drive1', blockdev_target_img)
 
+    def do_test_resize_blockdev_backup(self, device, node):
+        def pre_finalize():
+            result = self.vm.qmp('block_resize', device=device, size=65536)
+            self.assert_qmp(result, 'error/class', 'GenericError')
+
+            result = self.vm.qmp('block_resize', node_name=node, size=65536)
+            self.assert_qmp(result, 'error/class', 'GenericError')
+
+        result = self.vm.qmp('blockdev-backup', job_id='job0', device='drive0',
+                             target='drive1', sync='full', auto_finalize=False,
+                             auto_dismiss=False)
+        self.assert_qmp(result, 'return', {})
+
+        self.vm.run_job('job0', auto_finalize=False, pre_finalize=pre_finalize)
+
+    def test_source_resize_blockdev_backup(self):
+        self.do_test_resize_blockdev_backup('drive0', 'source')
+
+    def test_target_resize_blockdev_backup(self):
+        self.do_test_resize_blockdev_backup('drive1', 'target')
+
+    def do_test_target_size(self, size):
+        result = self.vm.qmp('block_resize', device='drive1', size=size)
+        self.assert_qmp(result, 'return', {})
+
+        result = self.vm.qmp('blockdev-backup', job_id='job0', device='drive0',
+                             target='drive1', sync='full')
+        self.assert_qmp(result, 'error/class', 'GenericError')
+
+    def test_small_target(self):
+        self.do_test_target_size(image_len // 2)
+
+    def test_large_target(self):
+        self.do_test_target_size(image_len * 2)
+
     def test_medium_not_found(self):
         if iotests.qemu_default_machine != 'pc':
             return
diff --git a/tests/qemu-iotests/055.out b/tests/qemu-iotests/055.out
index XXXXXXX..XXXXXXX 100644
--- a/tests/qemu-iotests/055.out
+++ b/tests/qemu-iotests/055.out
@@ -XXX,XX +XXX,XX @@
-....................................
+........................................
 ----------------------------------------------------------------------
-Ran 36 tests
+Ran 40 tests
 
 OK
-- 
2.25.3

055 uses the backup block job to create a compressed backup of an
$IMGFMT image with both qcow2 and vmdk targets. However, cluster
allocation in vmdk is very slow because it flushes the image file after
each L2 update.

There is no reason why we need this level of safety in this test, so
let's disable flushes for vmdk. For the blockdev-backup tests this is
achieved by simply adding the cache.no-flush=on to the drive_add() for
the target. For drive-backup, the caching flags are copied from the
source node, so we'll also add the flag to the source node, even though
it is not vmdk.

This can make the test run significantly faster (though it doesn't make
a difference on tmpfs). In my usual setup it goes from ~45s to ~15s.

Signed-off-by: Kevin Wolf <kwolf@redhat.com>
Message-Id: <20200505064618.16267-1-kwolf@redhat.com>
Reviewed-by: Eric Blake <eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 tests/qemu-iotests/055 | 11 +++++++----
 1 file changed, 7 insertions(+), 4 deletions(-)

diff --git a/tests/qemu-iotests/055 b/tests/qemu-iotests/055
index XXXXXXX..XXXXXXX 100755
--- a/tests/qemu-iotests/055
+++ b/tests/qemu-iotests/055
@@ -XXX,XX +XXX,XX @@ class TestSingleTransaction(iotests.QMPTestCase):
 
 class TestCompressedToQcow2(iotests.QMPTestCase):
     image_len = 64 * 1024 * 1024 # MB
-    target_fmt = {'type': 'qcow2', 'args': ()}
+    target_fmt = {'type': 'qcow2', 'args': (), 'drive-opts': ''}
 
     def tearDown(self):
         self.vm.shutdown()
@@ -XXX,XX +XXX,XX @@ class TestCompressedToQcow2(iotests.QMPTestCase):
             pass
 
     def do_prepare_drives(self, attach_target):
-        self.vm = iotests.VM().add_drive('blkdebug::' + test_img)
+        self.vm = iotests.VM().add_drive('blkdebug::' + test_img,
+                                         opts=self.target_fmt['drive-opts'])
 
         qemu_img('create', '-f', self.target_fmt['type'], blockdev_target_img,
                  str(self.image_len), *self.target_fmt['args'])
         if attach_target:
             self.vm.add_drive(blockdev_target_img,
                               img_format=self.target_fmt['type'],
-                              interface="none")
+                              interface="none",
+                              opts=self.target_fmt['drive-opts'])
 
         self.vm.launch()
 
@@ -XXX,XX +XXX,XX @@ class TestCompressedToQcow2(iotests.QMPTestCase):
 
 
 class TestCompressedToVmdk(TestCompressedToQcow2):
-    target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized')}
+    target_fmt = {'type': 'vmdk', 'args': ('-o', 'subformat=streamOptimized'),
+                  'drive-opts': 'cache.no-flush=on'}
 
     @iotests.skip_if_unsupported(['vmdk'])
     def setUp(self):
-- 
2.25.3

From: Max Reitz <mreitz@redhat.com>

Calling bdrv_getlength() to get the pre-truncate file size will not
really work on block devices, because they have always the same length,
and trying to write beyond it will fail with a rather cryptic error
message.

Instead, we should use qcow2_get_last_cluster() and bdrv_getlength()
only as a fallback.

Before this patch:
$ truncate -s 1G test.img
$ sudo losetup -f --show test.img
/dev/loop0
$ sudo qemu-img create -f qcow2 -o preallocation=full /dev/loop0 64M
Formatting '/dev/loop0', fmt=qcow2 size=67108864 cluster_size=65536
preallocation=full lazy_refcounts=off refcount_bits=16
qemu-img: /dev/loop0: Could not resize image: Failed to resize refcount
structures: No space left on device

With this patch:
$ sudo qemu-img create -f qcow2 -o preallocation=full /dev/loop0 64M
Formatting '/dev/loop0', fmt=qcow2 size=67108864 cluster_size=65536
preallocation=full lazy_refcounts=off refcount_bits=16
qemu-img: /dev/loop0: Could not resize image: Failed to resize
underlying file: Preallocation mode 'full' unsupported for this
non-regular file

So as you can see, it still fails, but now the problem is missing
support on the block device level, so we at least get a better error
message.

Note that we cannot preallocate block devices on truncate by design,
because we do not know what area to preallocate.  Their length is always
the same, the truncate operation does not change it.

Signed-off-by: Max Reitz <mreitz@redhat.com>
Message-Id: <20200505141801.1096763-1-mreitz@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/qcow2.c | 10 ++++++++--
 1 file changed, 8 insertions(+), 2 deletions(-)

diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
     {
         int64_t allocation_start, host_offset, guest_offset;
         int64_t clusters_allocated;
-        int64_t old_file_size, new_file_size;
+        int64_t old_file_size, last_cluster, new_file_size;
         uint64_t nb_new_data_clusters, nb_new_l2_tables;
 
         /* With a data file, preallocation means just allocating the metadata
@@ -XXX,XX +XXX,XX @@ static int coroutine_fn qcow2_co_truncate(BlockDriverState *bs, int64_t offset,
             ret = old_file_size;
             goto fail;
         }
-        old_file_size = ROUND_UP(old_file_size, s->cluster_size);
+
+        last_cluster = qcow2_get_last_cluster(bs, old_file_size);
+        if (last_cluster >= 0) {
+            old_file_size = (last_cluster + 1) * s->cluster_size;
+        } else {
+            old_file_size = ROUND_UP(old_file_size, s->cluster_size);
+        }
 
         nb_new_data_clusters = DIV_ROUND_UP(offset - old_length,
                                             s->cluster_size);
-- 
2.25.3

From: Eric Blake <eblake@redhat.com>

block.c already defaults to 0 if we don't provide a callback; there's
no need to write a callback that always fails.

Signed-off-by: Eric Blake <eblake@redhat.com>
Reviewed-by: Vladimir Sementsov-Ogievskiy <vsementsov@virtuozzo.com>
Reviewed-by: Alberto Garcia <berto@igalia.com>
Message-Id: <20200428202905.770727-2-eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/gluster.c | 14 --------------
 1 file changed, 14 deletions(-)

diff --git a/block/gluster.c b/block/gluster.c
index XXXXXXX..XXXXXXX 100644
--- a/block/gluster.c
+++ b/block/gluster.c
@@ -XXX,XX +XXX,XX @@ static int64_t qemu_gluster_allocated_file_size(BlockDriverState *bs)
     }
 }
 
-static int qemu_gluster_has_zero_init(BlockDriverState *bs)
-{
-    /* GlusterFS volume could be backed by a block device */
-    return 0;
-}
-
 /*
  * Find allocation range in @bs around offset @start.
  * May change underlying file descriptor's file offset.
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster = {
     .bdrv_co_readv                = qemu_gluster_co_readv,
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_tcp = {
     .bdrv_co_readv                = qemu_gluster_co_readv,
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_unix = {
     .bdrv_co_readv                = qemu_gluster_co_readv,
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_gluster_rdma = {
     .bdrv_co_readv                = qemu_gluster_co_readv,
     .bdrv_co_writev               = qemu_gluster_co_writev,
     .bdrv_co_flush_to_disk        = qemu_gluster_co_flush_to_disk,
-    .bdrv_has_zero_init           = qemu_gluster_has_zero_init,
-    .bdrv_has_zero_init_truncate  = qemu_gluster_has_zero_init,
 #ifdef CONFIG_GLUSTERFS_DISCARD
     .bdrv_co_pdiscard             = qemu_gluster_co_pdiscard,
 #endif
-- 
2.25.3

From: Eric Blake <eblake@redhat.com>

When using bdrv_file, .bdrv_has_zero_init_truncate always returns 1;
therefore, we can behave just like file-posix, and always implement
BDRV_REQ_ZERO_WRITE by ignoring it since the OS gives it to us for
free (note that file-posix.c had to use an 'if' because it shared code
between regular files and block devices, but in file-win32.c,
bdrv_host_device uses a separate .bdrv_file_open).

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200428202905.770727-3-eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/file-win32.c | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/block/file-win32.c b/block/file-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-win32.c
+++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ static int raw_open(BlockDriverState *bs, QDict *options, int flags,
         win32_aio_attach_aio_context(s->aio, bdrv_get_aio_context(bs));
     }
 
+    /* When extending regular files, we get zeros from the OS */
+    bs->supported_truncate_flags = BDRV_REQ_ZERO_WRITE;
+
     ret = 0;
 fail:
     qemu_opts_del(opts);
-- 
2.25.3

From: Eric Blake <eblake@redhat.com>

The parallels driver tries to use truncation for image growth, but can
only do so when reads are guaranteed as zero.  Now that we have a way
to request zero contents from truncation, we can defer the decision to
actual allocation attempts rather than up front, reducing the number
of places that still use bdrv_has_zero_init_truncate.

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200428202905.770727-8-eblake@redhat.com>
Reviewed-by: Denis V. Lunev <den@openvz.org>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/parallels.c | 25 ++++++++++++++++---------
 1 file changed, 16 insertions(+), 9 deletions(-)

diff --git a/block/parallels.c b/block/parallels.c
index XXXXXXX..XXXXXXX 100644
--- a/block/parallels.c
+++ b/block/parallels.c
@@ -XXX,XX +XXX,XX @@ static int64_t block_status(BDRVParallelsState *s, int64_t sector_num,
 static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
                                  int nb_sectors, int *pnum)
 {
-    int ret;
+    int ret = 0;
     BDRVParallelsState *s = bs->opaque;
     int64_t pos, space, idx, to_allocate, i, len;
 
@@ -XXX,XX +XXX,XX @@ static int64_t allocate_clusters(BlockDriverState *bs, int64_t sector_num,
     }
     if (s->data_end + space > (len >> BDRV_SECTOR_BITS)) {
         space += s->prealloc_size;
+        /*
+         * We require the expanded size to read back as zero. If the
+         * user permitted truncation, we try that; but if it fails, we
+         * force the safer-but-slower fallocate.
+         */
+        if (s->prealloc_mode == PRL_PREALLOC_MODE_TRUNCATE) {
+            ret = bdrv_truncate(bs->file,
+                                (s->data_end + space) << BDRV_SECTOR_BITS,
+                                false, PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE,
+                                NULL);
+            if (ret == -ENOTSUP) {
+                s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
+            }
+        }
         if (s->prealloc_mode == PRL_PREALLOC_MODE_FALLOCATE) {
             ret = bdrv_pwrite_zeroes(bs->file,
                                      s->data_end << BDRV_SECTOR_BITS,
                                      space << BDRV_SECTOR_BITS, 0);
-        } else {
-            ret = bdrv_truncate(bs->file,
-                                (s->data_end + space) << BDRV_SECTOR_BITS,
-                                false, PREALLOC_MODE_OFF, 0, NULL);
         }
         if (ret < 0) {
             return ret;
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         qemu_opt_get_size_del(opts, PARALLELS_OPT_PREALLOC_SIZE, 0);
     s->prealloc_size = MAX(s->tracks, s->prealloc_size >> BDRV_SECTOR_BITS);
     buf = qemu_opt_get_del(opts, PARALLELS_OPT_PREALLOC_MODE);
+    /* prealloc_mode can be downgraded later during allocate_clusters */
     s->prealloc_mode = qapi_enum_parse(&prealloc_mode_lookup, buf,
                                        PRL_PREALLOC_MODE_FALLOCATE,
                                        &local_err);
@@ -XXX,XX +XXX,XX @@ static int parallels_open(BlockDriverState *bs, QDict *options, int flags,
         goto fail_options;
     }
 
-    if (!bdrv_has_zero_init_truncate(bs->file->bs)) {
-        s->prealloc_mode = PRL_PREALLOC_MODE_FALLOCATE;
-    }
-
     if ((flags & BDRV_O_RDWR) && !(flags & BDRV_O_INACTIVE)) {
         s->header->inuse = cpu_to_le32(HEADER_INUSE_MAGIC);
         ret = parallels_update_header(bs);
-- 
2.25.3

From: Eric Blake <eblake@redhat.com>

The vhdx driver uses truncation for image growth, with a special case
for blocks that already read as zero but which are only being
partially written.  But with a bit of rearranging, it's just as easy
to defer the decision on whether truncation resulted in zeroes to the
actual allocation attempt, reducing the number of places that still
use bdrv_has_zero_init_truncate.

Signed-off-by: Eric Blake <eblake@redhat.com>
Message-Id: <20200428202905.770727-9-eblake@redhat.com>
Signed-off-by: Kevin Wolf <kwolf@redhat.com>
---
 block/vhdx.c | 89 ++++++++++++++++++++++++++++++----------------------
 1 file changed, 51 insertions(+), 38 deletions(-)

diff --git a/block/vhdx.c b/block/vhdx.c
index XXXXXXX..XXXXXXX 100644
--- a/block/vhdx.c
+++ b/block/vhdx.c
@@ -XXX,XX +XXX,XX @@ exit:
 /*
  * Allocate a new payload block at the end of the file.
  *
- * Allocation will happen at 1MB alignment inside the file
+ * Allocation will happen at 1MB alignment inside the file.
+ *
+ * If @need_zero is set on entry but not cleared on return, then truncation
+ * could not guarantee that the new portion reads as zero, and the caller
+ * will take care of it instead.
  *
  * Returns the file offset start of the new payload block
  */
 static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
-                                    uint64_t *new_offset)
+                               uint64_t *new_offset, bool *need_zero)
 {
     int64_t current_len;
 
@@ -XXX,XX +XXX,XX @@ static int vhdx_allocate_block(BlockDriverState *bs, BDRVVHDXState *s,
         return -EINVAL;
     }
 
+    if (*need_zero) {
+        int ret;
+
+        ret = bdrv_truncate(bs->file, *new_offset + s->block_size, false,
+                            PREALLOC_MODE_OFF, BDRV_REQ_ZERO_WRITE, NULL);
+        if (ret != -ENOTSUP) {
+            *need_zero = false;
+            return ret;
+        }
+    }
+
     return bdrv_truncate(bs->file, *new_offset + s->block_size, false,
                          PREALLOC_MODE_OFF, 0, NULL);
 }
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
                 /* in this case, we need to preserve zero writes for
                  * data that is not part of this write, so we must pad
                  * the rest of the buffer to zeroes */
-
-                /* if we are on a posix system with ftruncate() that extends
-                 * a file, then it is zero-filled for us.  On Win32, the raw
-                 * layer uses SetFilePointer and SetFileEnd, which does not
-                 * zero fill AFAIK */
-
-                /* Queue another write of zero buffers if the underlying file
-                 * does not zero-fill on file extension */
-
-                if (bdrv_has_zero_init_truncate(bs->file->bs) == 0) {
-                    use_zero_buffers = true;
-
+                use_zero_buffers = true;
+                /* fall through */
+            case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */
+            case PAYLOAD_BLOCK_UNMAPPED:
+            case PAYLOAD_BLOCK_UNMAPPED_v095:
+            case PAYLOAD_BLOCK_UNDEFINED:
+                bat_prior_offset = sinfo.file_offset;
+                ret = vhdx_allocate_block(bs, s, &sinfo.file_offset,
+                                          &use_zero_buffers);
+                if (ret < 0) {
+                    goto exit;
+                }
+                /*
+                 * once we support differencing files, this may also be
+                 * partially present
+                 */
+                /* update block state to the newly specified state */
+                vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
+                                            &bat_entry_offset,
+                                            PAYLOAD_BLOCK_FULLY_PRESENT);
+                bat_update = true;
+                /*
+                 * Since we just allocated a block, file_offset is the
+                 * beginning of the payload block. It needs to be the
+                 * write address, which includes the offset into the
+                 * block, unless the entire block needs to read as
+                 * zeroes but truncation was not able to provide them,
+                 * in which case we need to fill in the rest.
+                 */
+                if (!use_zero_buffers) {
+                    sinfo.file_offset += sinfo.block_offset;
+                } else {
                     /* zero fill the front, if any */
                     if (sinfo.block_offset) {
                         iov1.iov_len = sinfo.block_offset;
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
                     }
 
                     /* our actual data */
-                    qemu_iovec_concat(&hd_qiov, qiov,  bytes_done,
+                    qemu_iovec_concat(&hd_qiov, qiov, bytes_done,
                                       sinfo.bytes_avail);
 
                     /* zero fill the back, if any */
@@ -XXX,XX +XXX,XX @@ static coroutine_fn int vhdx_co_writev(BlockDriverState *bs, int64_t sector_num,
                         sectors_to_write += iov2.iov_len >> BDRV_SECTOR_BITS;
                     }
                 }
-                /* fall through */
-            case PAYLOAD_BLOCK_NOT_PRESENT: /* fall through */
-            case PAYLOAD_BLOCK_UNMAPPED:
-            case PAYLOAD_BLOCK_UNMAPPED_v095:
-            case PAYLOAD_BLOCK_UNDEFINED:
-                bat_prior_offset = sinfo.file_offset;
-                ret = vhdx_allocate_block(bs, s, &sinfo.file_offset);
-                if (ret < 0) {
-                    goto exit;
-                }
-                /* once we support differencing files, this may also be
-                 * partially present */
-                /* update block state to the newly specified state */
-                vhdx_update_bat_table_entry(bs, s, &sinfo, &bat_entry,
-                                            &bat_entry_offset,
-                                            PAYLOAD_BLOCK_FULLY_PRESENT);
-                bat_update = true;
-                /* since we just allocated a block, file_offset is the
-                 * beginning of the payload block. It needs to be the
-                 * write address, which includes the offset into the block */
-                if (!use_zero_buffers) {
-                    sinfo.file_offset += sinfo.block_offset;
-                }
+
                 /* fall through */
             case PAYLOAD_BLOCK_FULLY_PRESENT:
                 /* if the file offset address is in the header zone,
-- 
2.25.3

From: Eric Blake <eblake@redhat.com>

Now that there are no clients of bdrv_has_zero_init_truncate, none of
the drivers need to worry about providing it.

What's more, this eliminates a source of some confusion: a literal
reading of the documentation as written in ceaca56f and implemented in
commit 1dcaf527 claims that a driver which returns 0 for
bdrv_has_zero_init_truncate() must not return 1 for
bdrv_has_zero_init(); this condition was violated for parallels, qcow,
and sometimes for vdi, although in practice it did not matter since
those drivers also lacked .bdrv_co_truncate.

diff --git a/include/block/block.h b/include/block/block.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block.h
+++ b/include/block/block.h
@@ -XXX,XX +XXX,XX @@ int bdrv_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
 int bdrv_co_pdiscard(BdrvChild *child, int64_t offset, int64_t bytes);
 int bdrv_has_zero_init_1(BlockDriverState *bs);
 int bdrv_has_zero_init(BlockDriverState *bs);
-int bdrv_has_zero_init_truncate(BlockDriverState *bs);
 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs);
 bool bdrv_can_write_zeroes_with_unmap(BlockDriverState *bs);
 int bdrv_block_status(BlockDriverState *bs, int64_t offset,
diff --git a/include/block/block_int.h b/include/block/block_int.h
index XXXXXXX..XXXXXXX 100644
--- a/include/block/block_int.h
+++ b/include/block/block_int.h
@@ -XXX,XX +XXX,XX @@ struct BlockDriver {
     /*
      * Returns 1 if newly created images are guaranteed to contain only
      * zeros, 0 otherwise.
-     * Must return 0 if .bdrv_has_zero_init_truncate() returns 0.
      */
     int (*bdrv_has_zero_init)(BlockDriverState *bs);
 
-    /*
-     * Returns 1 if new areas added by growing the image with
-     * PREALLOC_MODE_OFF contain only zeros, 0 otherwise.
-     */
-    int (*bdrv_has_zero_init_truncate)(BlockDriverState *bs);
-
     /* Remove fd handlers, timers, and other event loop callbacks so the event
      * loop is no longer in use.  Called with no in-flight requests and in
      * depth-first traversal order with parents before child nodes.
diff --git a/block.c b/block.c
index XXXXXXX..XXXXXXX 100644
--- a/block.c
+++ b/block.c
@@ -XXX,XX +XXX,XX @@ int bdrv_has_zero_init(BlockDriverState *bs)
     return 0;
 }
 
-int bdrv_has_zero_init_truncate(BlockDriverState *bs)
-{
-    if (!bs->drv) {
-        return 0;
-    }
-
-    if (bs->backing) {
-        /* Depends on the backing image length, but better safe than sorry */
-        return 0;
-    }
-    if (bs->drv->bdrv_has_zero_init_truncate) {
-        return bs->drv->bdrv_has_zero_init_truncate(bs);
-    }
-    if (bs->file && bs->drv->is_filter) {
-        return bdrv_has_zero_init_truncate(bs->file->bs);
-    }
-
-    /* safe default */
-    return 0;
-}
-
 bool bdrv_unallocated_blocks_are_zero(BlockDriverState *bs)
 {
     BlockDriverInfo bdi;
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 @@ BlockDriver bdrv_file = {
     .bdrv_co_create = raw_co_create,
     .bdrv_co_create_opts = raw_co_create_opts,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
-    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status = raw_co_block_status,
     .bdrv_co_invalidate_cache = raw_co_invalidate_cache,
     .bdrv_co_pwrite_zeroes = raw_co_pwrite_zeroes,
diff --git a/block/file-win32.c b/block/file-win32.c
index XXXXXXX..XXXXXXX 100644
--- a/block/file-win32.c
+++ b/block/file-win32.c
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_file = {
     .bdrv_close         = raw_close,
     .bdrv_co_create_opts = raw_co_create_opts,
     .bdrv_has_zero_init = bdrv_has_zero_init_1,
-    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
 
     .bdrv_aio_preadv    = raw_aio_preadv,
     .bdrv_aio_pwritev   = raw_aio_pwritev,
diff --git a/block/nfs.c b/block/nfs.c
index XXXXXXX..XXXXXXX 100644
--- a/block/nfs.c
+++ b/block/nfs.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_nfs = {
     .create_opts                    = &nfs_create_opts,
 
     .bdrv_has_zero_init             = nfs_has_zero_init,
-    .bdrv_has_zero_init_truncate    = nfs_has_zero_init,
     .bdrv_get_allocated_file_size   = nfs_get_allocated_file_size,
     .bdrv_co_truncate               = nfs_file_co_truncate,
 
diff --git a/block/qcow2.c b/block/qcow2.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qcow2.c
+++ b/block/qcow2.c
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_qcow2 = {
     .bdrv_co_create_opts  = qcow2_co_create_opts,
     .bdrv_co_create       = qcow2_co_create,
     .bdrv_has_zero_init   = qcow2_has_zero_init,
-    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status = qcow2_co_block_status,
 
     .bdrv_co_preadv_part    = qcow2_co_preadv_part,
diff --git a/block/qed.c b/block/qed.c
index XXXXXXX..XXXXXXX 100644
--- a/block/qed.c
+++ b/block/qed.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_qed = {
     .bdrv_co_create           = bdrv_qed_co_create,
     .bdrv_co_create_opts      = bdrv_qed_co_create_opts,
     .bdrv_has_zero_init       = bdrv_has_zero_init_1,
-    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_co_block_status     = bdrv_qed_co_block_status,
     .bdrv_co_readv            = bdrv_qed_co_readv,
     .bdrv_co_writev           = bdrv_qed_co_writev,
diff --git a/block/raw-format.c b/block/raw-format.c
index XXXXXXX..XXXXXXX 100644
--- a/block/raw-format.c
+++ b/block/raw-format.c
@@ -XXX,XX +XXX,XX @@ static int raw_has_zero_init(BlockDriverState *bs)
     return bdrv_has_zero_init(bs->file->bs);
 }
 
-static int raw_has_zero_init_truncate(BlockDriverState *bs)
-{
-    return bdrv_has_zero_init_truncate(bs->file->bs);
-}
-
 static int coroutine_fn raw_co_create_opts(BlockDriver *drv,
                                            const char *filename,
                                            QemuOpts *opts,
@@ -XXX,XX +XXX,XX @@ BlockDriver bdrv_raw = {
     .bdrv_co_ioctl        = &raw_co_ioctl,
     .create_opts          = &raw_create_opts,
     .bdrv_has_zero_init   = &raw_has_zero_init,
-    .bdrv_has_zero_init_truncate = &raw_has_zero_init_truncate,
     .strong_runtime_opts  = raw_strong_runtime_opts,
     .mutable_opts         = mutable_opts,
 };
diff --git a/block/rbd.c b/block/rbd.c
index XXXXXXX..XXXXXXX 100644
--- a/block/rbd.c
+++ b/block/rbd.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_rbd = {
     .bdrv_co_create         = qemu_rbd_co_create,
     .bdrv_co_create_opts    = qemu_rbd_co_create_opts,
     .bdrv_has_zero_init     = bdrv_has_zero_init_1,
-    .bdrv_has_zero_init_truncate = bdrv_has_zero_init_1,
     .bdrv_get_info          = qemu_rbd_getinfo,
     .create_opts            = &qemu_rbd_create_opts,
     .bdrv_getlength         = qemu_rbd_getlength,
diff --git a/block/sheepdog.c b/block/sheepdog.c
index XXXXXXX..XXXXXXX 100644
--- a/block/sheepdog.c
+++ b/block/sheepdog.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog = {
     .bdrv_co_create               = sd_co_create,
     .bdrv_co_create_opts          = sd_co_create_opts,
     .bdrv_has_zero_init           = bdrv_has_zero_init_1,
-    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
     .bdrv_getlength               = sd_getlength,
     .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
     .bdrv_co_truncate             = sd_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog_tcp = {
     .bdrv_co_create               = sd_co_create,
     .bdrv_co_create_opts          = sd_co_create_opts,
     .bdrv_has_zero_init           = bdrv_has_zero_init_1,
-    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
     .bdrv_getlength               = sd_getlength,
     .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
     .bdrv_co_truncate             = sd_co_truncate,
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_sheepdog_unix = {
     .bdrv_co_create               = sd_co_create,
     .bdrv_co_create_opts          = sd_co_create_opts,
     .bdrv_has_zero_init           = bdrv_has_zero_init_1,
-    .bdrv_has_zero_init_truncate  = bdrv_has_zero_init_1,
     .bdrv_getlength               = sd_getlength,
     .bdrv_get_allocated_file_size = sd_get_allocated_file_size,
     .bdrv_co_truncate             = sd_co_truncate,
diff --git a/block/ssh.c b/block/ssh.c
index XXXXXXX..XXXXXXX 100644
--- a/block/ssh.c
+++ b/block/ssh.c
@@ -XXX,XX +XXX,XX @@ static BlockDriver bdrv_ssh = {
     .bdrv_co_create_opts          = ssh_co_create_opts,
     .bdrv_close                   = ssh_close,
     .bdrv_has_zero_init           = ssh_has_zero_init,
-    .bdrv_has_zero_init_truncate  = ssh_has_zero_init,
     .bdrv_co_readv                = ssh_co_readv,
     .bdrv_co_writev               = ssh_co_writev,
     .bdrv_getlength               = ssh_getlength,
-- 
2.25.3