Fuzzy tests for casadm 'add core' command

Signed-off-by: Katarzyna Treder <katarzyna.treder@h-partners.com>

test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/__init__.py

@@ -0,0 +1,5 @@
+#
+# Copyright(c) 2022 Intel Corporation
+# Copyright(c) 2024 Huawei Technologies
+# SPDX-License-Identifier: BSD-3-Clause
+#

test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_cache_id.py

@@ -0,0 +1,93 @@
+#
+# Copyright(c) 2022 Intel Corporation
+# Copyright(c) 2024 Huawei Technologies Co., Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import pytest
+
+from api.cas import casadm
+from api.cas.cache_config import (
+    CacheMode,
+    CacheLineSize,
+    UnalignedIo,
+    KernelParameters,
+    UseIoScheduler,
+    CleaningPolicy,
+    CacheModeTrait,
+)
+from api.cas.cli import add_core_cmd
+from core.test_run import TestRun
+from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
+from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer
+from tests.security.fuzzy.kernel.common.common import (
+    get_fuzz_config,
+    run_cmd_and_validate,
+)
+
+
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+@pytest.mark.parametrizex("cache_mode", CacheMode)
+@pytest.mark.parametrizex("cache_line_size", CacheLineSize)
+@pytest.mark.parametrizex("cleaning_policy", CleaningPolicy)
+@pytest.mark.parametrizex("unaligned_io", UnalignedIo)
+@pytest.mark.parametrizex("use_io_scheduler", UseIoScheduler)
+def test_fuzzy_add_core_cache_id(
+    cache_mode, cache_line_size, cleaning_policy, unaligned_io, use_io_scheduler
+):
+    """
+    title: Fuzzy test for casadm 'add core' command – cache id
+    description: |
+        Using Peach Fuzzer check Open CAS ability of handling wrong cache id in
+        'add core' command.
+    pass_criteria:
+      - System did not crash
+      - Open CAS still works.
+    """
+
+    core_id = 1
+
+    with TestRun.step("Start cache and set appropriate cleaning policy."):
+        cache_disk = TestRun.disks["cache"]
+        core_disk = TestRun.disks["core"]
+        cache = casadm.start_cache(
+            cache_dev=cache_disk,
+            cache_mode=cache_mode,
+            cache_line_size=cache_line_size,
+            cache_id=1,
+            force=True,
+            kernel_params=KernelParameters(unaligned_io, use_io_scheduler),
+        )
+
+        cache.set_cleaning_policy(
+            cleaning_policy=(
+                cleaning_policy
+                if CacheModeTrait.LazyWrites in CacheMode.get_traits(cache_mode)
+                else CleaningPolicy.DEFAULT
+            )
+        )
+
+    with TestRun.step("Prepare PeachFuzzer"):
+        valid_values = [str(cache.cache_id).encode("ascii")]
+        fuzz_config = get_fuzz_config("cache_id.yml")
+        PeachFuzzer.generate_config(fuzz_config)
+        base_cmd = add_core_cmd(
+            cache_id="{param}", core_dev=core_disk.path, core_id=str(core_id)
+        )
+        commands = PeachFuzzer.get_fuzzed_command(
+            command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count
+        )
+
+    for index, cmd in TestRun.iteration(
+        enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times"
+    ):
+        with TestRun.step(f"Iteration {index + 1}"):
+            output = run_cmd_and_validate(
+                cmd=cmd,
+                value_name="Cache id",
+                is_valid=cmd.param in valid_values,
+            )
+            if output.exit_code == 0:
+                with TestRun.step("Remove core"):
+                    cache.remove_core(core_id)

test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_core_id.py

@@ -0,0 +1,100 @@
+#
+# Copyright(c) 2022 Intel Corporation
+# Copyright(c) 2024 Huawei Technologies Co., Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import pytest
+
+from api.cas import casadm
+from api.cas.cache_config import (
+    CacheMode,
+    CacheLineSize,
+    UnalignedIo,
+    KernelParameters,
+    UseIoScheduler,
+    CleaningPolicy,
+    CacheModeTrait,
+)
+from api.cas.cli import add_core_cmd
+from core.test_run import TestRun
+from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
+from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer
+from tests.security.fuzzy.kernel.common.common import (
+    get_fuzz_config,
+    run_cmd_and_validate,
+)
+
+core_id_min = 0
+core_id_max = 4095
+
+
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+@pytest.mark.parametrizex("cache_mode", CacheMode)
+@pytest.mark.parametrizex("cache_line_size", CacheLineSize)
+@pytest.mark.parametrizex("cleaning_policy", CleaningPolicy)
+@pytest.mark.parametrizex("unaligned_io", UnalignedIo)
+@pytest.mark.parametrizex("use_io_scheduler", UseIoScheduler)
+def test_fuzzy_add_core_core_id(
+    cache_mode, cache_line_size, cleaning_policy, unaligned_io, use_io_scheduler
+):
+    """
+    title: Fuzzy test for casadm 'add core' command – core id
+    description: |
+        Using Peach Fuzzer check Open CAS ability of handling wrong core id in
+        'add core' command.
+    pass_criteria:
+      - System did not crash
+      - Open CAS still works.
+    """
+    with TestRun.step("Start cache and set appropriate cleaning policy."):
+        cache_disk = TestRun.disks["cache"]
+        core_disk = TestRun.disks["core"]
+        cache = casadm.start_cache(
+            cache_dev=cache_disk,
+            cache_mode=cache_mode,
+            cache_line_size=cache_line_size,
+            cache_id=1,
+            force=True,
+            kernel_params=KernelParameters(unaligned_io, use_io_scheduler),
+        )
+
+        cache.set_cleaning_policy(
+            cleaning_policy=(
+                cleaning_policy
+                if CacheModeTrait.LazyWrites in CacheMode.get_traits(cache_mode)
+                else CleaningPolicy.DEFAULT
+            )
+        )
+
+    with TestRun.step("Prepare PeachFuzzer"):
+        fuzz_config = get_fuzz_config("core_id.yml")
+        PeachFuzzer.generate_config(fuzz_config)
+        base_cmd = add_core_cmd(
+            cache_id=str(cache.cache_id), core_dev=core_disk.path, core_id="{param}"
+        )
+        commands = PeachFuzzer.get_fuzzed_command(
+            command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count
+        )
+
+    for index, cmd in TestRun.iteration(
+        enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times"
+    ):
+        with TestRun.step(f"Iteration {index + 1}"):
+            output = run_cmd_and_validate(
+                cmd=cmd,
+                value_name="Core id",
+                is_valid=__is_valid(cmd.param),
+            )
+            if output.exit_code == 0:
+                with TestRun.step("Remove core"):
+                    cache.remove_core(core_id=int(cmd.param))
+
+
+def __is_valid(parameter):
+    try:
+        value = int(parameter)
+    except ValueError:
+        return False
+    return core_id_min <= value <= core_id_max

test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_add_core_device.py

@@ -0,0 +1,98 @@
+#
+# Copyright(c) 2022 Intel Corporation
+# Copyright(c) 2024 Huawei Technologies Co., Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import pytest
+
+from api.cas import casadm
+from api.cas.cache_config import (
+    CacheMode,
+    CacheLineSize,
+    UnalignedIo,
+    KernelParameters,
+    UseIoScheduler,
+    CleaningPolicy,
+    CacheModeTrait,
+)
+from api.cas.cli import add_core_cmd
+from core.test_run import TestRun
+from storage_devices.disk import DiskType, DiskTypeSet, DiskTypeLowerThan
+from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer
+from tests.security.fuzzy.kernel.common.common import (
+    run_cmd_and_validate,
+    get_device_fuzz_config,
+)
+
+
+@pytest.mark.require_disk("cache", DiskTypeSet([DiskType.optane, DiskType.nand]))
+@pytest.mark.require_disk("core", DiskTypeLowerThan("cache"))
+@pytest.mark.parametrizex("cache_mode", CacheMode)
+@pytest.mark.parametrizex("cache_line_size", CacheLineSize)
+@pytest.mark.parametrizex("cleaning_policy", CleaningPolicy)
+@pytest.mark.parametrizex("unaligned_io", UnalignedIo)
+@pytest.mark.parametrizex("use_io_scheduler", UseIoScheduler)
+def test_fuzzy_add_core_device(
+    cache_mode, cache_line_size, cleaning_policy, unaligned_io, use_io_scheduler
+):
+    """
+    title: Fuzzy test for casadm 'add core' command – device
+    description: |
+        Using Peach Fuzzer check Open CAS ability of handling wrong core device in
+        'add core' command.
+    pass_criteria:
+      - System did not crash
+      - Open CAS still works.
+    """
+
+    core_id = 1
+
+    with TestRun.step("Start cache and set appropriate cleaning policy."):
+        cache_disk = TestRun.disks["cache"]
+        cache = casadm.start_cache(
+            cache_dev=cache_disk,
+            cache_mode=cache_mode,
+            cache_line_size=cache_line_size,
+            cache_id=1,
+            force=True,
+            kernel_params=KernelParameters(unaligned_io, use_io_scheduler),
+        )
+
+        cache.set_cleaning_policy(
+            cleaning_policy=(
+                cleaning_policy
+                if CacheModeTrait.LazyWrites in CacheMode.get_traits(cache_mode)
+                else CleaningPolicy.DEFAULT
+            )
+        )
+
+    with TestRun.step("Prepare PeachFuzzer"):
+        valid_values = [
+            disk.path
+            for disk in TestRun.dut.disks
+            if disk.path != cache_disk.path
+            and disk.block_size.get_value() >= cache_disk.block_size.get_value()
+        ]
+        fuzz_config = get_device_fuzz_config(valid_values)
+        valid_values = [path.encode("ascii") for path in valid_values]
+        PeachFuzzer.generate_config(fuzz_config)
+        base_cmd = add_core_cmd(
+            cache_id=str(cache.cache_id), core_dev="{param}", core_id=str(core_id)
+        )
+        commands = PeachFuzzer.get_fuzzed_command(
+            command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count
+        )
+
+    for index, cmd in TestRun.iteration(
+        enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times"
+    ):
+        with TestRun.step(f"Iteration {index + 1}"):
+            output = run_cmd_and_validate(
+                cmd=cmd,
+                value_name="Device path",
+                is_valid=cmd.param in valid_values,
+            )
+            if output.exit_code == 0:
+                with TestRun.step("Remove core"):
+                    cache.remove_core(core_id=core_id)

test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_cache_id.py

@@ -0,0 +1,65 @@
+#
+# Copyright(c) 2024 Huawei Technologies Co., Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import pytest
+
+from api.cas.cli import script_try_add_cmd, remove_detached_cmd
+from core.test_run import TestRun
+from storage_devices.disk import DiskTypeSet, DiskType
+from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer
+from tests.security.fuzzy.kernel.common.common import (
+    run_cmd_and_validate,
+    get_fuzz_config,
+)
+
+cache_id_min = 1
+cache_id_max = pow(2, 14)
+
+
+@pytest.mark.require_disk("core", DiskTypeSet([d for d in DiskType]))
+def test_fuzzy_script_add_core_try_add_cache_id():
+    """
+    title: Fuzzy test for casadm script 'add core' command with try-add flag - cache id.
+    description: |
+        Using Peach Fuzzer check Open CAS ability of handling wrong cache id
+        in script 'add core' command with try-add flag set.
+    pass_criteria:
+      - System did not crash
+      - Open CAS still works.
+    """
+
+    with TestRun.step("Prepare PeachFuzzer"):
+        core_disk = TestRun.disks["core"]
+        fuzz_config = get_fuzz_config("cache_id.yml")
+        PeachFuzzer.generate_config(fuzz_config)
+        base_cmd = script_try_add_cmd(
+            cache_id="{param}", core_dev=core_disk.path, core_id="1"
+        )
+        commands = PeachFuzzer.get_fuzzed_command(
+            command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count
+        )
+
+    for index, cmd in TestRun.iteration(
+        enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times"
+    ):
+        with TestRun.step(f"Iteration {index + 1}"):
+            output = run_cmd_and_validate(
+                cmd=cmd,
+                value_name="Cache id",
+                is_valid=__is_valid(cmd.param),
+            )
+            if output.exit_code == 0:
+                with TestRun.step("Remove core"):
+                    TestRun.executor.run_expect_success(
+                        remove_detached_cmd(core_device=core_disk.path)
+                    )
+
+
+def __is_valid(parameter):
+    try:
+        value = int(parameter)
+    except ValueError:
+        return False
+    return cache_id_min <= value <= cache_id_max

test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_core_id.py

@@ -0,0 +1,67 @@
+#
+# Copyright(c) 2024 Huawei Technologies Co., Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+import pytest
+
+from api.cas.cli import script_try_add_cmd, remove_detached_cmd
+from core.test_run import TestRun
+from storage_devices.disk import DiskTypeSet, DiskType
+from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer
+from tests.security.fuzzy.kernel.common.common import (
+    run_cmd_and_validate,
+    get_fuzz_config,
+)
+
+core_id_min = 0
+core_id_max = 4095
+
+
+@pytest.mark.require_disk("core", DiskTypeSet([d for d in DiskType]))
+def test_fuzzy_script_add_core_try_add_core_id():
+    """
+    title: Fuzzy test for casadm script 'add core' command with try-add flag - core id.
+    description: |
+        Using Peach Fuzzer check Open CAS ability of handling wrong core id
+        in script 'add core' command with try-add flag set.
+    pass_criteria:
+      - System did not crash
+      - Open CAS still works.
+    """
+
+    with TestRun.step("Prepare PeachFuzzer"):
+        core_disk = TestRun.disks["core"]
+        fuzz_config = get_fuzz_config("core_id.yml")
+        PeachFuzzer.generate_config(fuzz_config)
+        base_cmd = script_try_add_cmd(
+            cache_id="1",
+            core_dev=core_disk.path,
+            core_id="{param}",
+        )
+        commands = PeachFuzzer.get_fuzzed_command(
+            command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count
+        )
+
+    for index, cmd in TestRun.iteration(
+        enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times"
+    ):
+        with TestRun.step(f"Iteration {index + 1}"):
+            output = run_cmd_and_validate(
+                cmd=cmd,
+                value_name="Core id",
+                is_valid=__is_valid(cmd.param),
+            )
+            if output.exit_code == 0:
+                with TestRun.step("Remove core"):
+                    TestRun.executor.run_expect_success(
+                        remove_detached_cmd(core_device=core_disk.path)
+                    )
+
+
+def __is_valid(parameter):
+    try:
+        value = int(parameter)
+    except ValueError:
+        return False
+    return core_id_min <= value <= core_id_max

test/functional/tests/security/fuzzy/kernel/fuzzy_add_core/test_fuzzy_script_add_core_try_add_device.py

@@ -0,0 +1,52 @@
+#
+# Copyright(c) 2022 Intel Corporation
+# Copyright(c) 2024 Huawei Technologies Co., Ltd.
+# SPDX-License-Identifier: BSD-3-Clause
+#
+
+from api.cas.cli import script_try_add_cmd, remove_detached_cmd
+from core.test_run import TestRun
+from test_tools.peach_fuzzer.peach_fuzzer import PeachFuzzer
+from tests.security.fuzzy.kernel.common.common import (
+    run_cmd_and_validate,
+    get_device_fuzz_config,
+)
+
+
+def test_fuzzy_script_add_core_try_add_core_device():
+    """
+    title: Fuzzy test for casadm script 'add core' command - core device with try-add flag.
+    description: |
+        Using Peach Fuzzer check Open CAS ability of handling wrong core device path
+        in 'add core' command with try-add flag set.
+    pass_criteria:
+      - System did not crash
+      - Open CAS still works.
+    """
+
+    with TestRun.step("Prepare PeachFuzzer"):
+        valid_values = [disk.path for disk in TestRun.dut.disks]
+        fuzz_config = get_device_fuzz_config(valid_values)
+        valid_values = [path.encode("ascii") for path in valid_values]
+        PeachFuzzer.generate_config(fuzz_config)
+        base_cmd = script_try_add_cmd(
+            cache_id="1", core_dev="{param}", core_id="1"
+        )
+        commands = PeachFuzzer.get_fuzzed_command(
+            command_template=base_cmd, count=TestRun.usr.fuzzy_iter_count
+        )
+
+    for index, cmd in TestRun.iteration(
+        enumerate(commands), f"Run command {TestRun.usr.fuzzy_iter_count} times"
+    ):
+        with TestRun.step(f"Iteration {index + 1}"):
+            output = run_cmd_and_validate(
+                cmd=cmd,
+                value_name="Device path",
+                is_valid=cmd.param in valid_values,
+            )
+            if output.exit_code == 0:
+                with TestRun.step("Remove core"):
+                    TestRun.executor.run_expect_success(
+                        remove_detached_cmd(core_device=cmd.param.decode("ascii", "ignore"))
+                    )