intel/compute-runtime
1
0
Fork 0
mirror of https://github.com/intel/compute-runtime.git synced 2026-01-03 14:55:24 +08:00
Code Issues Packages Projects Releases Wiki Activity

feature(sysman): Add support for fabric error counters

Browse Source 
Related-To: LOCI-4620

Signed-off-by: Bellekallu Rajkiran <bellekallu.rajkiran@intel.com>
This commit is contained in:
Bellekallu Rajkiran
2023-08-04 06:58:17 +00:00
committed by Compute-Runtime-Automation
parent 7472da8eb6
commit 81d037f59b
20 changed files with 1006 additions and 47 deletions
Download Patch File Download Diff File Expand all files Collapse all files

4
level_zero/sysman/source/fabric_port/linux/sysman_os_fabric_port_imp.cpp
View File

@@ -57,6 +57,10 @@ ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThr
return ZE_RESULT_SUCCESS;
}
ze_result_t LinuxFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t LinuxFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::snprintf(pProperties->model, ZES_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
pProperties->onSubdevice = false;

1
level_zero/sysman/source/fabric_port/linux/sysman_os_fabric_port_imp.h
View File

@@ -35,6 +35,7 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
LinuxFabricPortImp() = delete;
LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

104
level_zero/sysman/source/fabric_port/linux/sysman_os_fabric_port_imp_prelim.cpp
View File

@@ -40,6 +40,106 @@ ze_result_t LinuxFabricDeviceImp::getThroughput(const zes_fabric_port_id_t portI
return pFabricDeviceAccess->getThroughput(portId, *pThroughput);
}
ze_result_t LinuxFabricDeviceImp::getFabricDevicePath(std::string &fabricDevicePath) {
FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess();
SysfsAccess *pSysfsAccess = &pLinuxSysmanImp->getSysfsAccess();
std::string devicePciPath("");
ze_result_t result = pSysfsAccess->getRealPath("device/", devicePciPath);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to get device path> <result: 0x%x>\n", __func__, result);
return result;
}
std::vector<std::string> list;
result = pFsAccess->listDirectory(devicePciPath, list);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to get list of files in device directory> <result: 0x%x>\n", __func__, result);
return result;
}
// List contains much many nodes such as "i915.spi/43520", "i915.iaf.31", "dma_mask_bits", "local_cpus"
// out of which fabric errors are captured under "i915.iaf.X/iaf.X".
for (const auto &entry : list) {
if ((entry.find("i915.iaf.") != std::string::npos) ||
(entry.find("iaf.") != std::string::npos)) {
fabricDevicePath = devicePciPath + "/" + entry;
break;
}
}
if (fabricDevicePath.empty()) {
// This device does not have a fabric
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <Device does not have fabric>\n", __func__);
return ZE_RESULT_ERROR_NOT_AVAILABLE;
}
return result;
}
void LinuxFabricDeviceImp::getLinkErrorCount(zes_fabric_port_error_counters_t *pErrors, const std::string &fabricDevicePath, const zes_fabric_port_id_t portId) {
FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess();
std::string fabricLinkErrorPath = fabricDevicePath + "/sd." + std::to_string(portId.attachId) + "/port." + std::to_string(portId.portNumber);
uint64_t linkErrorCount = 0;
std::string linkFailureFile = fabricLinkErrorPath + "/link_failures";
ze_result_t result = pFsAccess->read(linkFailureFile, linkErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, linkFailureFile.c_str(), result);
linkErrorCount = 0;
}
uint64_t linkDegradeCount = 0;
std::string linkDegradeFile = fabricLinkErrorPath + "/link_degrades";
result = pFsAccess->read(linkDegradeFile, linkDegradeCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, linkDegradeFile.c_str(), result);
linkDegradeCount = 0;
}
pErrors->linkFailureCount = linkErrorCount;
pErrors->linkDegradeCount = linkDegradeCount;
}
void LinuxFabricDeviceImp::getFwErrorCount(zes_fabric_port_error_counters_t *pErrors, const std::string &fabricDevicePath, const zes_fabric_port_id_t portId) {
FsAccess *pFsAccess = &pLinuxSysmanImp->getFsAccess();
uint64_t fwErrorCount = 0;
std::string fabricFwErrorPath = fabricDevicePath + "/sd." + std::to_string(portId.attachId);
std::string fwErrorFile = fabricFwErrorPath + "/fw_error";
ze_result_t result = pFsAccess->read(fwErrorFile, fwErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, fwErrorFile.c_str(), result);
fwErrorCount = 0;
}
uint64_t fwCommErrorCount = 0;
std::string fwCommErrorFile = fabricFwErrorPath + "/fw_comm_errors";
result = pFsAccess->read(fwCommErrorFile, fwCommErrorCount);
if (result != ZE_RESULT_SUCCESS) {
NEO::printDebugString(NEO::DebugManager.flags.PrintDebugMessages.get(), stderr,
"error@<%s> <failed to read file %s> <result: 0x%x>\n", __func__, fwCommErrorFile.c_str(), result);
fwCommErrorCount = 0;
}
pErrors->fwErrorCount = fwErrorCount;
pErrors->fwCommErrorCount = fwCommErrorCount;
}
// sysfs location for error counters can be any one of the below:
// MFD Driver: /sys/module/iaf/drivers/platform:iaf/iaf.X/sd.X/fw_error(fw_comm_errors)
// /sys/module/iaf/drivers/platform:iaf/iaf.X/sd.Y/port.Z/link_failures(link_degrades)
// AuxBus Driver: /sys/module/iaf/drivers/auxiliary:iaf/i915.iaf.A/sd.X/port.Y/link_failures(link_degrades)
// /sys/module/iaf/drivers/auxiliary:iaf/i915.iaf.A/sd.X/fw_error(fw_comm_errors)
ze_result_t LinuxFabricDeviceImp::getErrorCounters(const zes_fabric_port_id_t portId, zes_fabric_port_error_counters_t *pErrors) {
std::string fabricDevicePath("");
auto result = getFabricDevicePath(fabricDevicePath);
if (result != ZE_RESULT_SUCCESS) {
return result;
}
getLinkErrorCount(pErrors, fabricDevicePath, portId);
getFwErrorCount(pErrors, fabricDevicePath, portId);
return result;
}
ze_result_t LinuxFabricDeviceImp::performSweep() {
uint32_t start = 0U;
uint32_t end = 0U;
@@ -220,6 +320,10 @@ ze_result_t LinuxFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThr
return pLinuxFabricDeviceImp->getThroughput(portId, pThroughput);
}
ze_result_t LinuxFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return pLinuxFabricDeviceImp->getErrorCounters(portId, pErrors);
}
ze_result_t LinuxFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::snprintf(pProperties->model, ZES_MAX_FABRIC_PORT_MODEL_SIZE, "%s", this->model.c_str());
pProperties->onSubdevice = this->onSubdevice;

5
level_zero/sysman/source/fabric_port/linux/sysman_os_fabric_port_imp_prelim.h
View File

@@ -30,6 +30,7 @@ class LinuxFabricDeviceImp : public OsFabricDevice, NEO::NonCopyableOrMovableCla
ze_result_t disablePortBeaconing(const zes_fabric_port_id_t portId);
ze_result_t getState(const zes_fabric_port_id_t portId, zes_fabric_port_state_t *pState);
ze_result_t getThroughput(const zes_fabric_port_id_t portId, zes_fabric_port_throughput_t *pThroughput);
ze_result_t getErrorCounters(const zes_fabric_port_id_t portId, zes_fabric_port_error_counters_t *pErrors);
void getPortId(const uint32_t portNumber, zes_fabric_port_id_t &portId);
void getProperties(const zes_fabric_port_id_t portId, std::string &model, bool &onSubdevice,
@@ -48,6 +49,9 @@ class LinuxFabricDeviceImp : public OsFabricDevice, NEO::NonCopyableOrMovableCla
ze_result_t disable(const zes_fabric_port_id_t portId);
ze_result_t enableUsage(const zes_fabric_port_id_t portId);
ze_result_t disableUsage(const zes_fabric_port_id_t portId);
ze_result_t getFabricDevicePath(std::string &fabricDevicePath);
void getLinkErrorCount(zes_fabric_port_error_counters_t *pErrors, const std::string &fabricDevicePath, const zes_fabric_port_id_t portId);
void getFwErrorCount(zes_fabric_port_error_counters_t *pErrors, const std::string &fabricDevicePath, const zes_fabric_port_id_t portId);
protected:
LinuxSysmanImp *pLinuxSysmanImp = nullptr;
@@ -62,6 +66,7 @@ class LinuxFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
LinuxFabricPortImp() = delete;
LinuxFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

2
level_zero/sysman/source/fabric_port/sysman_fabric_port_imp.cpp
View File

@@ -35,7 +35,7 @@ void fabricPortGetTimestamp(uint64_t &timestamp) {
}
ze_result_t FabricPortImp::fabricPortGetErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
return pOsFabricPort->getErrorCounters(pErrors);
}
ze_result_t FabricPortImp::fabricPortGetProperties(zes_fabric_port_properties_t *pProperties) {

1
level_zero/sysman/source/fabric_port/sysman_os_fabric_port.h
View File

@@ -30,6 +30,7 @@ class OsFabricPort {
virtual ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) = 0;
virtual ze_result_t getState(zes_fabric_port_state_t *pState) = 0;
virtual ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) = 0;
virtual ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) = 0;
static std::unique_ptr<OsFabricPort> create(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

4
level_zero/sysman/source/fabric_port/windows/sysman_os_fabric_port_imp.cpp
View File

@@ -42,6 +42,10 @@ ze_result_t WddmFabricPortImp::getThroughput(zes_fabric_port_throughput_t *pThro
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getErrorCounters(zes_fabric_port_error_counters_t *pErrors) {
return ZE_RESULT_ERROR_UNSUPPORTED_FEATURE;
}
ze_result_t WddmFabricPortImp::getProperties(zes_fabric_port_properties_t *pProperties) {
::memset(pProperties->model, '\0', ZES_MAX_FABRIC_PORT_MODEL_SIZE);
pProperties->onSubdevice = false;

1
level_zero/sysman/source/fabric_port/windows/sysman_os_fabric_port_imp.h
View File

@@ -34,6 +34,7 @@ class WddmFabricPortImp : public OsFabricPort, NEO::NonCopyableOrMovableClass {
ze_result_t setConfig(const zes_fabric_port_config_t *pConfig) override;
ze_result_t getState(zes_fabric_port_state_t *pState) override;
ze_result_t getThroughput(zes_fabric_port_throughput_t *pThroughput) override;
ze_result_t getErrorCounters(zes_fabric_port_error_counters_t *pErrors) override;
WddmFabricPortImp() = delete;
WddmFabricPortImp(OsFabricDevice *pOsFabricDevice, uint32_t portNum);

8
level_zero/sysman/source/sysman_const.h
View File

@@ -33,14 +33,6 @@ struct SteadyClock {
}
};
typedef struct _zes_fabric_port_error_counters_t {
void *pNext;
uint64_t linkFailureCount;
uint64_t fwCommErrorCount;
uint64_t fwErrorCount;
uint64_t linkDegradeCount;
} zes_fabric_port_error_counters_t;
} // namespace Sysman
} // namespace L0

396
level_zero/sysman/test/unit_tests/sources/fabric_port/linux/test_sysman_fabric_port_prelim.cpp
View File

@@ -558,20 +558,6 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingZesFabricPortG
EXPECT_EQ(pMockIafNlApi->txCounter, throughput.txCounter);
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersThenUnsupportedFeatureErrorIsReturned) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
zes_fabric_port_handle_t hPorts[maxNumPorts];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, pMockIafNlApi->numPorts);
for (auto i = 0U; i < count; i++) {
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFabricPortGetFabricErrorCounters(hPorts[i], nullptr));
}
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetMultiPortThroughputThenUnsupportedFeatureErrorIsReturned) {
uint32_t count = pMockIafNlApi->numPorts;
ASSERT_LE(count, maxNumPorts);
@@ -582,6 +568,388 @@ TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortG
EXPECT_EQ(ZE_RESULT_ERROR_UNSUPPORTED_FEATURE, zesFabricPortGetMultiPortThroughput(device, count, hPorts, nullptr));
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersWithLegacyPathAndCallSucceeds) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"driver", "drm", "iaf.5"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersCallSucceeds) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndGetRealPathFailsThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
static_cast<MockFabricSysFsAccess *>(pSysfsAccess)->mockRealPathStatus = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndListDirectoryFailsThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
static_cast<MockFabricFsAccess *>(pFsAccess)->mockListDirectory = ZE_RESULT_ERROR_NOT_AVAILABLE;
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndIafSysfsFilesAreNotPresentThenFailureIsReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
std::vector<std::string> dirs = {"driver", "drm"};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_ERROR_NOT_AVAILABLE, result);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkFailureSysfsNodeIsAbsentThenZeroLinkFailuresAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorIncorrectPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, 0u);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndLinkDegradesSysfsNodeIsAbsentThenZeroLinkDegradesAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricLinkErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorIncorrectPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, 0u);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwErrorSysfsNodeIsAbsentThenZeroFwErrorsAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::string fabricFwErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorIncorrectPath + "/fw_error", mockFwErrors},
{fabricFwErrorPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, 0u);
EXPECT_EQ(errors.fwCommErrorCount, mockFwCommErrors);
delete pFsAccess;
delete pSysfsAccess;
}
TEST_F(ZesFabricPortFixture, GivenValidFabricPortHandleWhenCallingzesFabricPortGetFabricErrorCountersAndFwCommErrorSysfsNodeIsAbsentThenZeroFwCommErrorsAreReturned) {
VariableBackup<FsAccess *> backupFsAccess(&pLinuxSysmanImp->pFsAccess);
VariableBackup<SysfsAccess *> backupSysfsAccess(&pLinuxSysmanImp->pSysfsAccess);
auto pFsAccess = new MockFabricFsAccess;
auto pSysfsAccess = new MockFabricSysFsAccess;
pLinuxSysmanImp->pFsAccess = pFsAccess;
pLinuxSysmanImp->pSysfsAccess = pSysfsAccess;
uint32_t count = 1U;
zes_fabric_port_handle_t hPorts[1U];
ze_result_t result = zesDeviceEnumFabricPorts(device, &count, hPorts);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(count, 1U);
zes_fabric_port_properties_t properties;
result = zesFabricPortGetProperties(hPorts[0], &properties);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
std::string fabricLinkErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId) + "/port." + std::to_string(properties.portId.portNumber);
std::string fabricFwErrorPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId);
std::string fabricFwErrorIncorrectPath = "/mockRealPath/i915.iaf.5/sd." + std::to_string(properties.portId.attachId + 1);
std::vector<std::string> dirs = {"i915.iaf.5",
"driver", "drm"};
uint64_t mockLinkFailures = 401;
uint64_t mockLinkDegrades = 501;
uint64_t mockFwErrors = 301;
uint64_t mockFwCommErrors = 201;
std::map<std::string, uint64_t> nodes = {
{fabricLinkErrorPath + "/link_failures", mockLinkFailures},
{fabricLinkErrorPath + "/link_degrades", mockLinkDegrades},
{fabricFwErrorPath + "/fw_error", mockFwErrors},
{fabricFwErrorIncorrectPath + "/fw_comm_errors", mockFwCommErrors},
};
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleDirectories(dirs);
static_cast<MockFabricFsAccess *>(pFsAccess)->setAccessibleNodes(nodes);
zes_fabric_port_error_counters_t errors;
result = zesFabricPortGetFabricErrorCounters(hPorts[0], &errors);
EXPECT_EQ(ZE_RESULT_SUCCESS, result);
EXPECT_EQ(errors.linkFailureCount, mockLinkFailures);
EXPECT_EQ(errors.linkDegradeCount, mockLinkDegrades);
EXPECT_EQ(errors.fwErrorCount, mockFwErrors);
EXPECT_EQ(errors.fwCommErrorCount, 0u);
delete pFsAccess;
delete pSysfsAccess;
}
} // namespace ult
} // namespace Sysman
} // namespace L0