Media
/
compute-runtime
mirror of https://github.com/intel/compute-runtime.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

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 <shreyas.kunder@intel.com>
This commit is contained in:
Shreyas Kunder 2024-11-04 18:26:41 +00:00 committed by Compute-Runtime-Automation
parent 92b34f3b2c
commit f52f9753ed
11 changed files with 356 additions and 3 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
level_zero/core/test/common/ult_config_listener_l0.cpp
View File

@ -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);
}

3
level_zero/sysman/source/api/events/linux/sysman_os_events_imp.cpp
View File

@ -153,6 +153,9 @@ ze_result_t LinuxEventsUtil::eventsListen(uint64_t timeout, uint32_t count, zes_
std::vector<zes_event_type_flags_t> registeredEvents(count);
for (uint32_t devIndex = 0; devIndex < count; devIndex++) {
auto device = static_cast<SysmanDeviceImp *>(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];

104
level_zero/sysman/source/device/sysman_device.cpp
View File

@ -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 <cstring>
#include <vector>
@ -26,141 +28,237 @@ SysmanDevice *SysmanDevice::create(NEO::ExecutionEnvironment &executionEnvironme
return pSysmanDevice;
}
SysmanDevice *SysmanDevice::fromHandle(zes_device_handle_t handle) {
SysmanDevice *sysmanDevice = static_cast<SysmanDevice *>(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);
}

2
level_zero/sysman/source/device/sysman_device.h
View File

@ -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<SysmanDevice *>(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);

8
level_zero/sysman/source/shared/windows/zes_os_sysman_driver_imp.cpp
View File

@ -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<uint64_t, std::milli>(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;

37
level_zero/sysman/test/unit_tests/sources/events/linux/test_zes_events.cpp
View File

@ -178,6 +178,43 @@ TEST_F(SysmanEventsFixture, GivenPollSystemCallReturnsFailureWhenlisteningForRes
delete pUdevLibLocal;
}
TEST_F(SysmanEventsFixture, GivenNullDeviceHandleWhenListeningForEventsThenEventListenReturnsErrorUninitialized) {
VariableBackup<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
pipeFd[0] = mockReadPipeFd;
pipeFd[1] = mockWritePipeFd;
return 1;
});
VariableBackup<decltype(SysCalls::sysCallsPoll)> 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<PublicLinuxSysmanDriverImp>();
auto pOsSysmanDriverOriginal = driverHandle->pOsSysmanDriver;
driverHandle->pOsSysmanDriver = static_cast<L0::Sysman::OsSysmanDriver *>(pPublicLinuxSysmanDriverImp.get());
auto pUdevLibLocal = std::make_unique<EventsUdevLibMock>();
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<zes_device_handle_t[]> phDevices(new zes_device_handle_t[1]);
phDevices[0] = nullptr;
uint32_t numDeviceEvents = 0;
std::unique_ptr<zes_event_type_flags_t[]> 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<decltype(SysCalls::sysCallsPipe)> mockPipe(&SysCalls::sysCallsPipe, [](int pipeFd[2]) -> int {
return -1;

2
level_zero/sysman/test/unit_tests/sources/linux/mock_sysman_fixture.h
View File

@ -126,6 +126,7 @@ class SysmanMultiDeviceFixture : public ::testing::Test {
driverHandle = std::make_unique<L0::Sysman::SysmanDriverHandleImp>();
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;
}

90
level_zero/sysman/test/unit_tests/sources/linux/test_sysman.cpp
View File

@ -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<decltype(NEO::SysCalls::sysCallsStat)> 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<decltype(NEO::SysCalls::sysCallsStat)> mockStat(&NEO::SysCalls::sysCallsStat, &mockStatNoPermissions);

1
level_zero/sysman/test/unit_tests/sources/windows/CMakeLists.txt
View File

@ -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()

2
level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_fixture.h
View File

@ -46,6 +46,7 @@ class SysmanDeviceFixture : public ::testing::Test {
driverHandle = std::make_unique<L0::Sysman::SysmanDriverHandleImp>();
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;

108
level_zero/sysman/test/unit_tests/sources/windows/test_sysman.cpp Normal file
View File

@ -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