From 22e94c3a8c2cb3bf85b46c57b36819a21cd6c722 Mon Sep 17 00:00:00 2001 From: "Bari, Pratik" Date: Tue, 9 Apr 2024 10:29:44 +0000 Subject: [PATCH] fix(sysman): Changes in the Sysman Engine The engine module returns error if incorrect fds are fetched Related-To: NEO-10657 Signed-off-by: Bari, Pratik --- .../api/engine/linux/sysman_os_engine_imp.cpp | 5 ++++- .../linux/sysman_os_engine_imp_prelim.cpp | 5 ++++- .../source/api/engine/sysman_engine.cpp | 14 +++++++++++-- .../sysman/source/api/engine/sysman_engine.h | 3 ++- .../shared/linux/sysman_hw_device_id_linux.h | 6 ++---- .../sources/engine/linux/mock_engine.h | 18 ++++++++++++++++- .../sources/engine/linux/mock_engine_prelim.h | 18 ++++++++++++++++- .../sources/engine/linux/test_zes_engine.cpp | 19 +++++++++++++++++- .../engine/linux/test_zes_engine_prelim.cpp | 20 ++++++++++++++++++- .../engine/windows/test_zes_engine.cpp | 6 +++--- 10 files changed, 98 insertions(+), 16 deletions(-) diff --git a/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.cpp b/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.cpp index 2a2a93176a..5b1175ea24 100644 --- a/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.cpp +++ b/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -44,6 +44,9 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::setgetSysmanHwDeviceIdInstance(); + if (hwDeviceId.getFileDescriptor() < 0) { + return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; + } status = pDrm->sysmanQueryEngineInfo(); } diff --git a/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp_prelim.cpp b/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp_prelim.cpp index 0df3740715..5b73bbcddb 100644 --- a/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp_prelim.cpp +++ b/level_zero/sysman/source/api/engine/linux/sysman_os_engine_imp_prelim.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Intel Corporation + * Copyright (C) 2022-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -43,6 +43,9 @@ ze_result_t OsEngine::getNumEngineTypeAndInstances(std::setgetSysmanHwDeviceIdInstance(); + if (hwDeviceId.getFileDescriptor() < 0) { + return ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE; + } status = pDrm->sysmanQueryEngineInfo(); } diff --git a/level_zero/sysman/source/api/engine/sysman_engine.cpp b/level_zero/sysman/source/api/engine/sysman_engine.cpp index 90b05971f4..6748122ad7 100644 --- a/level_zero/sysman/source/api/engine/sysman_engine.cpp +++ b/level_zero/sysman/source/api/engine/sysman_engine.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -33,7 +33,12 @@ void EngineHandleContext::createHandle(zes_engine_group_t engineType, uint32_t e void EngineHandleContext::init(uint32_t subDeviceCount) { std::set> engineGroupInstance = {}; // set contains pair of engine group and struct containing engine instance and subdeviceId - OsEngine::getNumEngineTypeAndInstances(engineGroupInstance, pOsSysman); + deviceEngineInitStatus = OsEngine::getNumEngineTypeAndInstances(engineGroupInstance, pOsSysman); + + if (deviceEngineInitStatus != ZE_RESULT_SUCCESS) { + return; + } + for (auto itr = engineGroupInstance.begin(); itr != engineGroupInstance.end(); ++itr) { for (uint32_t subDeviceId = 0; subDeviceId <= subDeviceCount; subDeviceId++) { if (subDeviceId == itr->second.second) { @@ -53,6 +58,11 @@ ze_result_t EngineHandleContext::engineGet(uint32_t *pCount, zes_engine_handle_t this->init(pOsSysman->getSubDeviceCount()); this->engineInitDone = true; }); + + if (deviceEngineInitStatus != ZE_RESULT_SUCCESS) { + return deviceEngineInitStatus; + } + uint32_t handleListSize = static_cast(handleList.size()); uint32_t numToCopy = std::min(*pCount, handleListSize); if (0 == *pCount || *pCount > handleListSize) { diff --git a/level_zero/sysman/source/api/engine/sysman_engine.h b/level_zero/sysman/source/api/engine/sysman_engine.h index 1c01d7edc6..5883514584 100644 --- a/level_zero/sysman/source/api/engine/sysman_engine.h +++ b/level_zero/sysman/source/api/engine/sysman_engine.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -50,6 +50,7 @@ struct EngineHandleContext { void createHandle(zes_engine_group_t engineType, uint32_t engineInstance, uint32_t subDeviceId, ze_bool_t onSubdevice); std::once_flag initEngineOnce; bool engineInitDone = false; + ze_result_t deviceEngineInitStatus = ZE_RESULT_SUCCESS; }; } // namespace Sysman diff --git a/level_zero/sysman/source/shared/linux/sysman_hw_device_id_linux.h b/level_zero/sysman/source/shared/linux/sysman_hw_device_id_linux.h index a3604955c2..f040d7d5b0 100644 --- a/level_zero/sysman/source/shared/linux/sysman_hw_device_id_linux.h +++ b/level_zero/sysman/source/shared/linux/sysman_hw_device_id_linux.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -17,9 +17,7 @@ class SysmanHwDeviceIdDrm : public NEO::HwDeviceIdDrm { using NEO::HwDeviceIdDrm::HwDeviceIdDrm; class SingleInstance { public: - SingleInstance(SysmanHwDeviceIdDrm &input) : instance(input), fileDescriptor(input.openFileDescriptor()) { - UNRECOVERABLE_IF(fileDescriptor < 0); - } + SingleInstance(SysmanHwDeviceIdDrm &input) : instance(input), fileDescriptor(input.openFileDescriptor()) {} ~SingleInstance() { instance.closeFileDescriptor(); } int getFileDescriptor() const { return fileDescriptor; } diff --git a/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine.h b/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine.h index cbfd7f0eb8..25e1d20769 100644 --- a/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine.h +++ b/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -23,11 +23,27 @@ namespace L0 { namespace Sysman { namespace ult { +class MockEngineSysmanHwDeviceIdDrm : public MockSysmanHwDeviceIdDrm { + public: + using L0::Sysman::ult::MockSysmanHwDeviceIdDrm::MockSysmanHwDeviceIdDrm; + int returnOpenFileDescriptor = -1; + int returnCloseFileDescriptor = 0; + + int openFileDescriptor() override { + return returnOpenFileDescriptor; + } + + int closeFileDescriptor() override { + return returnCloseFileDescriptor; + } +}; + struct MockEngineNeoDrm : public Drm { using Drm::getEngineInfo; using Drm::setupIoctlHelper; const int mockFd = 0; MockEngineNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique(mockFd, ""), rootDeviceEnvironment) {} + MockEngineNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment, int mockFileDescriptor) : Drm(std::make_unique(mockFileDescriptor, ""), rootDeviceEnvironment) {} bool mockSysmanQueryEngineInfoReturnFalse = true; bool sysmanQueryEngineInfo() override { diff --git a/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_prelim.h b/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_prelim.h index a7e04c85f5..16f20f8276 100644 --- a/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_prelim.h +++ b/level_zero/sysman/test/unit_tests/sources/engine/linux/mock_engine_prelim.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Intel Corporation + * Copyright (C) 2022-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -33,11 +33,27 @@ constexpr uint32_t numberOfMockedEnginesForSingleTileDevice = 7u; constexpr uint32_t numberOfTiles = 2u; constexpr uint32_t numberOfMockedEnginesForMultiTileDevice = 2u; +class MockEngineSysmanHwDeviceIdDrm : public MockSysmanHwDeviceIdDrm { + public: + using L0::Sysman::ult::MockSysmanHwDeviceIdDrm::MockSysmanHwDeviceIdDrm; + int returnOpenFileDescriptor = -1; + int returnCloseFileDescriptor = 0; + + int openFileDescriptor() override { + return returnOpenFileDescriptor; + } + + int closeFileDescriptor() override { + return returnCloseFileDescriptor; + } +}; + struct MockEngineNeoDrm : public Drm { using Drm::engineInfo; using Drm::setupIoctlHelper; const int mockFd = 0; MockEngineNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment) : Drm(std::make_unique(mockFd, ""), rootDeviceEnvironment) {} + MockEngineNeoDrm(RootDeviceEnvironment &rootDeviceEnvironment, int mockFileDescriptor) : Drm(std::make_unique(mockFileDescriptor, ""), rootDeviceEnvironment) {} bool mockReadSysmanQueryEngineInfo = false; bool mockReadSysmanQueryEngineInfoMultiDevice = false; diff --git a/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine.cpp b/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine.cpp index 63a0545de0..47a88e6968 100644 --- a/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine.cpp +++ b/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2023 Intel Corporation + * Copyright (C) 2020-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -69,6 +69,23 @@ class ZesEngineFixtureI915 : public ZesEngineFixture { } }; +TEST_F(SysmanDeviceFixture, GivenComponentCountZeroAndOpenCallFailsWhenCallingZesDeviceEnumEngineGroupsThenErrorIsReturned) { + + MockEngineNeoDrm *pDrm = nullptr; + int mockFd = -1; + pDrm = new MockEngineNeoDrm(const_cast(pSysmanDeviceImp->getRootDeviceEnvironment()), mockFd); + pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily); + auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface; + osInterface->setDriverModel(std::unique_ptr(pDrm)); + + pSysmanDeviceImp->pEngineHandleContext->handleList.clear(); + pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable.isIntegratedDevice = true; + L0::Sysman::SysmanDevice *device = pSysmanDevice; + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL)); +} + TEST_F(ZesEngineFixtureI915, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) { uint32_t count = 0; diff --git a/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_prelim.cpp b/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_prelim.cpp index 5d907b4292..693cd1b7d8 100644 --- a/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_prelim.cpp +++ b/level_zero/sysman/test/unit_tests/sources/engine/linux/test_zes_engine_prelim.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2022-2023 Intel Corporation + * Copyright (C) 2022-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -80,6 +80,23 @@ class ZesEngineFixture : public SysmanDeviceFixture { } }; +TEST_F(SysmanDeviceFixture, GivenComponentCountZeroAndOpenCallFailsWhenCallingZesDeviceEnumEngineGroupsThenErrorIsReturned) { + + MockEngineNeoDrm *pDrm = nullptr; + int mockFd = -1; + pDrm = new MockEngineNeoDrm(const_cast(pSysmanDeviceImp->getRootDeviceEnvironment()), mockFd); + pDrm->setupIoctlHelper(pSysmanDeviceImp->getRootDeviceEnvironment().getHardwareInfo()->platform.eProductFamily); + auto &osInterface = pSysmanDeviceImp->getRootDeviceEnvironment().osInterface; + osInterface->setDriverModel(std::unique_ptr(pDrm)); + + pSysmanDeviceImp->pEngineHandleContext->handleList.clear(); + pSysmanDeviceImp->getRootDeviceEnvironment().getMutableHardwareInfo()->capabilityTable.isIntegratedDevice = true; + L0::Sysman::SysmanDevice *device = pSysmanDevice; + + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_ERROR_DEPENDENCY_UNAVAILABLE, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL)); +} + TEST_F(ZesEngineFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGroupsThenNonZeroCountIsReturnedAndVerifyCallSucceeds) { uint32_t count = 0; EXPECT_EQ(ZE_RESULT_SUCCESS, zesDeviceEnumEngineGroups(device->toHandle(), &count, NULL)); @@ -94,6 +111,7 @@ TEST_F(ZesEngineFixture, GivenComponentCountZeroWhenCallingzesDeviceEnumEngineGr EXPECT_EQ(zesDeviceEnumEngineGroups(device->toHandle(), &count, handles.data()), ZE_RESULT_SUCCESS); EXPECT_EQ(count, handleComponentCount); } + TEST_F(ZesEngineFixture, GivenValidEngineHandlesWhenCallingZesEngineGetPropertiesThenVerifyCallSucceeds) { zes_engine_properties_t properties; auto handles = getEngineHandles(handleComponentCount); diff --git a/level_zero/sysman/test/unit_tests/sources/engine/windows/test_zes_engine.cpp b/level_zero/sysman/test/unit_tests/sources/engine/windows/test_zes_engine.cpp index 697ae3a635..9878836249 100644 --- a/level_zero/sysman/test/unit_tests/sources/engine/windows/test_zes_engine.cpp +++ b/level_zero/sysman/test/unit_tests/sources/engine/windows/test_zes_engine.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -68,11 +68,11 @@ TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGr } } -TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsAndRequestMultipleFailsThenZeroHandlesAreReturned) { +TEST_F(SysmanDeviceEngineFixture, GivenComponentCountZeroWhenEnumeratingEngineGroupsAndRequestMultipleFailsThenErrorAndZeroHandlesAreReturned) { pKmdSysManager->mockRequestMultiple = true; pKmdSysManager->mockRequestMultipleResult = ZE_RESULT_ERROR_UNSUPPORTED_FEATURE; uint32_t count = 0; - EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_SUCCESS); + EXPECT_EQ(zesDeviceEnumEngineGroups(pSysmanDevice->toHandle(), &count, nullptr), ZE_RESULT_ERROR_UNSUPPORTED_FEATURE); EXPECT_EQ(count, 0u); }