From 7a97b98cfe65ac9ad91a47dbfeab2f0a3ce515f9 Mon Sep 17 00:00:00 2001 From: shubham kumar Date: Thu, 9 Oct 2025 11:38:58 +0000 Subject: [PATCH] feature: Map PMT interface correctly on multi GPU system Related-To: NEO-15912 Signed-off-by: shubham kumar --- .../source/shared/windows/pmt/sysman_pmt.cpp | 166 +++- .../source/shared/windows/pmt/sysman_pmt.h | 15 +- .../shared/windows/pmt/sysman_pmt_helper.h | 3 +- .../shared/windows/zes_os_sysman_imp.cpp | 4 +- .../source/shared/windows/zes_os_sysman_imp.h | 1 + .../sources/memory/windows/mock_memory.h | 7 - .../unit_tests/sources/pci/windows/mock_pci.h | 8 +- .../sources/pci/windows/test_zes_pci.cpp | 6 +- .../sources/power/windows/mock_power.h | 7 - .../sysman_product_helper_memory_tests.cpp | 5 +- .../sysman_product_helper_power_tests.cpp | 15 +- ...ysman_product_helper_temperature_tests.cpp | 6 +- .../temperature/windows/mock_temperature.h | 8 - .../windows/test_zes_temperature.cpp | 3 +- .../sources/windows/mock_sysman_fixture.h | 3 +- .../unit_tests/sources/windows/pmt/mock_pmt.h | 5 +- .../sources/windows/pmt/test_pmt.cpp | 791 +++++++++++++----- .../source/os_interface/windows/sys_calls.cpp | 36 + .../source/os_interface/windows/sys_calls.h | 9 + .../os_interface/windows/windows_wrapper.h | 3 +- .../os_interface/windows/mock_sys_calls.h | 9 + .../common/os_interface/windows/sys_calls.cpp | 90 ++ 22 files changed, 933 insertions(+), 267 deletions(-) diff --git a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp index 5ddf5ffc35..ef0b73cffe 100644 --- a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp +++ b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.cpp @@ -162,24 +162,162 @@ ze_result_t PlatformMonitoringTech::init() { return result; } -std::unique_ptr PlatformMonitoringTech::create(SysmanProductHelper *pSysmanProductHelper) { - std::wstring deviceInterface; - if (enumeratePMTInterface(&PmtSysman::GuidInterfacePmtTelemetry, deviceInterface) == ZE_RESULT_SUCCESS) { - std::unique_ptr pPmt; - pPmt = std::make_unique(deviceInterface, pSysmanProductHelper); - UNRECOVERABLE_IF(nullptr == pPmt); - if (pPmt->init() != ZE_RESULT_SUCCESS) { - pPmt.reset(nullptr); - } - return pPmt; +std::unique_ptr PlatformMonitoringTech::create(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function) { + std::unique_ptr pPmt; + pPmt = std::make_unique(pSysmanProductHelper, bus, device, function); + UNRECOVERABLE_IF(nullptr == pPmt); + + if ((pPmt->getDeviceInterface() != ZE_RESULT_SUCCESS) || (pPmt->init() != ZE_RESULT_SUCCESS)) { + pPmt.reset(nullptr); + return nullptr; } - return nullptr; + return pPmt; } PlatformMonitoringTech::~PlatformMonitoringTech() { } -ze_result_t PlatformMonitoringTech::enumeratePMTInterface(const GUID *guid, std::wstring &deviceInterface) { +ze_result_t PlatformMonitoringTech::getDeviceRegistryProperty(HDEVINFO deviceInfoSet, SP_DEVINFO_DATA *pDeviceInfoData, DWORD devicePropertyType, std::vector &dataBuffer) { + + DWORD dataSizeInBytes; + + if (NEO::SysCalls::setupDiGetDeviceRegistryProperty(deviceInfoSet, pDeviceInfoData, devicePropertyType, nullptr, nullptr, 0, &dataSizeInBytes)) { + return ZE_RESULT_ERROR_UNKNOWN; + } + + dataBuffer.resize(dataSizeInBytes); + if (!NEO::SysCalls::setupDiGetDeviceRegistryProperty(deviceInfoSet, pDeviceInfoData, devicePropertyType, nullptr, dataBuffer.data(), (DWORD)dataBuffer.size(), nullptr)) { + return ZE_RESULT_ERROR_UNKNOWN; + } + + return ZE_RESULT_SUCCESS; +} + +bool PlatformMonitoringTech::isInstancePciBdfMatchingWithWddmDevice(HDEVINFO hDevInfo, SP_DEVINFO_DATA *pDeviceInfoData) { + std::vector dataBuffer; + uint32_t devicePciBus = 0; + uint32_t devicePciDevice = 0; + uint32_t devicePciFunction = 0; + + // Fetch device pci bus number + ze_result_t result = getDeviceRegistryProperty(hDevInfo, pDeviceInfoData, SPDRP_BUSNUMBER, dataBuffer); + if (result != ZE_RESULT_SUCCESS) { + return false; + } + + memcpy_s(&devicePciBus, sizeof(uint32_t), dataBuffer.data(), sizeof(uint8_t) * dataBuffer.size()); + + if (devicePciBus != this->pciBus) { + return false; + } + + dataBuffer.resize(0); + uint32_t deviceAddress = 0; + + // Fetch device pci address. This provides the pci device and function numbers + result = getDeviceRegistryProperty(hDevInfo, pDeviceInfoData, SPDRP_ADDRESS, dataBuffer); + if (result != ZE_RESULT_SUCCESS) { + return false; + } + + memcpy_s(&deviceAddress, sizeof(uint32_t), dataBuffer.data(), sizeof(uint8_t) * dataBuffer.size()); + devicePciDevice = (deviceAddress >> 16) & 0xffff; + devicePciFunction = deviceAddress & 0xffff; + + if ((devicePciDevice != this->pciDevice) || (devicePciFunction != this->pciFunction)) { + return false; + } + + return true; +} + +ze_result_t PlatformMonitoringTech::getDeviceInstanceId(DEVINST deviceInstance, std::wstring &deviceInstanceId) { + unsigned long dataSizeInBytes = 0; + + CONFIGRET result = NEO::SysCalls::cmGetDeviceIdSize(&dataSizeInBytes, deviceInstance, 0); + if (result != CR_SUCCESS) { + return ZE_RESULT_ERROR_UNKNOWN; + } + + std::vector dataBuffer(dataSizeInBytes + 1, 0); + result = NEO::SysCalls::cmGetDeviceId(deviceInstance, dataBuffer.data(), (ULONG)dataBuffer.size(), 0); + if (result != CR_SUCCESS) { + return ZE_RESULT_ERROR_UNKNOWN; + } + + deviceInstanceId = std::wstring(dataBuffer.begin(), dataBuffer.end() - 1); + return ZE_RESULT_SUCCESS; +} + +void PlatformMonitoringTech::getAllChildDeviceInterfaces(HDEVINFO hDevInfo, DEVINST deviceInstance, uint32_t level, std::vector &deviceInstanceIdList) { + + // According to Microsoft's guide we need to follow the below steps to find all the children for a device instance. + // Call the CM_Get_Child function to retrieve a device instance handle to the first child device that is associated with a device instance. + // Call CM_Get_Sibling as many times as it is necessary to enumerate all the sibling devices of the first child device that was retrieved by the call to CM_Get_Child. + // Call CM_Get_Device_ID to retrieve the device instance identifiers that are associated with the device instance handles that were returned by the calls to CM_Get_Child and CM_Get_Sibling. + + std::wstring deviceInstanceId; + if ((getDeviceInstanceId(deviceInstance, deviceInstanceId) != ZE_RESULT_SUCCESS) || deviceInstanceId.empty()) { + return; + } + + if (level > 1) { + deviceInstanceIdList.push_back(deviceInstanceId); + } + + // Get the SP_DEVINFO_DATA for the device + SP_DEVINFO_DATA deviceInfoData = {}; + deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA); + if (!NEO::SysCalls::setupDiOpenDeviceInfo(hDevInfo, deviceInstanceId.c_str(), nullptr, 0, &deviceInfoData)) { + return; + } + + DEVINST childDeviceInstance = 0; + if (NEO::SysCalls::cmGetChild(&childDeviceInstance, deviceInstance, 0) == CR_SUCCESS) { + getAllChildDeviceInterfaces(hDevInfo, childDeviceInstance, level + 1, deviceInstanceIdList); + + DEVINST siblingDeviceInstance; + while (NEO::SysCalls::cmGetSibling(&siblingDeviceInstance, childDeviceInstance, 0) == CR_SUCCESS) { + getAllChildDeviceInterfaces(hDevInfo, siblingDeviceInstance, level + 1, deviceInstanceIdList); + childDeviceInstance = siblingDeviceInstance; + } + } +} + +ze_result_t PlatformMonitoringTech::getDeviceInterface() { + std::wstring pmtDeviceInstanceId; + GUID displayAdapter = PmtSysman::GuidIntefaceDisplayAdapter; + GUID pmtTelemetry = PmtSysman::GuidIntefacePmtTelemetry; + + HDEVINFO hDevInfo = NEO::SysCalls::setupDiGetClassDevs(&displayAdapter, NULL, NULL, DIGCF_PRESENT); + if (hDevInfo == INVALID_HANDLE_VALUE) { + DEBUG_BREAK_IF(true); + return ZE_RESULT_ERROR_UNKNOWN; + } + + SP_DEVINFO_DATA deviceInfoData = {}; + deviceInfoData.cbSize = sizeof(SP_DEVINFO_DATA); + for (DWORD i = 0; NEO::SysCalls::setupDiEnumDeviceInfo(hDevInfo, i, &deviceInfoData); i++) { + if (isInstancePciBdfMatchingWithWddmDevice(hDevInfo, &deviceInfoData)) { + std::vector deviceInstanceIdList; + + // Get all child devices + getAllChildDeviceInterfaces(hDevInfo, deviceInfoData.DevInst, 1, deviceInstanceIdList); + + // Find the PMT device instance ID + for (auto &deviceInstanceId : deviceInstanceIdList) { + if (deviceInstanceId.find(L"INTC_PMT") != std::wstring::npos) { + pmtDeviceInstanceId = deviceInstanceId; + break; + } + } + break; + } + } + + if (NEO::SysCalls::setupDiDestroyDeviceInfoList(hDevInfo) == FALSE) { + return ZE_RESULT_ERROR_UNKNOWN; + } unsigned long cmListCharCount = 0; CONFIGRET status = CR_SUCCESS; @@ -188,7 +326,7 @@ ze_result_t PlatformMonitoringTech::enumeratePMTInterface(const GUID *guid, std: do { // Get the total size of list of all instances // N.B. Size returned is total length in "characters" - status = NEO::SysCalls::cmGetDeviceInterfaceListSize(&cmListCharCount, (LPGUID)guid, NULL, CM_GET_DEVICE_INTERFACE_LIST_PRESENT); + status = NEO::SysCalls::cmGetDeviceInterfaceListSize(&cmListCharCount, (LPGUID)&pmtTelemetry, &pmtDeviceInstanceId[0], CM_GET_DEVICE_INTERFACE_LIST_PRESENT); if (status != CR_SUCCESS) { break; @@ -207,7 +345,7 @@ ze_result_t PlatformMonitoringTech::enumeratePMTInterface(const GUID *guid, std: return ZE_RESULT_ERROR_UNKNOWN; } // N.B. cmListCharCount is length in characters - status = NEO::SysCalls::cmGetDeviceInterfaceList((LPGUID)guid, NULL, deviceInterfaceList.data(), cmListCharCount, CM_GET_DEVICE_INTERFACE_LIST_PRESENT); + status = NEO::SysCalls::cmGetDeviceInterfaceList((LPGUID)&pmtTelemetry, &pmtDeviceInstanceId[0], deviceInterfaceList.data(), cmListCharCount, CM_GET_DEVICE_INTERFACE_LIST_PRESENT); } while (status == CR_BUFFER_SMALL); if (status != CR_SUCCESS) { diff --git a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h index 6639a96570..4341c58024 100644 --- a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h +++ b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h @@ -26,19 +26,24 @@ class SysmanProductHelper; class PlatformMonitoringTech : NEO::NonCopyableAndNonMovableClass { public: PlatformMonitoringTech() = delete; - PlatformMonitoringTech(std::wstring deviceInterface, SysmanProductHelper *pSysmanProductHelper) : deviceInterface(std::move(deviceInterface)), pSysmanProductHelper(pSysmanProductHelper) {} + PlatformMonitoringTech(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function) : pSysmanProductHelper(pSysmanProductHelper), pciBus(bus), pciDevice(device), pciFunction(function) {} virtual ~PlatformMonitoringTech(); virtual ze_result_t readValue(const std::string &key, uint32_t &value); virtual ze_result_t readValue(const std::string &key, uint64_t &value); ze_result_t getKeyOffsetMap(std::map> &keyOffsetMap); - static std::unique_ptr create(SysmanProductHelper *pSysmanProductHelper); - static ze_result_t enumeratePMTInterface(const GUID *Guid, std::wstring &deviceInterface); + static std::unique_ptr create(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function); protected: + std::wstring deviceInterface; std::map> keyOffsetMap; unsigned long guidToIndexList[PmtSysman::PmtMaxInterfaces] = {0}; ze_result_t ioctlReadWriteData(std::wstring &path, uint32_t ioctl, void *bufferIn, uint32_t inSize, void *bufferOut, uint32_t outSize, uint32_t *sizeReturned); + ze_result_t getDeviceInterface(); + ze_result_t getDeviceRegistryProperty(HDEVINFO deviceInfoSet, SP_DEVINFO_DATA *pDeviceInfoData, DWORD devicePropertyType, std::vector &dataBuffer); + bool isInstancePciBdfMatchingWithWddmDevice(HDEVINFO hDevInfo, SP_DEVINFO_DATA *pDeviceInfoData); + ze_result_t getDeviceInstanceId(DEVINST deviceInstance, std::wstring &deviceInstanceId); + void getAllChildDeviceInterfaces(HDEVINFO hDevInfo, DEVINST deviceInstance, uint32_t level, std::vector &interfacePathList); virtual ze_result_t init(); ze_result_t getGuid(); decltype(&NEO::SysCalls::deviceIoControl) pdeviceIoControl = NEO::SysCalls::deviceIoControl; @@ -48,9 +53,11 @@ class PlatformMonitoringTech : NEO::NonCopyableAndNonMovableClass { decltype(&NEO::SysCalls::heapFree) heapFreeFunction = NEO::SysCalls::heapFree; private: - std::wstring deviceInterface; SysmanProductHelper *pSysmanProductHelper = nullptr; uint32_t baseOffset = 0; + uint32_t pciBus; + uint32_t pciDevice; + uint32_t pciFunction; }; } // namespace Sysman diff --git a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt_helper.h b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt_helper.h index 722ceae2a2..a654055aed 100644 --- a/level_zero/sysman/source/shared/windows/pmt/sysman_pmt_helper.h +++ b/level_zero/sysman/source/shared/windows/pmt/sysman_pmt_helper.h @@ -20,7 +20,8 @@ constexpr uint32_t MethodBuffered = 0; constexpr uint32_t FileReadAccess = 0x0001; // Intel PMT Telemetry Interface GUID {3dfb2563-5c44-4c59-8d80-baea7d06e6b8} -constexpr GUID GuidInterfacePmtTelemetry = {0x3dfb2563, 0x5c44, 0x4c59, {0x8d, 0x80, 0xba, 0xea, 0x7d, 0x06, 0xe6, 0xb8}}; +constexpr GUID GuidIntefacePmtTelemetry = {0x3dfb2563, 0x5c44, 0x4c59, {0x8d, 0x80, 0xba, 0xea, 0x7d, 0x06, 0xe6, 0xb8}}; +constexpr GUID GuidIntefaceDisplayAdapter = {0x4d36e968, 0xe325, 0x11ce, {0xbf, 0xc1, 0x08, 0x00, 0x2b, 0xe1, 0x03, 0x18}}; inline constexpr uint32_t getCtlCode(uint32_t code) { return CTL_CODE(FileDeviceIntelPmt, code, MethodBuffered, FileReadAccess); diff --git a/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.cpp b/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.cpp index 8df8bfb1e3..363fb70f2e 100644 --- a/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.cpp +++ b/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.cpp @@ -52,7 +52,8 @@ ze_result_t WddmSysmanImp::init() { } } - pPmt = PlatformMonitoringTech::create(pSysmanProductHelper.get()); + pciBusInfo = pParentSysmanDeviceImp->getRootDeviceEnvironment().osInterface->getDriverModel()->getPciBusInfo(); + pPmt = PlatformMonitoringTech::create(pSysmanProductHelper.get(), pciBusInfo.pciBus, pciBusInfo.pciDevice, pciBusInfo.pciFunction); return ZE_RESULT_SUCCESS; } @@ -74,7 +75,6 @@ PlatformMonitoringTech *WddmSysmanImp::getSysmanPmt() { } void WddmSysmanImp::createFwUtilInterface() { - const auto pciBusInfo = pParentSysmanDeviceImp->getRootDeviceEnvironment().osInterface->getDriverModel()->getPciBusInfo(); const uint16_t domain = static_cast(pciBusInfo.pciDomain); const uint8_t bus = static_cast(pciBusInfo.pciBus); const uint8_t device = static_cast(pciBusInfo.pciDevice); diff --git a/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h b/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h index b153219d47..e29395f534 100644 --- a/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h +++ b/level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h @@ -62,6 +62,7 @@ class WddmSysmanImp : public OsSysman, NEO::NonCopyableAndNonMovableClass { } uuid; private: + NEO::PhysicalDevicePciBusInfo pciBusInfo; SysmanDeviceImp *pParentSysmanDeviceImp = nullptr; NEO::Wddm *pWddm = nullptr; uint32_t subDeviceCount = 0; diff --git a/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h b/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h index 2a9c435da5..35cf89c81a 100644 --- a/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h +++ b/level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory.h @@ -11,7 +11,6 @@ #include "level_zero/sysman/source/api/memory/sysman_memory_imp.h" #include "level_zero/sysman/source/api/memory/windows/sysman_os_memory_imp.h" -#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h" #include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h" #include "level_zero/sysman/test/unit_tests/sources/memory/windows/mock_memory_manager.h" #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h" @@ -205,12 +204,6 @@ class PublicWddmPowerImp : public L0::Sysman::WddmMemoryImp { using WddmMemoryImp::pKmdSysManager; }; -class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech { - public: - PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {} - using PlatformMonitoringTech::keyOffsetMap; -}; - struct MockSysmanProductHelperMemory : L0::Sysman::SysmanProductHelperHw { MockSysmanProductHelperMemory() = default; ADDMETHOD_NOBASE(getMemoryBandWidth, ze_result_t, ZE_RESULT_SUCCESS, (zes_mem_bandwidth_t * pBandwidth, WddmSysmanImp *pWddmSysmanImp)); diff --git a/level_zero/sysman/test/unit_tests/sources/pci/windows/mock_pci.h b/level_zero/sysman/test/unit_tests/sources/pci/windows/mock_pci.h index c2aad37364..89ff042e66 100644 --- a/level_zero/sysman/test/unit_tests/sources/pci/windows/mock_pci.h +++ b/level_zero/sysman/test/unit_tests/sources/pci/windows/mock_pci.h @@ -8,7 +8,6 @@ #pragma once #include "level_zero/sysman/source/api/pci/sysman_pci_imp.h" #include "level_zero/sysman/source/api/pci/windows/sysman_os_pci_imp.h" -#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h" #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h" namespace L0 { @@ -125,12 +124,6 @@ struct PciKmdSysManager : public MockKmdSysManager { } }; -class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech { - public: - PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {} - using PlatformMonitoringTech::keyOffsetMap; -}; - class PciWddmSysmanImp : public L0::Sysman::WddmSysmanImp { public: PciWddmSysmanImp(SysmanDeviceImp *pParentSysmanDeviceImp) : WddmSysmanImp(pParentSysmanDeviceImp) {} @@ -163,6 +156,7 @@ class PciWddmSysmanImp : public L0::Sysman::WddmSysmanImp { return pPciBdfInfo; } }; + } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/pci/windows/test_zes_pci.cpp b/level_zero/sysman/test/unit_tests/sources/pci/windows/test_zes_pci.cpp index 7efcc326f6..7b0a96c5fb 100644 --- a/level_zero/sysman/test/unit_tests/sources/pci/windows/test_zes_pci.cpp +++ b/level_zero/sysman/test/unit_tests/sources/pci/windows/test_zes_pci.cpp @@ -31,12 +31,11 @@ const std::map> dummyKeyOffsetMap = { {"GDDR_TELEM_CAPTURE_TIMESTAMP_UPPER", {92, 1}}, {"GDDR_TELEM_CAPTURE_TIMESTAMP_LOWER", {93, 1}}}}; -const std::wstring deviceInterfacePci = L"TEST\0"; - class SysmanDevicePciFixture : public SysmanDeviceFixture { protected: std::unique_ptr pKmdSysManager = nullptr; KmdSysManager *pOriginalKmdSysManager = nullptr; + PublicPlatformMonitoringTech *pPmt = nullptr; void SetUp() override { SysmanDeviceFixture::SetUp(); @@ -46,8 +45,9 @@ class SysmanDevicePciFixture : public SysmanDeviceFixture { pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager; pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get(); - auto pPmt = new PublicPlatformMonitoringTech(deviceInterfacePci, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); pPmt->keyOffsetMap = dummyKeyOffsetMap; + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pWddmSysmanImp->pPmt.reset(pPmt); delete pSysmanDeviceImp->pPci; diff --git a/level_zero/sysman/test/unit_tests/sources/power/windows/mock_power.h b/level_zero/sysman/test/unit_tests/sources/power/windows/mock_power.h index 9a34ef5cdf..1185d8a4dc 100644 --- a/level_zero/sysman/test/unit_tests/sources/power/windows/mock_power.h +++ b/level_zero/sysman/test/unit_tests/sources/power/windows/mock_power.h @@ -7,7 +7,6 @@ #pragma once -#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h" #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h" namespace L0 { @@ -226,12 +225,6 @@ struct PowerKmdSysManager : public MockKmdSysManager { } }; -class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech { - public: - PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {} - using PlatformMonitoringTech::keyOffsetMap; -}; - } // namespace ult } // namespace Sysman } // namespace L0 diff --git a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp index b8ccceda0a..5d8d979bb9 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp +++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_memory_tests.cpp @@ -63,11 +63,11 @@ const std::map> dummyKeyOffsetMap = { {"GDDR0_CH1_GT_64B_WR_REQ_UPPER", {120, 1}}, {"GDDR0_CH1_GT_64B_WR_REQ_LOWER", {121, 1}}}}; -const std::wstring deviceInterfaceMemory = L"TEST\0"; class SysmanDeviceMemoryHelperFixture : public SysmanDeviceFixture { protected: std::unique_ptr pKmdSysManager; L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr; + PublicPlatformMonitoringTech *pPmt = nullptr; void SetUp() override { SysmanDeviceFixture::SetUp(); @@ -79,8 +79,9 @@ class SysmanDeviceMemoryHelperFixture : public SysmanDeviceFixture { pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager; pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get(); - auto pPmt = new PublicPlatformMonitoringTech(deviceInterfaceMemory, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); pPmt->keyOffsetMap = dummyKeyOffsetMap; + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pWddmSysmanImp->pPmt.reset(pPmt); pSysmanDeviceImp->pMemoryHandleContext->handleList.clear(); diff --git a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_power_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_power_tests.cpp index 3c0aa4c6ba..4a54ab1db9 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_power_tests.cpp +++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_power_tests.cpp @@ -18,8 +18,6 @@ namespace L0 { namespace Sysman { namespace ult { -const std::wstring pmtInterfacePower = L"TEST\0"; - const std::map> dummyKeyOffsetMap = { {{"XTAL_CLK_FREQUENCY", {1, 0}}, {"XTAL_COUNT", {128, 0}}, @@ -46,6 +44,7 @@ class SysmanProductHelperPowerTest : public SysmanDeviceFixture { protected: std::unique_ptr pKmdSysManager; L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr; + PublicPlatformMonitoringTech *pPmt = nullptr; void SetUp() override { SysmanDeviceFixture::SetUp(); @@ -61,15 +60,9 @@ class SysmanProductHelperPowerTest : public SysmanDeviceFixture { delete handle; } - auto pPmt = new PublicPlatformMonitoringTech(pmtInterfacePower, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); pPmt->keyOffsetMap = dummyKeyOffsetMap; - pWddmSysmanImp->pPmt.reset(pPmt); - pSysmanDeviceImp->pPowerHandleContext->handleList.clear(); - } - - void updatePmtKeyOffsetMap(const std::map> keyOffsetMap) { - auto pPmt = new PublicPlatformMonitoringTech(pmtInterfacePower, pWddmSysmanImp->getSysmanProductHelper()); - pPmt->keyOffsetMap = keyOffsetMap; + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pWddmSysmanImp->pPmt.reset(pPmt); pSysmanDeviceImp->pPowerHandleContext->handleList.clear(); } @@ -188,7 +181,7 @@ HWTEST2_F(SysmanProductHelperPowerTest, GivenValidPowerHandleWhenGettingPowerEne }); // Setting allow set calls or not init(true); - updatePmtKeyOffsetMap(dummyKeyOffsetMapToGetEnergyCounterFromPunit); + pPmt->keyOffsetMap = dummyKeyOffsetMapToGetEnergyCounterFromPunit; // Calculate the expected energy counter value from the mockPmtEnergyCounterVariableFromOobmsmBackupValue uint32_t integerPart = static_cast(mockPmtEnergyCounterVariableFromOobmsmBackupValue >> 14); diff --git a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_temperature_tests.cpp b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_temperature_tests.cpp index 9f2b601b1e..aa22de7f9a 100644 --- a/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_temperature_tests.cpp +++ b/level_zero/sysman/test/unit_tests/sources/shared/windows/product_helper/sysman_product_helper_temperature_tests.cpp @@ -17,7 +17,6 @@ namespace L0 { namespace Sysman { namespace ult { -std::wstring pmtInterface = std::move(pmtInterfaceName); const std::map> dummyKeyOffsetMap = { {{"SOC_THERMAL_SENSORS_TEMPERATURE_0_2_0_GTTMMADR[1]", {41, 1}}, {"VRAM_TEMPERATURE_0_2_0_GTTMMADR", {42, 1}}}}; @@ -28,6 +27,7 @@ class SysmanProductHelperTemperatureTest : public SysmanDeviceFixture { std::unique_ptr pKmdSysManager = nullptr; L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr; std::vector deviceHandles; + PublicPlatformMonitoringTech *pPmt = nullptr; void SetUp() override { SysmanDeviceFixture::SetUp(); @@ -36,8 +36,10 @@ class SysmanProductHelperTemperatureTest : public SysmanDeviceFixture { pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager; pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get(); - auto pPmt = new PublicPlatformMonitoringTech(pmtInterface, pWddmSysmanImp->getSysmanProductHelper()); + + pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); pPmt->keyOffsetMap = dummyKeyOffsetMap; + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pWddmSysmanImp->pPmt.reset(pPmt); pSysmanDeviceImp->pTempHandleContext->handleList.clear(); diff --git a/level_zero/sysman/test/unit_tests/sources/temperature/windows/mock_temperature.h b/level_zero/sysman/test/unit_tests/sources/temperature/windows/mock_temperature.h index b9b22ce8ce..5e78c8cb32 100644 --- a/level_zero/sysman/test/unit_tests/sources/temperature/windows/mock_temperature.h +++ b/level_zero/sysman/test/unit_tests/sources/temperature/windows/mock_temperature.h @@ -10,7 +10,6 @@ #include "shared/test/common/test_macros/mock_method_macros.h" #include "level_zero/sysman/source/api/temperature/sysman_temperature_imp.h" -#include "level_zero/sysman/source/shared/windows/pmt/sysman_pmt.h" #include "level_zero/sysman/source/shared/windows/product_helper/sysman_product_helper_hw.h" #include "level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h" #include "level_zero/sysman/test/unit_tests/sources/windows/mock_kmd_sys_manager.h" @@ -19,7 +18,6 @@ namespace L0 { namespace Sysman { namespace ult { -const std::wstring pmtInterfaceName = L"TEST\0"; constexpr uint32_t temperatureHandleComponentCount = 3u; struct TemperatureKmdSysManager : public MockKmdSysManager { @@ -99,12 +97,6 @@ struct TemperatureKmdSysManager : public MockKmdSysManager { } }; -class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech { - public: - PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {} - using PlatformMonitoringTech::keyOffsetMap; -}; - struct MockSysmanProductHelperTemp : L0::Sysman::SysmanProductHelperHw { MockSysmanProductHelperTemp() = default; ADDMETHOD_NOBASE(getSensorTemperature, ze_result_t, ZE_RESULT_SUCCESS, (double *pTemperature, zes_temp_sensors_t type, WddmSysmanImp *pWddmSysmanImp)); diff --git a/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp b/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp index 81e12662aa..e9fd146fb3 100644 --- a/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp +++ b/level_zero/sysman/test/unit_tests/sources/temperature/windows/test_zes_temperature.cpp @@ -20,7 +20,6 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture { L0::Sysman::KmdSysManager *pOriginalKmdSysManager = nullptr; std::vector deviceHandles; void SetUp() override { - std::wstring deviceInterfacePmt = std::move(pmtInterfaceName); SysmanDeviceFixture::SetUp(); pKmdSysManager.reset(new TemperatureKmdSysManager); @@ -29,7 +28,7 @@ class SysmanDeviceTemperatureFixture : public SysmanDeviceFixture { pOriginalKmdSysManager = pWddmSysmanImp->pKmdSysManager; pWddmSysmanImp->pKmdSysManager = pKmdSysManager.get(); - auto pPmt = new PublicPlatformMonitoringTech(deviceInterfacePmt, pWddmSysmanImp->getSysmanProductHelper()); + auto pPmt = new PublicPlatformMonitoringTech(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); pWddmSysmanImp->pPmt.reset(pPmt); pSysmanDeviceImp->pTempHandleContext->handleList.clear(); 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 2e0653a8ef..21eff5b54b 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 @@ -1,5 +1,5 @@ /* - * Copyright (C) 2020-2024 Intel Corporation + * Copyright (C) 2020-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -14,6 +14,7 @@ #include "level_zero/sysman/source/shared/windows/zes_os_sysman_imp.h" #include "level_zero/sysman/test/unit_tests/sources/firmware_util/mock_fw_util_fixture.h" #include "level_zero/sysman/test/unit_tests/sources/windows/mock_sysman_wddm.h" +#include "level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h" #include "gtest/gtest.h" diff --git a/level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h b/level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h index a6a545cd56..3f5051dbe1 100644 --- a/level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h +++ b/level_zero/sysman/test/unit_tests/sources/windows/pmt/mock_pmt.h @@ -15,9 +15,12 @@ namespace L0 { namespace Sysman { namespace ult { +const std::wstring deviceInterface = L"TEST_INTC_PMT\0"; + class PublicPlatformMonitoringTech : public L0::Sysman::PlatformMonitoringTech { public: - PublicPlatformMonitoringTech(std::wstring deviceInterfaceList, SysmanProductHelper *pSysmanProductHelper) : PlatformMonitoringTech(deviceInterfaceList, pSysmanProductHelper) {} + PublicPlatformMonitoringTech(SysmanProductHelper *pSysmanProductHelper, uint32_t bus, uint32_t device, uint32_t function) : PlatformMonitoringTech(pSysmanProductHelper, bus, device, function) {} + using PlatformMonitoringTech::deviceInterface; using PlatformMonitoringTech::keyOffsetMap; using PlatformMonitoringTech::pcreateFile; using PlatformMonitoringTech::pdeviceIoControl; diff --git a/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp b/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp index d40eb65aef..970406a824 100644 --- a/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp +++ b/level_zero/sysman/test/unit_tests/sources/windows/pmt/test_pmt.cpp @@ -16,7 +16,10 @@ namespace L0 { namespace Sysman { namespace ult { -const std::wstring deviceInterface = L"TEST_INTC_PMT\0"; +static uint32_t sysCallsCmGetChildCount = 1; +static uint32_t sysCallsCmGetSiblingCount = 1; +static uint32_t createCallCount = 2; +static int sysCallsInterfaceListCounter = 0; const std::map> dummyKeyOffsetMap = { {"DUMMY_KEY", {0x0, 1}}}; @@ -31,13 +34,86 @@ inline static BOOL mockDeviceIoControlSuccess(HANDLE hDevice, DWORD dwIoControlC return true; } +inline static BOOL mockDeviceIoControlExtendedSuccess(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) { + if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { + *static_cast(lpOutBuffer) = 40; + } else if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) { + PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}}; + *static_cast(lpOutBuffer) = temp; + } + return true; +} + +inline static CONFIGRET mockCmGetDeviceInterfaceListSizeSuccess(PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) { + if (pDeviceID[0] != L'\0') { + *pulLen = 40; + return CR_SUCCESS; + } + return CR_FAILURE; +} + +inline static CONFIGRET mockCmGetDeviceInterfaceListSuccess(LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) { + wcscpy(buffer, L"TEST_INTC_PMT"); + return CR_SUCCESS; +} + +inline static CONFIGRET mockCmGetDeviceIdSizeSuccess(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) { + *pulLen = 40; + return CR_SUCCESS; +} + +inline static CONFIGRET mockCmGetDeviceIdSuccess(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) { + wcscpy(buffer, L"TEST_INTC_PMT"); + return CR_SUCCESS; +} + +inline static BOOL mockSetupDiGetDeviceRegistryPropertySuccess(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) { + if (requiredSize != nullptr) { + *requiredSize = 0x1; + return false; + } + *propertyBuffer = 0u; + return true; +} + +inline static CONFIGRET mockCmGetChildSuccess(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) { + if (sysCallsCmGetChildCount) { + sysCallsCmGetChildCount--; + return CR_SUCCESS; + } + return CR_FAILURE; +} + +inline static CONFIGRET mockCmGetSiblingSuccess(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) { + if (sysCallsCmGetSiblingCount) { + sysCallsCmGetSiblingCount--; + return CR_SUCCESS; + } + return CR_FAILURE; +} + +inline static BOOL mockSetupDiEnumDeviceInfoSuccess(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) { + return true; +} + +inline static BOOL mockSetupDiOpenDeviceInfoSuccess(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) { + return true; +} + +inline static BOOL mockSetupDiDestroyDeviceInfoListSuccess(HDEVINFO deviceInfoSet) { + return true; +} + +inline static HDEVINFO mockSetupDiGetClassDevsSuccess(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) { + return reinterpret_cast(static_cast(0x1)); +} + class SysmanDevicePmtFixture : public SysmanDeviceFixture { protected: std::unique_ptr pPmt; void SetUp() override { SysmanDeviceFixture::SetUp(); - std::wstring deviceInterface; - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); } void TearDown() override { @@ -46,13 +122,11 @@ class SysmanDevicePmtFixture : public SysmanDeviceFixture { }; TEST_F(SysmanDevicePmtFixture, GivenWrongKeyWhenCallingReadValueWithUint32TypeThenCallFails) { - uint32_t val = 0; EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("SOMETHING", val)); } TEST_F(SysmanDevicePmtFixture, GivenWrongKeyWhenCallingReadValueWithUint64TypeThenCallFails) { - uint64_t val = 0; EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("SOMETHING", val)); } @@ -67,7 +141,8 @@ TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtHandleWhenCallingReadValue32CallFa VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { return INVALID_HANDLE_VALUE; }); - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; uint32_t val = 0; pPmt->keyOffsetMap = dummyKeyOffsetMap; EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); @@ -77,22 +152,25 @@ TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtHandleWhenCallingReadValue64CallFa VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { return INVALID_HANDLE_VALUE; }); - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; uint64_t val = 0; pPmt->keyOffsetMap = dummyKeyOffsetMap; EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); } TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32WhenIoctlCallFailsThenProperErrorIsReturned) { - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pPmt->pcreateFile = mockCreateFileSuccess; uint32_t val = 0; pPmt->keyOffsetMap = dummyKeyOffsetMap; EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); } -TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32TypeWhenIoctlCallSucceedsThenreadValueReturned) { - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); +TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32TypeWhenIoctlCallSucceedsThenReadValueReturned) { + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pPmt->pcreateFile = mockCreateFileSuccess; pPmt->pdeviceIoControl = mockDeviceIoControlSuccess; @@ -108,7 +186,8 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint32 *static_cast(lpOutBuffer) = 4; return true; }); - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pPmt->pcreateFile = mockCreateFileSuccess; uint32_t val = 0; @@ -122,7 +201,8 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64 *static_cast(lpOutBuffer) = 4; return true; }); - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pPmt->pcreateFile = mockCreateFileSuccess; uint64_t val = 0; @@ -130,8 +210,9 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64 EXPECT_EQ(ZE_RESULT_ERROR_UNKNOWN, pPmt->readValue("DUMMY_KEY", val)); } -TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingreadValueWithUint64TypeAndIoctlCallSucceedsThenreadValueReturned) { - pPmt = std::make_unique(deviceInterface, pWddmSysmanImp->getSysmanProductHelper()); +TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingReadValueWithUint64TypeAndIoctlCallSucceedsThenreadValueReturned) { + pPmt = std::make_unique(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + pPmt->deviceInterface = L0::Sysman::ult::deviceInterface; pPmt->pcreateFile = mockCreateFileSuccess; pPmt->pdeviceIoControl = mockDeviceIoControlSuccess; uint64_t val = 0; @@ -141,7 +222,7 @@ TEST_F(SysmanDevicePmtFixture, GivenValidPmtHandleWhenCallingreadValueWithUint64 } TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtInterfaceWhenCallingCreateThenCallReturnsNullPtr) { - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } @@ -150,135 +231,130 @@ TEST_F(SysmanDevicePmtFixture, GivenInvalidPmtInterfaceWhenCallingGetSysmanPmtTh EXPECT_EQ(nullptr, pPmt); } -TEST_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWithUnsupportedGuidWhenCallingGetSysmanPmtThenCallReturnsNullPtr) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); - VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { - if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { - *static_cast(lpOutBuffer) = 40; - } else if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) { - PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}}; - *static_cast(lpOutBuffer) = temp; - } - return true; - }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); +TEST_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWithUnsupportedGuidWhenCallingCreateThenCallReturnsNullPtr) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + struct MockSysmanProductHelperPmt : L0::Sysman::SysmanProductHelperHw { MockSysmanProductHelperPmt() = default; }; std::unique_ptr pSysmanProductHelper = std::make_unique(); std::swap(pWddmSysmanImp->pSysmanProductHelper, pSysmanProductHelper); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateThenCallSucceeds, IsBMG) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); - VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { - if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { - *static_cast(lpOutBuffer) = 40; - } else if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) { - PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}}; - *static_cast(lpOutBuffer) = temp; - } - return true; - }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_NE(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenInValidPmtInterfaceNameWhenCallingCreateThenCallFails, IsBMG) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); - VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { - if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { - *static_cast(lpOutBuffer) = 40; - } else if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) { - PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}}; - *static_cast(lpOutBuffer) = temp; - } - return true; - }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { wcscpy(buffer, L"TEST_WRONG_INTERFACE"); return CR_SUCCESS; }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateWithNoGuidsFoundThenCallFails, IsBMG) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { *static_cast(lpOutBuffer) = 40; } return true; }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemtrySizeIsZeroThenCallFails, IsBMG) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { *static_cast(lpOutBuffer) = 0; } return true; }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemtryDiscoveryFailsThenCallFails, IsBMG) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { *static_cast(lpOutBuffer) = 40; @@ -287,53 +363,48 @@ HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTele } return true; }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemtryDiscoveryFailsThenCallFailsCoveringNewBranch, IsBMG) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateThenCallSucceedsCoveringNewBranch, IsBMG) { - VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); - VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { - if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { - *static_cast(lpOutBuffer) = 40; - } else if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) { - PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}}; - *static_cast(lpOutBuffer) = temp; - } - return true; - }); - VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + sysCallsInterfaceListCounter = 0; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - static int sysCallsInterfaceListCounter = 0; if (sysCallsInterfaceListCounter) { wcscpy(buffer, L"TEST_INTC_PMT"); return CR_SUCCESS; @@ -341,66 +412,105 @@ HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateThenCal sysCallsInterfaceListCounter++; return CR_BUFFER_SMALL; }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_NE(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenInValidPmtInterfaceWhenCallingCreateThenCallFails, IsBMG) { - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceInterfaceListFailsThenCallFails, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 4; - return CR_SUCCESS; + if (pDeviceID[0] != L'\0') { + *pulLen = 4; + return CR_SUCCESS; + } + return CR_FAILURE; }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceInterfaceListSizeReturnZeroThenCallFails, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 0; - return CR_SUCCESS; + if (pDeviceID[0] != L'\0') { + *pulLen = 0; + return CR_SUCCESS; + } + return CR_FAILURE; }); VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { return CR_SUCCESS; }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndHeapAllocFailsThenCreateCallFails, IsBMG) { - VariableBackup mockCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); VariableBackup mockDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { *static_cast(lpOutBuffer) = 40; } return true; }); - VariableBackup mockCmGetDeviceInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup mockCmGetDeviceInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); VariableBackup mockHeapAlloc(&NEO::SysCalls::sysCallsHeapAlloc, [](HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) -> LPVOID { return nullptr; }); - - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTelemetryIndexIsGreaterThanTotalPmtInterfacesThenCreateCallFails, IsBMG) { - VariableBackup mockCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); VariableBackup mockDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { *static_cast(lpOutBuffer) = 40; @@ -411,43 +521,336 @@ HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndTele } return true; }); - VariableBackup mockCmGetDeviceInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup mockCmGetDeviceInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndHeapFreeCallFailsThenCreateCallFails, IsBMG) { - VariableBackup mockCreateFile(&NEO::SysCalls::sysCallsCreateFile, [](LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, LPSECURITY_ATTRIBUTES lpSecurityAttributes, DWORD dwCreationDisposition, DWORD dwFlagsAndAttributes, HANDLE hTemplateFile) -> HANDLE { - return reinterpret_cast(static_cast(0x7)); - }); - VariableBackup mockDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, [](HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped) -> BOOL { - if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscoverySize) { - *static_cast(lpOutBuffer) = 40; - } else if (static_cast(dwIoControlCode) == PmtSysman::IoctlPmtGetTelemetryDiscovery) { - PmtSysman::PmtTelemetryDiscovery temp = {1, 2, {{1, 1, 0x5e2f8210, 10}}}; - *static_cast(lpOutBuffer) = temp; - } - return true; - }); - VariableBackup mockCmGetDeviceInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, [](PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags) -> CONFIGRET { - *pulLen = 40; - return CR_SUCCESS; - }); - VariableBackup mockCmGetDeviceInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, [](LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { - wcscpy(buffer, L"TEST_INTC_PMT"); - return CR_SUCCESS; - }); + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); VariableBackup mocksHeapFree(&NEO::SysCalls::sysCallsHeapFree, [](HANDLE hHeap, DWORD dwFlags, LPVOID lpMem) -> BOOL { return false; }); - std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper()); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiGetClassDevsCallFailsThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, [](GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) -> HDEVINFO { + return reinterpret_cast(INVALID_HANDLE_VALUE); + }); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiDestroyDeviceInfoListFailsThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL { + return false; + }); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, [](HDEVINFO deviceInfoSet) -> BOOL { + return false; + }); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiEnumDeviceInfoFailsThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL { + return false; + }); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndGetDeviceRegistryPropertyFailsThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + createCallCount = 2; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, [](HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) -> BOOL { + if (createCallCount == 1) { + *requiredSize = 0x0; + return true; + } else { + if (requiredSize != nullptr) { + *requiredSize = 0x1; + return false; + } + return false; + } + }); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL { + if (createCallCount) { + createCallCount--; + return true; + } + return false; + }); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndGetDeviceRegistryPropertyFailsThenNullptrIsReturnedCoveringAdditionalBranch, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + createCallCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, [](HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) -> BOOL { + if (property == SPDRP_BUSNUMBER) { + if (requiredSize != nullptr) { + *requiredSize = 0x1; + return false; + } + *propertyBuffer = 0u; + return true; + } else { + return true; + } + }); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL { + if (createCallCount) { + createCallCount--; + return true; + } + return false; + }); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndPciBDFMatchingFailsThenNullptrIsReturned, IsBMG) { + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, [](HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) -> BOOL { + if (requiredSize != nullptr) { + *requiredSize = 0x1; + return false; + } + *propertyBuffer = 0u; + return true; + }); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, [](HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) -> BOOL { + if (createCallCount) { + createCallCount--; + return true; + } + return false; + }); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::vector> devicePciBdfCombinations = {{1, 1, 1}, {1, 1, 0}, {1, 0, 1}, {1, 0, 0}, {0, 1, 1}, {0, 1, 0}, {0, 0, 1}}; + for (uint32_t i = 0; i < devicePciBdfCombinations.size(); i++) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + createCallCount = 1; + + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), devicePciBdfCombinations[i][0], devicePciBdfCombinations[i][1], devicePciBdfCombinations[i][2]); + EXPECT_EQ(nullptr, pPmt); + } +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdSizeFailsThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, [](PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) -> CONFIGRET { + return CR_FAILURE; + }); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdFailsThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, [](DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { + return CR_FAILURE; + }); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdReturnEmptyIdThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, [](PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) -> CONFIGRET { + return CR_SUCCESS; + }); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, [](DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { + return CR_SUCCESS; + }); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndSetupDiOpenDeviceInfoFailsThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, &mockCmGetDeviceIdSuccess); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, [](HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) -> BOOL { + return false; + }); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); + EXPECT_EQ(nullptr, pPmt); +} + +HWTEST2_F(SysmanDevicePmtFixture, GivenValidPmtInterfaceWhenCallingCreateAndCmGetDeviceIdReturnsWrongIdThenNullptrIsReturned, IsBMG) { + sysCallsCmGetChildCount = 1; + sysCallsCmGetSiblingCount = 1; + VariableBackup psysCallsCreateFile(&NEO::SysCalls::sysCallsCreateFile, &mockCreateFileSuccess); + VariableBackup psysCallsDeviceIoControl(&NEO::SysCalls::sysCallsDeviceIoControl, &mockDeviceIoControlExtendedSuccess); + VariableBackup psysCallsInterfaceListSize(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceListSize, &mockCmGetDeviceInterfaceListSizeSuccess); + VariableBackup psysCallsInterfaceList(&NEO::SysCalls::sysCallsCmGetDeviceInterfaceList, &mockCmGetDeviceInterfaceListSuccess); + VariableBackup psysCallsCmGetDeviceIdSize(&NEO::SysCalls::sysCallsCmGetDeviceIdSize, &mockCmGetDeviceIdSizeSuccess); + VariableBackup psysCallsCmGetDeviceId(&NEO::SysCalls::sysCallsCmGetDeviceId, [](DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) -> CONFIGRET { + wcscpy(buffer, L"INVALID_TEST_ID"); + return CR_SUCCESS; + }); + VariableBackup psysCallsCmGetChild(&NEO::SysCalls::sysCallsCmGetChild, &mockCmGetChildSuccess); + VariableBackup psysCallsCmGetSibling(&NEO::SysCalls::sysCallsCmGetSibling, &mockCmGetSiblingSuccess); + VariableBackup psysCallsSetupDiGetDeviceRegistryProperty(&NEO::SysCalls::sysCallsSetupDiGetDeviceRegistryProperty, &mockSetupDiGetDeviceRegistryPropertySuccess); + VariableBackup psysCallsSetupDiOpenDeviceInfo(&NEO::SysCalls::sysCallsSetupDiOpenDeviceInfo, &mockSetupDiOpenDeviceInfoSuccess); + VariableBackup psysCallsSetupDiEnumDeviceInfo(&NEO::SysCalls::sysCallsSetupDiEnumDeviceInfo, &mockSetupDiEnumDeviceInfoSuccess); + VariableBackup psysCallsSetupDiDestroyDeviceInfoList(&NEO::SysCalls::sysCallsSetupDiDestroyDeviceInfoList, &mockSetupDiDestroyDeviceInfoListSuccess); + VariableBackup psysCallsSetupDiGetClassDevs(&NEO::SysCalls::sysCallsSetupDiGetClassDevs, &mockSetupDiGetClassDevsSuccess); + std::unique_ptr pPmt = PublicPlatformMonitoringTech::create(pWddmSysmanImp->getSysmanProductHelper(), 0, 0, 0); EXPECT_EQ(nullptr, pPmt); } diff --git a/shared/source/os_interface/windows/sys_calls.cpp b/shared/source/os_interface/windows/sys_calls.cpp index 03b12ea866..03261d81e3 100644 --- a/shared/source/os_interface/windows/sys_calls.cpp +++ b/shared/source/os_interface/windows/sys_calls.cpp @@ -177,6 +177,42 @@ CONFIGRET cmGetDeviceInterfaceList(LPGUID interfaceClassGuid, DEVINSTID_W pDevic return CM_Get_Device_Interface_List(interfaceClassGuid, pDeviceID, buffer, bufferLen, ulFlags); } +CONFIGRET cmGetDeviceIdSize(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) { + return CM_Get_Device_ID_Size(pulLen, dnDevInst, ulFlags); +} + +CONFIGRET cmGetDeviceId(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) { + return CM_Get_Device_ID(dnDevInst, buffer, bufferLen, ulFlags); +} + +CONFIGRET cmGetChild(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) { + return CM_Get_Child(pdnDevInst, dnDevInst, ulFlags); +} + +CONFIGRET cmGetSibling(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) { + return CM_Get_Sibling(pdnDevInst, dnDevInst, ulFlags); +} + +BOOL setupDiGetDeviceRegistryProperty(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) { + return SetupDiGetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, propertyRegDataType, propertyBuffer, propertyBufferSize, requiredSize); +} + +BOOL setupDiOpenDeviceInfo(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) { + return SetupDiOpenDeviceInfo(deviceInfoSet, deviceInstanceId, hwndParent, openFlags, deviceInfoData); +} + +BOOL setupDiEnumDeviceInfo(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) { + return SetupDiEnumDeviceInfo(deviceInfoSet, memberIndex, deviceInfoData); +} + +BOOL setupDiDestroyDeviceInfoList(HDEVINFO deviceInfoSet) { + return SetupDiDestroyDeviceInfoList(deviceInfoSet); +} + +HDEVINFO setupDiGetClassDevs(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) { + return SetupDiGetClassDevs(classGuid, enumerator, hwndParent, flags); +} + LPVOID heapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) { return HeapAlloc(hHeap, dwFlags, dwBytes); } diff --git a/shared/source/os_interface/windows/sys_calls.h b/shared/source/os_interface/windows/sys_calls.h index acc450cbee..a13c152182 100644 --- a/shared/source/os_interface/windows/sys_calls.h +++ b/shared/source/os_interface/windows/sys_calls.h @@ -58,6 +58,15 @@ HANDLE createFile(LPCWSTR lpFileName, DWORD dwDesiredAccess, DWORD dwShareMode, BOOL deviceIoControl(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped); CONFIGRET cmGetDeviceInterfaceListSize(PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags); CONFIGRET cmGetDeviceInterfaceList(LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags); +CONFIGRET cmGetDeviceIdSize(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags); +CONFIGRET cmGetDeviceId(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags); +CONFIGRET cmGetChild(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags); +CONFIGRET cmGetSibling(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags); +BOOL setupDiGetDeviceRegistryProperty(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize); +BOOL setupDiOpenDeviceInfo(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData); +BOOL setupDiEnumDeviceInfo(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData); +BOOL setupDiDestroyDeviceInfoList(HDEVINFO deviceInfoSet); +HDEVINFO setupDiGetClassDevs(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags); LPVOID heapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes); BOOL heapFree(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem); SIZE_T virtualQuery(LPCVOID lpAddress, PMEMORY_BASIC_INFORMATION lpBuffer, SIZE_T dwLength); diff --git a/shared/source/os_interface/windows/windows_wrapper.h b/shared/source/os_interface/windows/windows_wrapper.h index 937a9d5f19..ec7499281a 100644 --- a/shared/source/os_interface/windows/windows_wrapper.h +++ b/shared/source/os_interface/windows/windows_wrapper.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 2018-2024 Intel Corporation + * Copyright (C) 2018-2025 Intel Corporation * * SPDX-License-Identifier: MIT * @@ -18,6 +18,7 @@ #include +#include #include #include #include diff --git a/shared/test/common/os_interface/windows/mock_sys_calls.h b/shared/test/common/os_interface/windows/mock_sys_calls.h index 4d62ca688d..f9f1ab410d 100644 --- a/shared/test/common/os_interface/windows/mock_sys_calls.h +++ b/shared/test/common/os_interface/windows/mock_sys_calls.h @@ -65,6 +65,15 @@ extern HANDLE (*sysCallsCreateFile)(LPCWSTR lpFileName, DWORD dwDesiredAccess, D extern BOOL (*sysCallsDeviceIoControl)(HANDLE hDevice, DWORD dwIoControlCode, LPVOID lpInBuffer, DWORD nInBufferSize, LPVOID lpOutBuffer, DWORD nOutBufferSize, LPDWORD lpBytesReturned, LPOVERLAPPED lpOverlapped); extern CONFIGRET (*sysCallsCmGetDeviceInterfaceListSize)(PULONG pulLen, LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, ULONG ulFlags); extern CONFIGRET (*sysCallsCmGetDeviceInterfaceList)(LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags); +extern CONFIGRET (*sysCallsCmGetDeviceIdSize)(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags); +extern CONFIGRET (*sysCallsCmGetDeviceId)(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags); +extern CONFIGRET (*sysCallsCmGetChild)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags); +extern CONFIGRET (*sysCallsCmGetSibling)(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags); +extern BOOL (*sysCallsSetupDiGetDeviceRegistryProperty)(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize); +extern BOOL (*sysCallsSetupDiOpenDeviceInfo)(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData); +extern BOOL (*sysCallsSetupDiEnumDeviceInfo)(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData); +extern BOOL (*sysCallsSetupDiDestroyDeviceInfoList)(HDEVINFO deviceInfoSet); +extern HDEVINFO (*sysCallsSetupDiGetClassDevs)(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags); extern LPVOID (*sysCallsHeapAlloc)(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes); extern BOOL (*sysCallsHeapFree)(HANDLE hHeap, DWORD dwFlags, LPVOID lpMem); extern BOOL (*sysCallsDuplicateHandle)(HANDLE hSourceProcessHandle, HANDLE hSourceHandle, HANDLE hTargetProcessHandle, LPHANDLE lpTargetHandle, DWORD dwDesiredAccess, BOOL bInheritHandle, DWORD dwOptions); diff --git a/shared/test/common/os_interface/windows/sys_calls.cpp b/shared/test/common/os_interface/windows/sys_calls.cpp index 8fa25838df..98938bbfb8 100644 --- a/shared/test/common/os_interface/windows/sys_calls.cpp +++ b/shared/test/common/os_interface/windows/sys_calls.cpp @@ -114,6 +114,33 @@ CONFIGRET(*sysCallsCmGetDeviceInterfaceListSize) CONFIGRET(*sysCallsCmGetDeviceInterfaceList) (LPGUID interfaceClassGuid, DEVINSTID_W pDeviceID, PZZWSTR buffer, ULONG bufferLen, ULONG ulFlags) = nullptr; +CONFIGRET(*sysCallsCmGetDeviceIdSize) +(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) = nullptr; + +CONFIGRET(*sysCallsCmGetDeviceId) +(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) = nullptr; + +CONFIGRET(*sysCallsCmGetChild) +(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) = nullptr; + +CONFIGRET(*sysCallsCmGetSibling) +(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) = nullptr; + +BOOL(*sysCallsSetupDiGetDeviceRegistryProperty) +(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) = nullptr; + +BOOL(*sysCallsSetupDiOpenDeviceInfo) +(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) = nullptr; + +BOOL(*sysCallsSetupDiEnumDeviceInfo) +(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) = nullptr; + +BOOL(*sysCallsSetupDiDestroyDeviceInfoList) +(HDEVINFO deviceInfoSet) = nullptr; + +HDEVINFO(*sysCallsSetupDiGetClassDevs) +(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) = nullptr; + LPVOID(*sysCallsHeapAlloc) (HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) = nullptr; @@ -337,6 +364,69 @@ CONFIGRET cmGetDeviceInterfaceList(LPGUID interfaceClassGuid, DEVINSTID_W pDevic return -1; } +CONFIGRET cmGetDeviceIdSize(PULONG pulLen, DEVINST dnDevInst, ULONG ulFlags) { + if (sysCallsCmGetDeviceIdSize != nullptr) { + return sysCallsCmGetDeviceIdSize(pulLen, dnDevInst, ulFlags); + } + return -1; +} + +CONFIGRET cmGetDeviceId(DEVINST dnDevInst, PWSTR buffer, ULONG bufferLen, ULONG ulFlags) { + if (sysCallsCmGetDeviceId != nullptr) { + return sysCallsCmGetDeviceId(dnDevInst, buffer, bufferLen, ulFlags); + } + return -1; +} + +CONFIGRET cmGetChild(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) { + if (sysCallsCmGetChild != nullptr) { + return sysCallsCmGetChild(pdnDevInst, dnDevInst, ulFlags); + } + return -1; +} + +CONFIGRET cmGetSibling(PDEVINST pdnDevInst, DEVINST dnDevInst, ULONG ulFlags) { + if (sysCallsCmGetSibling != nullptr) { + return sysCallsCmGetSibling(pdnDevInst, dnDevInst, ulFlags); + } + return -1; +} + +BOOL setupDiGetDeviceRegistryProperty(HDEVINFO deviceInfoSet, PSP_DEVINFO_DATA deviceInfoData, DWORD property, PDWORD propertyRegDataType, PBYTE propertyBuffer, DWORD propertyBufferSize, PDWORD requiredSize) { + if (sysCallsSetupDiGetDeviceRegistryProperty != nullptr) { + return sysCallsSetupDiGetDeviceRegistryProperty(deviceInfoSet, deviceInfoData, property, propertyRegDataType, propertyBuffer, propertyBufferSize, requiredSize); + } + return false; +} + +BOOL setupDiOpenDeviceInfo(HDEVINFO deviceInfoSet, PCWSTR deviceInstanceId, HWND hwndParent, DWORD openFlags, PSP_DEVINFO_DATA deviceInfoData) { + if (sysCallsSetupDiOpenDeviceInfo != nullptr) { + return sysCallsSetupDiOpenDeviceInfo(deviceInfoSet, deviceInstanceId, hwndParent, openFlags, deviceInfoData); + } + return false; +} + +BOOL setupDiEnumDeviceInfo(HDEVINFO deviceInfoSet, DWORD memberIndex, PSP_DEVINFO_DATA deviceInfoData) { + if (sysCallsSetupDiEnumDeviceInfo != nullptr) { + return sysCallsSetupDiEnumDeviceInfo(deviceInfoSet, memberIndex, deviceInfoData); + } + return false; +} + +BOOL setupDiDestroyDeviceInfoList(HDEVINFO deviceInfoSet) { + if (sysCallsSetupDiDestroyDeviceInfoList != nullptr) { + return sysCallsSetupDiDestroyDeviceInfoList(deviceInfoSet); + } + return false; +} + +HDEVINFO setupDiGetClassDevs(GUID *classGuid, PCWSTR enumerator, HWND hwndParent, DWORD flags) { + if (sysCallsSetupDiGetClassDevs != nullptr) { + return sysCallsSetupDiGetClassDevs(classGuid, enumerator, hwndParent, flags); + } + return nullptr; +} + LPVOID heapAlloc(HANDLE hHeap, DWORD dwFlags, SIZE_T dwBytes) { if (sysCallsHeapAlloc != nullptr) { return sysCallsHeapAlloc(hHeap, dwFlags, dwBytes);