xref: /qemu/tests/qemu-iotests/tests/mirror-change-copy-mode (revision 900e7d41)

#!/usr/bin/env python3
# group: rw
#
# Test for changing mirror copy mode from background to active
#
# Copyright (C) 2023 Proxmox Server Solutions GmbH
#
# 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/>.
#

import os
import time

import iotests
from iotests import qemu_img, QemuStorageDaemon

iops_target = 8
iops_source = iops_target * 2
image_size = 1 * 1024 * 1024
source_img = os.path.join(iotests.test_dir, 'source.' + iotests.imgfmt)
target_img = os.path.join(iotests.test_dir, 'target.' + iotests.imgfmt)
nbd_sock = os.path.join(iotests.sock_dir, 'nbd.sock')

class TestMirrorChangeCopyMode(iotests.QMPTestCase):

    def setUp(self):
        qemu_img('create', '-f', iotests.imgfmt, source_img, str(image_size))
        qemu_img('create', '-f', iotests.imgfmt, target_img, str(image_size))

        self.qsd = QemuStorageDaemon('--nbd-server',
                                     f'addr.type=unix,addr.path={nbd_sock}',
                                     qmp=True)

        self.qsd.cmd('object-add', {
            'qom-type': 'throttle-group',
            'id': 'thrgr-target',
            'limits': {
                'iops-write': iops_target,
                'iops-write-max': iops_target
            }
        })

        self.qsd.cmd('blockdev-add', {
            'node-name': 'target',
            'driver': 'throttle',
            'throttle-group': 'thrgr-target',
            'file': {
                'driver': iotests.imgfmt,
                'file': {
                    'driver': 'file',
                    'filename': target_img
                }
            }
        })

        self.qsd.cmd('block-export-add', {
            'id': 'exp0',
            'type': 'nbd',
            'node-name': 'target',
            'writable': True
        })

        self.vm = iotests.VM()
        self.vm.add_args('-drive',
                         f'file={source_img},if=none,format={iotests.imgfmt},'
                         f'iops_wr={iops_source},'
                         f'iops_wr_max={iops_source},'
                         'id=source')
        self.vm.launch()

        self.vm.cmd('blockdev-add', {
            'node-name': 'target',
            'driver': 'nbd',
            'export': 'target',
            'server': {
                'type': 'unix',
                'path': nbd_sock
            }
        })


    def tearDown(self):
        self.vm.shutdown()
        self.qsd.stop()
        self.check_qemu_io_errors()
        self.check_images_identical()
        os.remove(source_img)
        os.remove(target_img)

    # Once the VM is shut down we can parse the log and see if qemu-io ran
    # without errors.
    def check_qemu_io_errors(self):
        self.assertFalse(self.vm.is_running())
        log = self.vm.get_log()
        for line in log.split("\n"):
            assert not line.startswith("Pattern verification failed")

    def check_images_identical(self):
        qemu_img('compare', '-f', iotests.imgfmt, source_img, target_img)

    def start_mirror(self):
        self.vm.cmd('blockdev-mirror',
                    job_id='mirror',
                    device='source',
                    target='target',
                    filter_node_name='mirror-top',
                    sync='full',
                    copy_mode='background')

    def test_background_to_active(self):
        self.vm.hmp_qemu_io('source', f'write 0 {image_size}')
        self.vm.hmp_qemu_io('target', f'write 0 {image_size}')

        self.start_mirror()

        result = self.vm.cmd('query-block-jobs')
        assert not result[0]['actively-synced']

        self.vm.event_wait('BLOCK_JOB_READY')

        result = self.vm.cmd('query-block-jobs')
        assert not result[0]['actively-synced']

        # Start some background requests.
        reqs = 4 * iops_source
        req_size = image_size // reqs
        for i in range(0, reqs):
            req = f'aio_write -P 7 {req_size * i} {req_size}'
            self.vm.hmp_qemu_io('source', req)

        # Wait for the first few requests.
        time.sleep(1)
        self.vm.qtest(f'clock_step {1 * 1000 * 1000 * 1000}')

        result = self.vm.cmd('query-block-jobs')
        # There should've been new requests.
        assert result[0]['len'] > image_size
        # To verify later that not all requests were completed at this point.
        len_before_change = result[0]['len']

        # Change the copy mode while requests are happening.
        self.vm.cmd('block-job-change',
                    id='mirror',
                    type='mirror',
                    copy_mode='write-blocking')

        # Wait until image is actively synced.
        while True:
            time.sleep(0.1)
            self.vm.qtest(f'clock_step {100 * 1000 * 1000}')
            result = self.vm.cmd('query-block-jobs')
            if result[0]['actively-synced']:
                break

        # Because of throttling, not all requests should have been completed
        # above.
        result = self.vm.cmd('query-block-jobs')
        assert result[0]['len'] > len_before_change

        # Issue enough requests for a few seconds only touching the first half
        # of the image.
        reqs = 4 * iops_target
        req_size = image_size // 2 // reqs
        for i in range(0, reqs):
            req = f'aio_write -P 19 {req_size * i} {req_size}'
            self.vm.hmp_qemu_io('source', req)

        # Now issue a synchronous write in the second half of the image and
        # immediately verify that it was written to the target too. This would
        # fail without switching the copy mode. Note that this only produces a
        # log line and the actual checking happens during tearDown().
        req_args = f'-P 37 {3 * (image_size // 4)} {req_size}'
        self.vm.hmp_qemu_io('source', f'write {req_args}')
        self.vm.hmp_qemu_io('target', f'read {req_args}')

        self.vm.cmd('block-job-cancel', device='mirror')
        while len(self.vm.cmd('query-block-jobs')) > 0:
            time.sleep(0.1)

if __name__ == '__main__':
    iotests.main(supported_fmts=['qcow2', 'raw'],
                 supported_protocols=['file'])