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