From f52f9753edd71e1ce91f858ef0086acb2b664d20 Mon Sep 17 00:00:00 2001 From: Shreyas Kunder Date: Mon, 4 Nov 2024 18:26:41 +0000 Subject: [PATCH] fix: zesInit switch crash The fix is provided to detect validity of sysman device handle in sysman APIs. It can detect core device handle when passed instead of sysman device handle in zesInit path and return error code. Related-To: NEO-12690 Signed-off-by: Shreyas Kunder --- .../test/common/ult_config_listener_l0.cpp | 2 + .../api/events/linux/sysman_os_events_imp.cpp | 3 + .../sysman/source/device/sysman_device.cpp | 104 +++++++++++++++++ .../sysman/source/device/sysman_device.h | 2 +- .../windows/zes_os_sysman_driver_imp.cpp | 8 +- .../sources/events/linux/test_zes_events.cpp | 37 ++++++ .../sources/linux/mock_sysman_fixture.h | 2 + .../unit_tests/sources/linux/test_sysman.cpp | 90 +++++++++++++++ .../unit_tests/sources/windows/CMakeLists.txt | 1 + .../sources/windows/mock_sysman_fixture.h | 2 + .../sources/windows/test_sysman.cpp | 108 ++++++++++++++++++ 11 files changed, 356 insertions(+), 3 deletions(-) create mode 100644 level_zero/sysman/test/unit_tests/sources/windows/test_sysman.cpp diff --git a/level_zero/core/test/common/ult_config_listener_l0.cpp b/level_zero/core/test/common/ult_config_listener_l0.cpp index 2f0ca47697..61afc1bc8d 100644 --- a/level_zero/core/test/common/ult_config_listener_l0.cpp +++ b/level_zero/core/test/common/ult_config_listener_l0.cpp @@ -9,6 +9,7 @@ #include "level_zero/core/source/driver/driver.h" #include "level_zero/core/source/driver/driver_handle_imp.h" +#include "level_zero/sysman/source/driver/sysman_driver_handle_imp.h" void L0::UltConfigListenerL0::OnTestStart(const ::testing::TestInfo &testInfo) { BaseUltConfigListener::OnTestStart(testInfo); @@ -23,6 +24,7 @@ void L0::UltConfigListenerL0::OnTestEnd(const ::testing::TestInfo &testInfo) { EXPECT_EQ(nullptr, globalDriverHandle); EXPECT_EQ(0u, driverCount); EXPECT_EQ(nullptr, L0::globalDriver); + EXPECT_EQ(nullptr, L0::Sysman::globalSysmanDriver); BaseUltConfigListener::OnTestEnd(testInfo); } diff --git a/level_zero/sysman/source/api/events/linux/sysman_os_events_imp.cpp b/level_zero/sysman/source/api/events/linux/sysman_os_events_imp.cpp index 757fac979b..cd4ced1f3f 100644 --- a/level_zero/sysman/source/api/events/linux/sysman_os_events_imp.cpp +++ b/level_zero/sysman/source/api/events/linux/sysman_os_events_imp.cpp @@ -153,6 +153,9 @@ ze_result_t LinuxEventsUtil::eventsListen(uint64_t timeout, uint32_t count, zes_ std::vector registeredEvents(count); for (uint32_t devIndex = 0; devIndex < count; devIndex++) { auto device = static_cast(L0::Sysman::SysmanDevice::fromHandle(phDevices[devIndex])); + if (device == nullptr) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } eventsMutex.lock(); if (deviceEventsMap.find(device) != deviceEventsMap.end()) { registeredEvents[devIndex] = deviceEventsMap[device]; diff --git a/level_zero/sysman/source/device/sysman_device.cpp b/level_zero/sysman/source/device/sysman_device.cpp index e7771916de..101749f4cb 100644 --- a/level_zero/sysman/source/device/sysman_device.cpp +++ b/level_zero/sysman/source/device/sysman_device.cpp @@ -5,9 +5,11 @@ * */ +#include "shared/source/debug_settings/debug_settings_manager.h" #include "shared/source/execution_environment/execution_environment.h" #include "level_zero/sysman/source/device/sysman_device_imp.h" +#include "level_zero/sysman/source/driver/sysman_driver_handle_imp.h" #include #include @@ -26,141 +28,237 @@ SysmanDevice *SysmanDevice::create(NEO::ExecutionEnvironment &executionEnvironme return pSysmanDevice; } +SysmanDevice *SysmanDevice::fromHandle(zes_device_handle_t handle) { + SysmanDevice *sysmanDevice = static_cast(handle); + if (globalSysmanDriver == nullptr) { + return nullptr; + } + if (std::find(globalSysmanDriver->sysmanDevices.begin(), globalSysmanDriver->sysmanDevices.end(), sysmanDevice) == globalSysmanDriver->sysmanDevices.end()) { + PRINT_DEBUG_STRING(NEO::debugManager.flags.PrintDebugMessages.get(), stderr, "SysmanDevice::fromHandle: Device not found in sysmanDevices list%s\n", ""); + return nullptr; + } + return sysmanDevice; +} + ze_result_t SysmanDevice::fabricPortGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_fabric_port_handle_t *phPort) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->fabricPortGet(pCount, phPort); } ze_result_t SysmanDevice::memoryGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_mem_handle_t *phMemory) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->memoryGet(pCount, phMemory); } ze_result_t SysmanDevice::powerGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_pwr_handle_t *phPower) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->powerGet(pCount, phPower); } ze_result_t SysmanDevice::powerGetCardDomain(zes_device_handle_t hDevice, zes_pwr_handle_t *phPower) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->powerGetCardDomain(phPower); } ze_result_t SysmanDevice::engineGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_engine_handle_t *phEngine) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->engineGet(pCount, phEngine); } ze_result_t SysmanDevice::frequencyGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_freq_handle_t *phFrequency) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->frequencyGet(pCount, phFrequency); } ze_result_t SysmanDevice::schedulerGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_sched_handle_t *phScheduler) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->schedulerGet(pCount, phScheduler); } ze_result_t SysmanDevice::rasGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_ras_handle_t *phRas) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->rasGet(pCount, phRas); } ze_result_t SysmanDevice::diagnosticsGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_diag_handle_t *phDiagnostics) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->diagnosticsGet(pCount, phDiagnostics); } ze_result_t SysmanDevice::firmwareGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_firmware_handle_t *phFirmware) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->firmwareGet(pCount, phFirmware); } ze_result_t SysmanDevice::deviceGetProperties(zes_device_handle_t hDevice, zes_device_properties_t *pProperties) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceGetProperties(pProperties); } ze_result_t SysmanDevice::processesGetState(zes_device_handle_t hDevice, uint32_t *pCount, zes_process_state_t *pProcesses) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->processesGetState(pCount, pProcesses); } ze_result_t SysmanDevice::deviceReset(zes_device_handle_t hDevice, ze_bool_t force) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceReset(force); } ze_result_t SysmanDevice::deviceGetState(zes_device_handle_t hDevice, zes_device_state_t *pState) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceGetState(pState); } ze_result_t SysmanDevice::deviceGetSubDeviceProperties(zes_device_handle_t hDevice, uint32_t *pCount, zes_subdevice_exp_properties_t *pSubdeviceProps) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceGetSubDeviceProperties(pCount, pSubdeviceProps); } ze_result_t SysmanDevice::standbyGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_standby_handle_t *phStandby) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->standbyGet(pCount, phStandby); } ze_result_t SysmanDevice::deviceEccAvailable(zes_device_handle_t hDevice, ze_bool_t *pAvailable) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceEccAvailable(pAvailable); } ze_result_t SysmanDevice::deviceEccConfigurable(zes_device_handle_t hDevice, ze_bool_t *pConfigurable) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceEccConfigurable(pConfigurable); } ze_result_t SysmanDevice::deviceGetEccState(zes_device_handle_t hDevice, zes_device_ecc_properties_t *pState) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceGetEccState(pState); } ze_result_t SysmanDevice::deviceSetEccState(zes_device_handle_t hDevice, const zes_device_ecc_desc_t *newState, zes_device_ecc_properties_t *pState) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceSetEccState(newState, pState); } ze_result_t SysmanDevice::temperatureGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_temp_handle_t *phTemperature) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->temperatureGet(pCount, phTemperature); } ze_result_t SysmanDevice::performanceGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_perf_handle_t *phPerformance) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->performanceGet(pCount, phPerformance); } ze_result_t SysmanDevice::pciGetProperties(zes_device_handle_t hDevice, zes_pci_properties_t *pProperties) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->pciGetProperties(pProperties); } ze_result_t SysmanDevice::pciGetState(zes_device_handle_t hDevice, zes_pci_state_t *pState) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->pciGetState(pState); } ze_result_t SysmanDevice::pciGetBars(zes_device_handle_t hDevice, uint32_t *pCount, zes_pci_bar_properties_t *pProperties) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->pciGetBars(pCount, pProperties); } ze_result_t SysmanDevice::pciGetStats(zes_device_handle_t hDevice, zes_pci_stats_t *pStats) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->pciGetStats(pStats); } ze_result_t SysmanDevice::fanGet(zes_device_handle_t hDevice, uint32_t *pCount, zes_fan_handle_t *phFan) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->fanGet(pCount, phFan); } ze_result_t SysmanDevice::deviceEventRegister(zes_device_handle_t hDevice, zes_event_type_flags_t events) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceEventRegister(events); } @@ -171,11 +269,17 @@ uint64_t SysmanDevice::getSysmanTimestamp() { ze_result_t SysmanDevice::deviceResetExt(zes_device_handle_t hDevice, zes_reset_properties_t *pProperties) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->deviceResetExt(pProperties); } ze_result_t SysmanDevice::fabricPortGetMultiPortThroughput(zes_device_handle_t hDevice, uint32_t numPorts, zes_fabric_port_handle_t *phPort, zes_fabric_port_throughput_t **pThroughput) { auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(hDevice); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_UNINITIALIZED; + } return pSysmanDevice->fabricPortGetMultiPortThroughput(numPorts, phPort, pThroughput); } diff --git a/level_zero/sysman/source/device/sysman_device.h b/level_zero/sysman/source/device/sysman_device.h index 6a39e87f9c..96214e9a78 100644 --- a/level_zero/sysman/source/device/sysman_device.h +++ b/level_zero/sysman/source/device/sysman_device.h @@ -33,7 +33,7 @@ namespace L0 { namespace Sysman { struct SysmanDevice : _ze_device_handle_t { - static SysmanDevice *fromHandle(zes_device_handle_t handle) { return static_cast(handle); } + static SysmanDevice *fromHandle(zes_device_handle_t handle); inline zes_device_handle_t toHandle() { return this; } virtual ~SysmanDevice() = default; static SysmanDevice *create(NEO::ExecutionEnvironment &executionEnvironment, const uint32_t rootDeviceIndex); diff --git a/level_zero/sysman/source/shared/windows/zes_os_sysman_driver_imp.cpp b/level_zero/sysman/source/shared/windows/zes_os_sysman_driver_imp.cpp index fed7dc8928..49d9093955 100644 --- a/level_zero/sysman/source/shared/windows/zes_os_sysman_driver_imp.cpp +++ b/level_zero/sysman/source/shared/windows/zes_os_sysman_driver_imp.cpp @@ -1,5 +1,5 @@ /* - * Copyright (C) 2023 Intel Corporation + * Copyright (C) 2023-2024 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -23,7 +23,11 @@ ze_result_t WddmSysmanDriverImp::eventsListen(uint64_t timeout, uint32_t count, auto timeToExitLoop = L0::Sysman::SteadyClock::now() + std::chrono::duration(timeout); do { for (uint32_t devIndex = 0; devIndex < count; devIndex++) { - gotSysmanEvent = L0::Sysman::SysmanDevice::fromHandle(phDevices[devIndex])->deviceEventListen(pEvents[devIndex], timeout); + auto pSysmanDevice = L0::Sysman::SysmanDevice::fromHandle(phDevices[devIndex]); + if (pSysmanDevice == nullptr) { + return ZE_RESULT_ERROR_INVALID_ARGUMENT; + } + gotSysmanEvent = pSysmanDevice->deviceEventListen(pEvents[devIndex], timeout); if (gotSysmanEvent) { *pNumDeviceEvents = 1; break; diff --git a/level_zero/sysman/test/unit_tests/sources/events/linux/test_zes_events.cpp b/level_zero/sysman/test/unit_tests/sources/events/linux/test_zes_events.cpp index bcee682051..065efbefb6 100644 --- a/level_zero/sysman/test/unit_tests/sources/events/linux/test_zes_events.cpp +++ b/level_zero/sysman/test/unit_tests/sources/events/linux/test_zes_events.cpp @@ -178,6 +178,43 @@ TEST_F(SysmanEventsFixture, GivenPollSystemCallReturnsFailureWhenlisteningForRes delete pUdevLibLocal; } +TEST_F(SysmanEventsFixture, GivenNullDeviceHandleWhenListeningForEventsThenEventListenReturnsErrorUninitialized) { + VariableBackup mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int { + pipeFd[0] = mockReadPipeFd; + pipeFd[1] = mockWritePipeFd; + return 1; + }); + VariableBackup mockPoll(&SysCalls::sysCallsPoll, [](struct pollfd *pollFd, unsigned long int numberOfFds, int timeout) -> int { + for (uint64_t i = 0; i < numberOfFds; i++) { + if (pollFd[i].fd == mockUdevFd) { + pollFd[i].revents = POLLIN; + } + } + return 1; + }); + + auto pPublicLinuxSysmanDriverImp = std::make_unique(); + auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver; + driverHandle->pOsSysmanDriver = static_cast(pPublicLinuxSysmanDriverImp.get()); + + auto pUdevLibLocal = std::make_unique(); + int a = 0; + void *ptr = &a; // Initialize a void pointer with dummy data + pUdevLibLocal->allocateDeviceToReceiveDataResult = ptr; + + auto pUdevLibOriginal = pPublicLinuxSysmanDriverImp->pUdevLib; + pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibLocal.get(); + + std::unique_ptr phDevices(new zes_device_handle_t[1]); + phDevices[0] = nullptr; + uint32_t numDeviceEvents = 0; + std::unique_ptr pDeviceEvents(new zes_event_type_flags_t[1]); + EXPECT_EQ(ZE_RESULT_ERROR_INVALID_ARGUMENT, zesDriverEventListen(driverHandle->toHandle(), 1u, 1u, phDevices.get(), &numDeviceEvents, pDeviceEvents.get())); + + pPublicLinuxSysmanDriverImp->pUdevLib = pUdevLibOriginal; + driverHandle->pOsSysmanDriver = pOsSysmanDriverOriginal; +} + TEST_F(SysmanEventsFixture, GivenPipeSystemCallReturnsFailureWhenlisteningForResetRequiredEventThenDeviceListenReturnsResetRequiredEvent) { VariableBackup mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int { return -1; diff --git a/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h b/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h index 2541872927..e292ea7989 100644 --- a/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h +++ b/level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h @@ -126,6 +126,7 @@ class SysmanMultiDeviceFixture : public ::testing::Test { driverHandle = std::make_unique(); driverHandle->initialize(*execEnv); pSysmanDevice = driverHandle->sysmanDevices[0]; + L0::Sysman::globalSysmanDriver = driverHandle.get(); L0::Sysman::sysmanOnlyInit = true; @@ -135,6 +136,7 @@ class SysmanMultiDeviceFixture : public ::testing::Test { pLinuxSysmanImp->pFwUtilInterface = new MockFwUtilInterface(); } void TearDown() override { + L0::Sysman::globalSysmanDriver = nullptr; L0::Sysman::sysmanOnlyInit = false; } diff --git a/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp b/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp index 5bad8b0e4e..d4b0c06072 100644 --- a/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp +++ b/level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp @@ -99,6 +99,24 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserH delete tempFsAccess; } +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleWhenCallingSysmanFromHandleThenValidSysmanDeviceIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + SysmanDevice *sysmanDevice = SysmanDevice::fromHandle(validHandle); + EXPECT_NE(nullptr, sysmanDevice); + EXPECT_EQ(pSysmanDevice, sysmanDevice); +} + +TEST_F(SysmanDeviceFixture, GivenInvalidSysmanDeviceHandleWhenCallingSysmanFromHandleThenNullptrIsReturned) { + zes_device_handle_t invalidHandle = nullptr; + EXPECT_EQ(nullptr, SysmanDevice::fromHandle(invalidHandle)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleAndGivenGlobalSysmanDriverIsNullptrWhenCallingSysmanFromHandleThenValidSysmanDeviceIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + L0::Sysman::globalSysmanDriver = nullptr; + EXPECT_EQ(nullptr, SysmanDevice::fromHandle(validHandle)); +} + TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserHavingReadPermissionsThenSuccessIsReturned) { PublicFsAccess *tempFsAccess = new PublicFsAccess(); VariableBackup mockStat(&NEO::SysCalls::sysCallsStat, &mockStatSuccess); @@ -108,6 +126,78 @@ TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanReadWithUserHa delete tempFsAccess; } +TEST_F(SysmanMultiDeviceFixture, GivenInvalidSysmanDeviceHandleWhenCallingSysmanDeviceFunctionsforMultipleDevicesThenUninitializedErrorIsReturned) { + zes_device_handle_t invalidHandle = nullptr; + uint32_t count = 0; + + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::performanceGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::powerGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::powerGetCardDomain(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::frequencyGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fabricPortGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::temperatureGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::standbyGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetProperties(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetSubDeviceProperties(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::processesGetState(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceReset(invalidHandle, false)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::engineGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetProperties(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetBars(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetStats(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::schedulerGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::rasGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::memoryGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fanGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::diagnosticsGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::firmwareGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEventRegister(invalidHandle, u_int32_t(0))); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEccAvailable(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEccConfigurable(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetEccState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceSetEccState(invalidHandle, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceResetExt(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fabricPortGetMultiPortThroughput(invalidHandle, count, nullptr, nullptr)); +} + +TEST_F(SysmanDeviceFixture, GivenInvalidSysmanDeviceHandleWhenCallingSysmanDeviceFunctionsThenUninitializedErrorIsReturned) { + zes_device_handle_t invalidHandle = nullptr; + uint32_t count = 0; + + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::performanceGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::powerGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::powerGetCardDomain(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::frequencyGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fabricPortGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::temperatureGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::standbyGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetProperties(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetSubDeviceProperties(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::processesGetState(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceReset(invalidHandle, false)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::engineGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetProperties(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetBars(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetStats(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::schedulerGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::rasGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::memoryGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fanGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::diagnosticsGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::firmwareGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEventRegister(invalidHandle, u_int32_t(0))); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEccAvailable(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEccConfigurable(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetEccState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceSetEccState(invalidHandle, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceResetExt(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fabricPortGetMultiPortThroughput(invalidHandle, count, nullptr, nullptr)); +} + TEST_F(SysmanDeviceFixture, GivenPublicFsAccessClassWhenCallingCanWriteWithUserNotHavingWritePermissionsThenInsufficientIsReturned) { PublicFsAccess *tempFsAccess = new PublicFsAccess(); VariableBackup mockStat(&NEO::SysCalls::sysCallsStat, &mockStatNoPermissions); diff --git a/level_zero/sysman/test/unit_tests/sources/windows/CMakeLists.txt b/level_zero/sysman/test/unit_tests/sources/windows/CMakeLists.txt index 89bbabf44f..e5d8dcd116 100644 --- a/level_zero/sysman/test/unit_tests/sources/windows/CMakeLists.txt +++ b/level_zero/sysman/test/unit_tests/sources/windows/CMakeLists.txt @@ -14,6 +14,7 @@ if(WIN32) ${CMAKE_CURRENT_SOURCE_DIR}/mock_sysman_driver.h ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_driver.cpp ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman_manager.cpp + ${CMAKE_CURRENT_SOURCE_DIR}/test_sysman.cpp ) endif() add_subdirectories() \ No newline at end of file diff --git a/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h b/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h index 9dc780d6a1..2e0653a8ef 100644 --- a/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h +++ b/level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h @@ -46,6 +46,7 @@ class SysmanDeviceFixture : public ::testing::Test { driverHandle = std::make_unique(); driverHandle->initialize(*execEnv); pSysmanDevice = driverHandle->sysmanDevices[0]; + L0::Sysman::globalSysmanDriver = driverHandle.get(); L0::Sysman::sysmanOnlyInit = true; @@ -57,6 +58,7 @@ class SysmanDeviceFixture : public ::testing::Test { void TearDown() override { L0::Sysman::sysmanOnlyInit = false; + L0::Sysman::globalSysmanDriver = nullptr; } L0::Sysman::SysmanDevice *pSysmanDevice = nullptr; diff --git a/level_zero/sysman/test/unit_tests/sources/windows/test_sysman.cpp b/level_zero/sysman/test/unit_tests/sources/windows/test_sysman.cpp new file mode 100644 index 0000000000..8303900374 --- /dev/null +++ b/level_zero/sysman/test/unit_tests/sources/windows/test_sysman.cpp @@ -0,0 +1,108 @@ +/* + * Copyright (C) 2024 Intel Corporation + * + * SPDX-License-Identifier: MIT + * + */ + +#include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h" + +namespace L0 { +namespace Sysman { +namespace ult { + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleWhenCallingSysmanFromHandleThenValidSysmanDeviceIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + SysmanDevice *sysmanDevice = SysmanDevice::fromHandle(validHandle); + EXPECT_NE(nullptr, sysmanDevice); + EXPECT_EQ(pSysmanDevice, sysmanDevice); +} + +TEST_F(SysmanDeviceFixture, GivenInvalidSysmanDeviceHandleWhenCallingSysmanFromHandleThenNullptrIsReturned) { + zes_device_handle_t invalidHandle = nullptr; + EXPECT_EQ(nullptr, SysmanDevice::fromHandle(invalidHandle)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleAndGivenGlobalSysmanDriverIsNullptrWhenCallingSysmanFromHandleThenValidSysmanDeviceIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + L0::Sysman::globalSysmanDriver = nullptr; + EXPECT_EQ(nullptr, SysmanDevice::fromHandle(validHandle)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleAndGivenGlobalSysmanDriverIsNotNullptrWhenCallingSysmanFromHandleThenValidSysmanDeviceIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + EXPECT_EQ(pSysmanDevice, SysmanDevice::fromHandle(validHandle)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleWhenCallingDiagnosticsGetThenSuccessIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + uint32_t count = 0; + EXPECT_EQ(ZE_RESULT_SUCCESS, SysmanDevice::diagnosticsGet(validHandle, &count, nullptr)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleWhenCallingFabricPortGetThenSuccessIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + uint32_t count = 0; + zes_fabric_port_handle_t *phPort = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, SysmanDevice::fabricPortGet(validHandle, &count, phPort)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleWhenCallingPowerGetCardDomainThenUnsupportedErrorIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + zes_pwr_handle_t powerHandle = nullptr; + EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, SysmanDevice::powerGetCardDomain(validHandle, &powerHandle)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleWhenCallingSchedulerGetThenSuccessIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + uint32_t count = 0; + zes_sched_handle_t *phScheduler = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, SysmanDevice::schedulerGet(validHandle, &count, phScheduler)); +} + +TEST_F(SysmanDeviceFixture, GivenValidSysmanDeviceHandleWhenCallingStandbyGetThenSuccessIsReturned) { + zes_device_handle_t validHandle = pSysmanDevice->toHandle(); + uint32_t count = 0; + zes_standby_handle_t *phStandby = nullptr; + EXPECT_EQ(ZE_RESULT_SUCCESS, SysmanDevice::standbyGet(validHandle, &count, phStandby)); +} + +TEST_F(SysmanDeviceFixture, GivenInvalidSysmanDeviceHandleWhenCallingSysmanDeviceFunctionsThenUninitializedErrorIsReturned) { + zes_device_handle_t invalidHandle = nullptr; + uint32_t count = 0; + + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::performanceGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::powerGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::powerGetCardDomain(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::frequencyGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fabricPortGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::temperatureGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::standbyGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetProperties(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetSubDeviceProperties(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::processesGetState(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceReset(invalidHandle, false)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::engineGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetProperties(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetBars(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::pciGetStats(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::schedulerGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::rasGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::memoryGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fanGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::diagnosticsGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::firmwareGet(invalidHandle, &count, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEventRegister(invalidHandle, uint32_t(0))); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEccAvailable(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceEccConfigurable(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceGetEccState(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceSetEccState(invalidHandle, nullptr, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::deviceResetExt(invalidHandle, nullptr)); + EXPECT_EQ(ZE_RESULT_ERROR_UNINITIALIZED, SysmanDevice::fabricPortGetMultiPortThroughput(invalidHandle, count, nullptr, nullptr)); +} + +} // namespace ult +} // namespace Sysman +} // namespace L0