150 lines
5.0 KiB
Python
150 lines
5.0 KiB
Python
#
|
|
# Copyright(c) 2019 Intel Corporation
|
|
# SPDX-License-Identifier: BSD-3-Clause-Clear
|
|
#
|
|
|
|
import pytest
|
|
|
|
from test_tools.fio.fio import Fio
|
|
from test_tools.fio.fio_param import ReadWrite, IoEngine, ErrorFilter, VerifyMethod
|
|
from test_tools.device_mapper import ErrorDevice, DmTable
|
|
from core.test_run import TestRun
|
|
from api.cas import casadm
|
|
from api.cas.cache_config import (
|
|
CacheMode,
|
|
CacheLineSize,
|
|
SeqCutOffPolicy,
|
|
CleaningPolicy,
|
|
)
|
|
from storage_devices.disk import DiskTypeSet, DiskType, DiskTypeLowerThan
|
|
from test_utils.os_utils import Udev
|
|
from test_utils.size import Size, Unit
|
|
|
|
|
|
@pytest.mark.parametrize("cache_line_size", CacheLineSize)
|
|
@pytest.mark.parametrize("cache_mode", CacheMode)
|
|
@pytest.mark.parametrize("io_dir", [ReadWrite.randread, ReadWrite.randwrite])
|
|
@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
|
|
@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
|
|
def test_core_device_error(io_dir, cache_mode, cache_line_size):
|
|
"""
|
|
title: Check if CAS behaves correctly when encountering errors on core device
|
|
description: |
|
|
Perform I/O on two exported objects created using error and non-error device.
|
|
Validate CAS that stats counting is consistent with OS reporting.
|
|
Also, check if normal I/O is uninterrupted and no DC occurs on any of the
|
|
core devices.
|
|
pass_criteria:
|
|
- I/O error count in FIO and in cache statistics match
|
|
- Positively passed fio verify on both core devices
|
|
"""
|
|
with TestRun.step("Prepare error device and setup cache and cores"):
|
|
cache, error_core, good_core = prepare_configuration(cache_mode, cache_line_size)
|
|
|
|
good_core_fio = (
|
|
Fio()
|
|
.create_command()
|
|
.io_engine(IoEngine.libaio)
|
|
.size(good_core.size)
|
|
.block_size(cache_line_size)
|
|
.target(good_core)
|
|
.read_write(ReadWrite.randrw)
|
|
.verify_pattern()
|
|
.verify(VerifyMethod.pattern)
|
|
.direct()
|
|
)
|
|
|
|
error_core_fio = (
|
|
Fio()
|
|
.create_command()
|
|
.io_engine(IoEngine.libaio)
|
|
.size(error_core.size)
|
|
.block_size(cache_line_size)
|
|
.target(error_core)
|
|
.read_write(io_dir)
|
|
.continue_on_error(ErrorFilter.io)
|
|
.direct()
|
|
)
|
|
if io_dir == ReadWrite.randwrite:
|
|
error_core_fio.verify_pattern().verify(VerifyMethod.pattern)
|
|
|
|
with TestRun.step("Run fio on core without errors in background"):
|
|
fio_pid = good_core_fio.run_in_background()
|
|
|
|
with TestRun.step("Run fio on error core and check if IO errors are present"):
|
|
fio_errors = error_core_fio.run()[0].total_errors()
|
|
|
|
if fio_errors == 0:
|
|
TestRun.fail("No I/O ended with error!")
|
|
|
|
with TestRun.step("Check error statistics on error core"):
|
|
stats = cache.get_statistics()
|
|
|
|
core_errors_in_cache = stats.error_stats.core.total
|
|
if fio_errors != core_errors_in_cache:
|
|
TestRun.fail(
|
|
f"Core errors in cache stats({core_errors_in_cache}) should be equal to number of"
|
|
" fio errors ({fio_errors})"
|
|
)
|
|
|
|
with TestRun.step("Wait for fio on good core"):
|
|
TestRun.executor.wait_cmd_finish(fio_pid)
|
|
|
|
with TestRun.step("Check error statistics on good core"):
|
|
stats = good_core.get_statistics()
|
|
|
|
if stats.error_stats.core.total != 0:
|
|
TestRun.fail(
|
|
f"No errors should be reported for good core. "
|
|
"Actual result: {stats.error_stats.total}"
|
|
)
|
|
|
|
with TestRun.step("Stop the cache"):
|
|
cache.stop()
|
|
|
|
with TestRun.step("Verify error core device contents (if writes)"):
|
|
if io_dir == ReadWrite.randwrite:
|
|
error_core_fio.target(error_core.core_device).verify_only().run()
|
|
|
|
with TestRun.step("Verify good core device contents"):
|
|
good_core_fio.target(good_core.core_device).verify_only().run()
|
|
|
|
|
|
def prepare_configuration(cache_mode, cache_line_size):
|
|
cache_device = TestRun.disks["cache"]
|
|
core_device = TestRun.disks["core"]
|
|
|
|
cache_device.create_partitions([Size(70, Unit.MebiByte)])
|
|
core_device.create_partitions(
|
|
[Size(70, Unit.MebiByte), Size(70, Unit.MebiByte)]
|
|
)
|
|
core1 = core_device.partitions[0]
|
|
core2 = core_device.partitions[1]
|
|
|
|
error_device = ErrorDevice(
|
|
"error",
|
|
core1,
|
|
DmTable.uniform_error_table(
|
|
start_lba=0,
|
|
stop_lba=int(core1.size.get_value(Unit.Blocks512)),
|
|
num_error_zones=100,
|
|
error_zone_size=Size(5, Unit.Blocks512),
|
|
).fill_gaps(core1),
|
|
)
|
|
|
|
cache = casadm.start_cache(
|
|
cache_device.partitions[0],
|
|
cache_mode=cache_mode,
|
|
cache_line_size=cache_line_size,
|
|
force=True,
|
|
)
|
|
cache.set_seq_cutoff_policy(SeqCutOffPolicy.never)
|
|
|
|
cache.set_cleaning_policy(CleaningPolicy.nop)
|
|
|
|
Udev.disable()
|
|
error_core = cache.add_core(core_dev=error_device)
|
|
good_core = cache.add_core(core_dev=core2)
|
|
|
|
return cache, error_core, good_core
|