sts-libs 2.4.0__tar.gz → 2.4.2__tar.gz

{sts_libs-2.4.0 → sts_libs-2.4.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: sts-libs
-Version: 2.4.0
+Version: 2.4.2
 Summary: Library for pytest-based Linux storage tests
 Project-URL: Repository, https://gitlab.com/rh-kernel-stqe/sts/
 Author-email: Martin Hoyer <mhoyer@redhat.com>, Filip Suba <fsuba@redhat.com>, Zhaojuan Guo <zguo@redhat.com>, Bruno Goncalves <bgoncalv@redhat.com>, Jakub Krysl <jkrysl@redhat.com>

{sts_libs-2.4.0 → sts_libs-2.4.2}/pyproject.toml

@@ -7,7 +7,7 @@ name = 'sts-libs'
 description = 'Library for pytest-based Linux storage tests'
 readme = 'sts_libs/README.md'
 requires-python = '>=3.12'
-version = "2.4.0"
+version = "2.4.2"
 authors = [
   {name = 'Martin Hoyer', email = 'mhoyer@redhat.com'},
   {name = 'Filip Suba', email = 'fsuba@redhat.com'},

sts_libs-2.4.2/sts_libs/src/sts/fixtures/iscsi_fixtures.py

@@ -0,0 +1,174 @@
+# Copyright: Contributors to the sts project
+# SPDX-License-Identifier: GPL-3.0-or-later
+# pyright: reportUnusedFunction=false
+
+"""iSCSI test fixtures."""
+
+import logging
+from collections.abc import Callable, Generator, Sequence
+from pathlib import Path
+from typing import Any
+
+import pytest
+
+from sts.base import StorageDevice
+from sts.iscsi import setup_and_login
+from sts.iscsi.config import ISCSID_SERVICE_NAME
+from sts.iscsi.node import IscsiNode
+from sts.iscsi.session import IscsiSession
+from sts.multipath import MultipathDevice, MultipathService
+from sts.scsi import ScsiDevice
+from sts.target import BackstoreFileio, Iscsi, IscsiLUN, create_basic_iscsi_target
+from sts.utils import wait_for
+from sts.utils.packages import ensure_installed, log_package_versions
+from sts.utils.system import SystemManager
+
+logger = logging.getLogger(__name__)
+
+ISCSI_DEVICE_SETTLE_TIMEOUT = 60
+ISCSI_DEVICE_POLL_INTERVAL = 0.2
+
+
+def generate_test_iqns(test_name: str) -> tuple[str, str, str]:
+    """Generate (base_iqn, target_iqn, initiator_iqn) from test name."""
+    test_name = test_name.split('[', maxsplit=1)[0]
+    test_name = test_name.replace('_', '-')
+    base_iqn = f'iqn.2024-01.sts.{test_name}'
+    return base_iqn, f'{base_iqn}:target', f'{base_iqn}:initiator'
+
+
+@pytest.fixture(scope='class')
+def _iscsi_test() -> None:
+    """Install iSCSI packages and start iscsid."""
+    assert ensure_installed('iscsi-initiator-utils', 'lsscsi')
+    log_package_versions('iscsi-initiator-utils', 'targetcli')
+
+    system = SystemManager()
+    assert system.service_start(ISCSID_SERVICE_NAME), 'Failed to start iscsid'
+
+
+@pytest.fixture(scope='class')
+def iscsi_localhost_test(request: pytest.FixtureRequest, _iscsi_test: None) -> Generator[str, None, None]:
+    """Set up and tear down a local iSCSI target environment. Yields target IQN."""
+    assert ensure_installed('targetcli')
+
+    test_name = str(request.node.name)  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+    _, target_iqn, _ = generate_test_iqns(test_name)
+
+    target = Iscsi(target_wwn=target_iqn)
+    for session in IscsiSession.get_by_target(target_iqn):
+        session.logout()
+    target.delete_target()
+
+    yield target_iqn
+
+    for session in IscsiSession.get_by_target(target_iqn):
+        session.logout()
+    target.delete_target()
+
+
+def _get_target_device_paths(target_iqn: str) -> list[Path]:
+    """Return running SCSI disks belonging to an active target session."""
+    return [
+        ScsiDevice.DEV_PATH / disk.name
+        for session in IscsiSession.get_by_target(target_iqn)
+        for disk in session.get_disks()
+        if disk.is_running()
+    ]
+
+
+def _device_is_openable(path: Path) -> bool:
+    """Check whether a device node can be opened without issuing data I/O."""
+    try:
+        with path.open('rb'):
+            pass
+    except OSError:
+        return False
+    return True
+
+
+def _target_devices_ready(target_iqn: str, expected_count: int) -> bool:
+    """Check that all expected target disks are running and openable."""
+    paths = _get_target_device_paths(target_iqn)
+    return len(paths) == expected_count and all(_device_is_openable(path) for path in paths)
+
+
+def _find_test_devices(vendor: str = 'LIO-ORG', *, target_iqn: str | None = None) -> list[Path]:
+    """Find test device paths, optionally restricted to one iSCSI target."""
+    if target_iqn is not None:
+        paths = _get_target_device_paths(target_iqn)
+        assert paths, f'No running devices found for iSCSI target {target_iqn}'
+        return paths
+
+    def _extract_paths(devices: Sequence[StorageDevice]) -> list[Path]:
+        return [Path(str(d.path)) for d in devices if d.path]
+
+    mp_service = MultipathService()
+    if mp_service.is_running():
+        devices = MultipathDevice.get_all()
+        if devices:
+            paths = _extract_paths(devices)
+            if paths:
+                return paths
+
+    devices = ScsiDevice.get_by_vendor(vendor)
+    assert devices, f'No {vendor} devices found'
+
+    paths = _extract_paths(devices)
+    assert paths, f'No valid device paths found for {vendor} devices'
+    return paths
+
+
+@pytest.fixture
+def get_test_device() -> Callable[..., list[Path]]:
+    """Return a callable that finds test device paths."""
+    return _find_test_devices
+
+
+@pytest.fixture
+def iscsi_target(request: pytest.FixtureRequest, iscsi_localhost_test: None) -> Generator[IscsiNode, None, None]:  # noqa: ARG001
+    """Create iSCSI target with optional LUNs, log in, yield IscsiNode, log out on exit."""
+    node_name = str(request.node.name)  # pyright: ignore[reportUnknownMemberType, reportUnknownArgumentType]
+    _, target_iqn, initiator_iqn = generate_test_iqns(node_name)
+    params: dict[str, Any] = request.param if hasattr(request, 'param') else {}
+    size: str = params.get('size', '1G')
+    n_luns: int = params.get('n_luns', 1)
+    backstores = [(initiator_iqn.split(':')[1], Path('initiator_backstore_file'))]
+
+    assert create_basic_iscsi_target(
+        target_wwn=target_iqn,
+        initiator_wwn=initiator_iqn,
+        size=size,
+    ), 'Failed to create target'
+
+    if n_luns > 1:
+        test_name = node_name.split('[', maxsplit=1)[0]
+        for i in range(1, n_luns):
+            backstore_name = f'{test_name}_lun{i}'
+            backing_file = Path(f'{backstore_name}_file')
+            backstore = BackstoreFileio(name=backstore_name)
+            backstore.create_backstore(size=size, file_or_dev=str(backing_file))
+            IscsiLUN(target_wwn=target_iqn).create_lun(storage_object=backstore.path)
+            backstores.append((backstore_name, backing_file))
+
+    node = setup_and_login(
+        portal='127.0.0.1:3260',
+        initiator_iqn=initiator_iqn,
+        target_iqn=target_iqn,
+    )
+    try:
+        assert wait_for(
+            lambda: _target_devices_ready(target_iqn, n_luns),
+            timeout=ISCSI_DEVICE_SETTLE_TIMEOUT,
+            poll=ISCSI_DEVICE_POLL_INTERVAL,
+        ), f'Timed out waiting for {n_luns} usable device(s) from iSCSI target {target_iqn}'
+        yield node
+    finally:
+        node.logout()
+        Iscsi(target_wwn=target_iqn).delete_target()
+        for backstore_name, backing_file in reversed(backstores):
+            result = BackstoreFileio(name=backstore_name).delete_backstore()
+            if result.succeeded:
+                backing_file.unlink(missing_ok=True)
+            else:
+                logger.warning(f'Failed to delete iSCSI test backstore {backstore_name}: {result.stderr}')

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/src/sts/fixtures/vdo_fixtures.py

@@ -7,10 +7,17 @@
 from __future__ import annotations
 
 import logging
+from os import getenv
+from pathlib import Path
 from typing import TYPE_CHECKING
 
 import pytest
 
+from sts.loop import LoopDevice
+from sts.lvm.logical_volume import LogicalVolume
+from sts.lvm.physical_volume import PhysicalVolume
+from sts.lvm.volume_group import VolumeGroup
+from sts.models import StsBaseModel
 from sts.utils.cmdline import run
 from sts.utils.errors import ModuleInUseError
 from sts.utils.modules import ModuleManager
@@ -26,6 +33,14 @@ logger = logging.getLogger(__name__)
 VDO_PACKAGE_NAME = 'vdo'
 
 
+class VdoTestContext(StsBaseModel):
+    """Fixture-owned VDO volume used by data-path tests."""
+
+    dev_path: Path
+    vg_name: str
+    lv_name: str
+
+
 @pytest.fixture(scope='class')
 def load_vdo_module(_lvm_test: None) -> str:
     """Install VDO and load the appropriate kernel module (dm-vdo or kvdo).
@@ -82,3 +97,30 @@ def _vdo_test(load_vdo_module: str) -> Generator[None, None, None]:
             logger.debug(f'VDO module {module} could not be unloaded cleanly; continuing.')
     except (ModuleInUseError, RuntimeError):
         logger.debug(f'Ignoring unload error for {module}.')
+
+
+@pytest.fixture
+def vdo_test(_vdo_test: None) -> Generator[VdoTestContext, None, None]:
+    """Create a VDO LV on an owned sparse loop device."""
+    vg_name = getenv('VDO_VG_NAME', 'vdovg')
+    lv_name = getenv('VDO_LV_NAME', 'vdolv')
+    pool_name = getenv('VDO_POOL_NAME', 'vdopool0')
+    loop_device = LoopDevice.create(size_mb=16384, sparse=True)
+    assert loop_device is not None
+    device_path = str(loop_device.device_path)
+    pv = PhysicalVolume(path=device_path)
+    vg = VolumeGroup(name=vg_name, pvs=[device_path])
+    lv = LogicalVolume(name=lv_name, vg=vg_name, pool_name=pool_name)
+
+    try:
+        pv.create().assert_ok()
+        vg.create().assert_ok()
+        lv.create(type='vdo', size='12G', virtualsize='20G', vdosettings='vdo_slab_size_mb=128').assert_ok()
+        assert lv.path is not None
+        yield VdoTestContext(dev_path=Path(lv.path), vg_name=vg_name, lv_name=lv_name)
+    finally:
+        lv.remove()
+        vg.deactivate()
+        vg.remove(force=True)
+        pv.remove()
+        loop_device.remove()

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/src/sts/loop.py

@@ -245,6 +245,10 @@ class LoopDevice(StorageDevice):
         result = run_argv(command)
         if result.failed:
             logger.error('Failed to create image file')
+            try:
+                image_file.unlink(missing_ok=True)
+            except OSError:
+                logger.exception('Failed to clean up incomplete image file')
             return None
 
         return image_file

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/src/sts/pr.py

@@ -72,16 +72,21 @@ class PRDevice(StorageDevice):
         """Wait for udev, validate PR support, optionally register key, and load state.
 
         Raises:
-            DeviceError: If device is not fully ready or does not support
-                persistent reservations.
+            DeviceError: If the device is not ready or its persistent reservation
+                capabilities cannot be verified.
         """
         # Wait for device to be fully available before PR operations
         if not self.wait_udev():
             raise DeviceError(f'Device {self.path} is not fully ready')
 
-        # Validate PR capability
-        if not self.supports_pr:
-            raise DeviceError(f'Device {self.path} does not support persistent reservations')
+        # Validate PR capability while preserving the reason a query failed.
+        if not self.path:
+            raise DeviceError('Cannot check persistent reservation capabilities without a device path')
+        capabilities = self._sg_persist.report_capabilities_result(self.path)
+        if capabilities.failed:
+            detail = capabilities.stderr.strip() or f'exit status {capabilities.rc}'
+            raise DeviceError(f'Could not verify persistent reservation support on {self.path}: {detail}')
+        self._supports_pr = True
 
         # Auto-register key if requested
         if self.auto_register and self.register_key:

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/src/sts/sg3_utils.py

@@ -459,12 +459,16 @@ class SgPersist(Sg3UtilsCommand):
 
     def report_capabilities(self, device: str | Path) -> bool:
         """Check whether a device supports persistent reservation operations."""
+        return self.report_capabilities_result(device).succeeded
+
+    def report_capabilities_result(self, device: str | Path) -> CommandResult:
+        """Query persistent reservation capabilities and preserve failure details."""
         result = self._run_command(self.COMMAND, '--in', '--report-capabilities', str(device))
 
         if not result.succeeded:
             logger.warning(f'Failed to check PR capabilities for {device}: {result.stderr}')
 
-        return result.succeeded
+        return result
 
 
 # =============================================================================

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/src/sts/target.py

@@ -622,9 +622,16 @@ def create_loopback_devices(count: int, block_size: int = 4096) -> list[BlockDev
     # Create each device
     for n in range(count):
         backstore = BackstoreFileio(name=f'{lun_prefix}{n}')
+        backing_file = Path(image_path) / f'{lun_prefix}{n}{suffix}'
+
+        try:
+            backing_file.unlink(missing_ok=True)
+        except OSError as error:
+            msg = f'Failed to remove stale loopback backing file {backing_file}'
+            raise RuntimeError(msg) from error
 
         # Create backstore
-        result = backstore.create_backstore(size=device_size, file_or_dev=f'{image_path}{lun_prefix}{n}{suffix}')
+        result = backstore.create_backstore(size=device_size, file_or_dev=str(backing_file))
         assert result.succeeded, f'Failed to create backstore {n}: {result.stderr}'
 
         # Set block size
@@ -657,6 +664,8 @@ def cleanup_loopback_devices(devices: list[BlockDevice]) -> None:
     # Get configuration from environment variables
     wwn = getenv('TARGET_WWN', 'naa.50014054c1441891')
     lun_prefix = getenv('LUN_PREFIX', 'common-lun-')
+    image_path = getenv('IMAGE_PATH', '/var/tmp/')
+    suffix = '.image'
 
     # Initialize loopback target and LUN
     loopback = Loopback(target_wwn=wwn)
@@ -673,6 +682,13 @@ def cleanup_loopback_devices(devices: list[BlockDevice]) -> None:
         result = backstore.delete_backstore()
         if result.failed:
             logger.warning(f'Failed to delete backstore {n}: {result.stderr}')
+            continue
+
+        backing_file = Path(image_path) / f'{lun_prefix}{n}{suffix}'
+        try:
+            backing_file.unlink(missing_ok=True)
+        except OSError:
+            logger.warning(f'Failed to delete loopback backing file {backing_file}', exc_info=True)
 
     result = loopback.delete_target()
     if result.failed:

sts_libs-2.4.2/sts_libs/tests/fixtures/test_iscsi_fixtures.py

@@ -0,0 +1,69 @@
+# Copyright: Contributors to the sts project
+# SPDX-License-Identifier: GPL-3.0-or-later
+
+"""Tests for iSCSI fixture device discovery and readiness."""
+
+from __future__ import annotations
+
+from pathlib import Path
+from unittest.mock import MagicMock
+
+import pytest
+
+from sts.fixtures import iscsi_fixtures
+from sts.iscsi.session import SessionDisk
+
+
+def test_get_target_device_paths_uses_matching_running_sessions(monkeypatch: pytest.MonkeyPatch) -> None:
+    session = MagicMock()
+    session.get_disks.return_value = [
+        SessionDisk(name='sdc', state='running', scsi_n='3', channel='0', id='0', lun='0'),
+        SessionDisk(name='sdd', state='blocked', scsi_n='3', channel='0', id='0', lun='1'),
+    ]
+    get_by_target = MagicMock(return_value=[session])
+    monkeypatch.setattr(iscsi_fixtures.IscsiSession, 'get_by_target', get_by_target)
+
+    paths = iscsi_fixtures._get_target_device_paths('iqn.test:target')
+
+    assert paths == [Path('/dev/sdc')]
+    get_by_target.assert_called_once_with('iqn.test:target')
+
+
+def test_target_devices_ready_requires_expected_count_and_openable_paths(monkeypatch: pytest.MonkeyPatch) -> None:
+    paths = [Path('/dev/sdc'), Path('/dev/sdd')]
+    monkeypatch.setattr(iscsi_fixtures, '_get_target_device_paths', lambda _target_iqn: paths)
+    is_openable = MagicMock(side_effect=lambda path: path == Path('/dev/sdc'))
+    monkeypatch.setattr(iscsi_fixtures, '_device_is_openable', is_openable)
+
+    assert not iscsi_fixtures._target_devices_ready('iqn.test:target', 1)
+    assert not iscsi_fixtures._target_devices_ready('iqn.test:target', 2)
+
+    is_openable.side_effect = None
+    is_openable.return_value = True
+    assert iscsi_fixtures._target_devices_ready('iqn.test:target', 2)
+
+
+def test_device_is_openable_checks_the_device_node(tmp_path: Path) -> None:
+    device = tmp_path / 'device'
+    device.touch()
+
+    assert iscsi_fixtures._device_is_openable(device)
+    assert not iscsi_fixtures._device_is_openable(tmp_path / 'missing')
+
+
+def test_find_test_devices_can_be_restricted_to_target(monkeypatch: pytest.MonkeyPatch) -> None:
+    target_paths = [Path('/dev/sdc')]
+    get_target_paths = MagicMock(return_value=target_paths)
+    monkeypatch.setattr(iscsi_fixtures, '_get_target_device_paths', get_target_paths)
+
+    paths = iscsi_fixtures._find_test_devices(target_iqn='iqn.test:target')
+
+    assert paths == target_paths
+    get_target_paths.assert_called_once_with('iqn.test:target')
+
+
+def test_find_test_devices_rejects_target_without_running_disks(monkeypatch: pytest.MonkeyPatch) -> None:
+    monkeypatch.setattr(iscsi_fixtures, '_get_target_device_paths', lambda _target_iqn: [])
+
+    with pytest.raises(AssertionError, match='No running devices found'):
+        iscsi_fixtures._find_test_devices(target_iqn='iqn.test:target')

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/tests/test_loop.py

@@ -350,12 +350,18 @@ class TestLoopDevicePrepareImageFile:
             result = LoopDevice._prepare_image_file('loop0', tmp_path, 512)
         assert result is None
 
-    def test_returns_none_on_fallocate_failure(self, mock_run_with_result, mock_command_result, tmp_path) -> None:
-        _, results = mock_run_with_result
-        results[f'fallocate -l 512M {tmp_path / "loop0.img"}'] = mock_command_result(command='test', rc=1)
+    def test_returns_none_on_fallocate_failure(self, mock_command_result, tmp_path) -> None:
+        image = tmp_path / 'loop0.img'
+
+        def fail_after_creating_image(_argv):
+            image.touch()
+            return mock_command_result(command='test', rc=1)
+
+        with patch('sts.loop.run_argv', side_effect=fail_after_creating_image):
+            result = LoopDevice._prepare_image_file('loop0', tmp_path, 512)
 
-        result = LoopDevice._prepare_image_file('loop0', tmp_path, 512)
         assert result is None
+        assert not image.exists()
 
     @pytest.mark.usefixtures('mock_run')
     def test_creates_parent_directory(self) -> None:

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/tests/test_pr.py

@@ -68,7 +68,7 @@ class TestPRDeviceSetup:
         with pytest.raises(DeviceError):
             device.setup()
 
-    def test_setup_raises_when_pr_unsupported(self, mock_run_with_result, mock_command_result) -> None:
+    def test_setup_preserves_pr_capability_failure(self, mock_run_with_result, mock_command_result) -> None:
         _, results = mock_run_with_result
         results['udevadm settle'] = mock_command_result(command='test', rc=0)
         results['sg_persist --in --report-capabilities /dev/sda'] = mock_command_result(
@@ -77,7 +77,10 @@ class TestPRDeviceSetup:
 
         device = PRDevice(path='/dev/sda')
 
-        with pytest.raises(DeviceError, match='does not support persistent reservations'):
+        with pytest.raises(
+            DeviceError,
+            match='Could not verify persistent reservation support on /dev/sda: not supported',
+        ):
             device.setup()
 
     def test_setup_auto_registers_key(self, mock_run_with_result, mock_command_result) -> None:

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/tests/test_sg3_utils.py

@@ -654,6 +654,22 @@ class TestSgPersistReportCapabilities:
         persist = SgPersist()
         assert persist.report_capabilities('/dev/sda') is False
 
+    def test_report_capabilities_result_preserves_failure(
+        self,
+        mock_run_with_result: tuple[list[str], dict[str, CommandResult]],
+        mock_command_result: type[CommandResult],
+    ) -> None:
+        _calls, results = mock_run_with_result
+        results['sg_persist --in --report-capabilities /dev/sda'] = mock_command_result(
+            command='test', rc=56, stderr='No such device or address'
+        )
+        persist = SgPersist()
+
+        result = persist.report_capabilities_result('/dev/sda')
+
+        assert result.rc == 56
+        assert result.stderr == 'No such device or address'
+
 
 class TestSgInq:
     def test_inquiry_basic(

{sts_libs-2.4.0 → sts_libs-2.4.2}/sts_libs/tests/test_target.py

@@ -30,6 +30,8 @@ from sts.target import (
 )
 
 if TYPE_CHECKING:
+    from pathlib import Path
+
     from sts.utils.cmdline import CommandResult
 
 
@@ -891,6 +893,21 @@ class TestCreateLoopbackDevices:
         with pytest.raises(ValueError, match='Device count must be at least 1'):
             create_loopback_devices(0)
 
+    def test_removes_stale_backing_file_before_create(
+        self,
+        mock_run: list[str],
+        monkeypatch: pytest.MonkeyPatch,
+        tmp_path: Path,
+    ) -> None:
+        monkeypatch.setenv('IMAGE_PATH', str(tmp_path))
+        backing_file = tmp_path / 'common-lun-0.image'
+        backing_file.write_bytes(b'stale')
+
+        with patch('sts.target.get_free_disks', return_value=[]):
+            create_loopback_devices(1)
+
+        assert not backing_file.exists()
+
     @patch('sts.target.get_free_disks')
     def test_creates_devices(
         self,
@@ -979,6 +996,20 @@ class TestCleanupLoopbackDevices:
         with pytest.raises(ValueError, match='No devices provided for cleanup'):
             cleanup_loopback_devices([])
 
+    def test_removes_owned_backing_file(
+        self,
+        mock_run: list[str],
+        monkeypatch: pytest.MonkeyPatch,
+        tmp_path: Path,
+    ) -> None:
+        monkeypatch.setenv('IMAGE_PATH', str(tmp_path))
+        backing_file = tmp_path / 'common-lun-0.image'
+        backing_file.touch()
+
+        cleanup_loopback_devices([MagicMock()])
+
+        assert not backing_file.exists()
+
     def test_cleans_up_devices(
         self,
         mock_run_with_result: tuple[list[str], dict[str, CommandResult]],

{sts_libs-2.4.0 → sts_libs-2.4.2}/tests/block/cpu_hotplug/test_cpu_offline_io.py

@@ -199,7 +199,7 @@ def _assert_device_readable(path: Path) -> None:
     assert result.succeeded, f'Post-hotplug read failed for {path}: {result.stderr}'
 
 
-def _exercise_cpu_hotplug_io(path: Path) -> None:
+def _exercise_cpu_hotplug_io(path: Path, *, reports_io_stats: bool = True) -> None:
     """Run fio while cycling every available hotpluggable CPU and restore all states."""
     states = _online_hotpluggable_cpus()
     assert states, 'No currently online nonzero hotpluggable CPUs are available after fixture setup'
@@ -211,7 +211,8 @@ def _exercise_cpu_hotplug_io(path: Path) -> None:
     try:
         assert fio_started.is_set(), f'cpu-hotplug fio did not start for {path}'
         assert fio.poll() is None, f'cpu-hotplug fio exited before CPU toggling for {path}'
-        _wait_for_device_io(path)
+        if reports_io_stats:
+            _wait_for_device_io(path)
         _cycle_online_cpus(states)
     finally:
         restore_failures = _restore_cpu_states(states)
@@ -303,7 +304,8 @@ def test_cpu_hotplug_preserves_io_on_loop(loop_devices: list[LoopDevice]) -> Non
 def test_cpu_hotplug_preserves_io_on_brd(brd_device: BlockDevice) -> None:
     """A fixture-owned RAM disk continues I/O while available vCPUs are repeatedly cycled."""
     assert brd_device.path is not None
-    _exercise_cpu_hotplug_io(Path(brd_device.path))
+    # brd does not account completed I/O in /sys/block/ram*/stat.
+    _exercise_cpu_hotplug_io(Path(brd_device.path), reports_io_stats=False)
 
 
 @pytest.mark.destructive

{sts_libs-2.4.0 → sts_libs-2.4.2}/tests/block/io_scheduler/test_elevator_switch_race.py

@@ -133,6 +133,7 @@ def _is_expected_disappearance_failure(
         rf'(?:failed to (?:open|stat)(?: file)?\s+{target}'
         rf'|(?:open|stat)\(\s*{target}\s*\)\s*failed'
         rf'|(?:open|stat)(?: file)?\s+{target}\s+failed){missing_device_suffix}'
+        rf'|func=(?:open|stat)\(\s*{target}\s*\)\s*,\s*error={MISSING_DEVICE_ERROR}(?:\s|$)'
     )
     if absence.overlaps(path, started, finished) and any(
         target_open_or_stat.search(line) for line in output.splitlines()
@@ -295,9 +296,10 @@ def _delete_and_rescan(
             deleted_path = _current_hctl_path(device)
             if not device.wait_for_path(path=deleted_path, timeout=TRANSITION_TIMEOUT):
                 continue
+            delete_started = monotonic()
             if not device.delete_disk():
                 continue
-            events.put(('absent', str(deleted_path), monotonic()))
+            events.put(('absent', str(deleted_path), delete_started))
             if not device.rescan_host():
                 continue
             current_path = _current_hctl_path(device)
@@ -390,6 +392,10 @@ def _assert_race_results(events: list[tuple[Any, ...]]) -> None:
     [
         pytest.param('failed to open /dev/sdz: No such device or address', id='open'),
         pytest.param('stat(/dev/sdz) failed: ENOENT', id='stat'),
+        pytest.param(
+            'fio: pid=123, err=2/file:filesetup.c:794, func=open(/dev/sdz), error=No such file or directory',
+            id='fio-filesetup',
+        ),
         pytest.param('io_u error on file /dev/sdz: No such device', id='io_u'),
     ],
 )
@@ -541,8 +547,10 @@ def test_delete_rescan_rediscovery_tracks_an_hctl_that_returns_under_a_new_path(
     monkeypatch.setattr(ScsiDebugDevice, 'delete_disk', delete_disk)
     monkeypatch.setattr(ScsiDebugDevice, 'rescan_host', rescan_host)
     monkeypatch.setitem(globals(), 'TRANSITION_TIMEOUT', 0.01)
+    clock = iter([1.0, 2.0, 3.0])
+    monkeypatch.setitem(globals(), 'monotonic', lambda: next(clock))
 
-    _delete_and_rescan(device, stop, monotonic() + 1, events)  # type: ignore[arg-type]
+    _delete_and_rescan(device, stop, 10.0, events)  # type: ignore[arg-type]
 
     event_log: list[tuple[Any, ...]] = []
     _drain_events(events, event_log)  # type: ignore[arg-type]
@@ -552,6 +560,7 @@ def test_delete_rescan_rediscovery_tracks_an_hctl_that_returns_under_a_new_path(
         ('present', str(new_path)),
         ('cycle', str(new_path)),
     ]
+    assert event_log[0][2] == 2.0
 
 
 def _renamed_hctl_device(tmp_path: Path, monkeypatch: pytest.MonkeyPatch) -> tuple[ScsiDebugDevice, Path]:

{sts_libs-2.4.0 → sts_libs-2.4.2}/tests/block/md/test_lvm_raid.py

@@ -45,9 +45,9 @@ class LvmRaidCase(StsBaseModel):
 
 LVM_RAID_CASES = (
     LvmRaidCase(level='raid0', stripe_count=3, device_count=3, stripesize='64k'),
-    LvmRaidCase(level='raid1', stripe_count=1, device_count=4, mirrors=3),
-    LvmRaidCase(level='raid5', stripe_count=3, device_count=4),
-    LvmRaidCase(level='raid10', stripe_count=2, device_count=4, mirrors=1),
+    LvmRaidCase(level='raid1', stripe_count=4, device_count=4, mirrors=3),
+    LvmRaidCase(level='raid5', stripe_count=4, device_count=4),
+    LvmRaidCase(level='raid10', stripe_count=4, device_count=4, mirrors=1),
 )
 
 
@@ -343,9 +343,9 @@ def _wait_for_healthy_raid(lv: LogicalVolume, case: LvmRaidCase, *, timeout: int
 
 def test_healthy_lvm_raid_requires_matching_layout_and_idle_sync() -> None:
     """A wrong layout or active synchronization must not start the fio phase."""
-    case = LvmRaidCase(level='raid5', stripe_count=3, device_count=4)
-    wrong_layout = LVReport(segtype='raid1', stripes=3, raid_sync_action='idle')
-    rebuilding = LVReport(segtype='raid5', stripes=3, raid_sync_action='resync')
+    case = LvmRaidCase(level='raid5', stripe_count=4, device_count=4)
+    wrong_layout = LVReport(segtype='raid1', stripes=4, raid_sync_action='idle')
+    rebuilding = LVReport(segtype='raid5', stripes=4, raid_sync_action='resync')
 
     assert not _is_healthy_raid_report(wrong_layout, case)
     assert not _is_healthy_raid_report(rebuilding, case)