diff --git a/shared/source/os_interface/linux/drm_neo.cpp b/shared/source/os_interface/linux/drm_neo.cpp index 5301af55db..cafc2e6849 100644 --- a/shared/source/os_interface/linux/drm_neo.cpp +++ b/shared/source/os_interface/linux/drm_neo.cpp @@ -244,17 +244,22 @@ bool Drm::isGpuHangDetected(OsContext &osContext) { for (const auto drmContextId : drmContextIds) { ResetStats resetStats{}; resetStats.contextId = drmContextId; - - const auto retVal{ioctlHelper->ioctl(DrmIoctl::getResetStats, &resetStats)}; + ResetStatsFault fault{}; + uint32_t status = 0; + const auto retVal{ioctlHelper->getResetStats(resetStats, &status, &fault)}; UNRECOVERABLE_IF(retVal != 0); - + if (ioctlHelper->validPageFault(fault.flags)) { + UNRECOVERABLE_IF((status & ioctlHelper->getStatusForResetStats(true)) == 0); + PRINT_DEBUG_STRING(debugManager.flags.PrintDebugMessages.get(), stderr, "ERROR: Unexpected page fault from GPU at 0x%llx, type: %d, level: %d, access: %d, aborting.\n", + fault.addr, fault.type, fault.level, fault.access); + UNRECOVERABLE_IF(true); + } if (resetStats.batchActive > 0 || resetStats.batchPending > 0) { PRINT_DEBUG_STRING(debugManager.flags.PrintDebugMessages.get(), stderr, "%s", "ERROR: GPU HANG detected!\n"); osContextLinux->setHangDetected(); return true; } } - return false; } diff --git a/shared/source/os_interface/linux/drm_wrappers.h b/shared/source/os_interface/linux/drm_wrappers.h index 83a3c3378e..ea354d0d52 100644 --- a/shared/source/os_interface/linux/drm_wrappers.h +++ b/shared/source/os_interface/linux/drm_wrappers.h @@ -238,6 +238,7 @@ enum class DrmIoctl { gemContextDestroy, regRead, getResetStats, + getResetStatsPrelim, gemContextGetparam, gemContextSetparam, query, diff --git a/shared/source/os_interface/linux/i915_prelim.h b/shared/source/os_interface/linux/i915_prelim.h index ddf40a589a..cb1e55ca48 100644 --- a/shared/source/os_interface/linux/i915_prelim.h +++ b/shared/source/os_interface/linux/i915_prelim.h @@ -79,6 +79,7 @@ using NEO::PrelimI915::prelim_drm_i915_gem_vm_region_ext; using NEO::PrelimI915::prelim_drm_i915_gem_wait_user_fence; using NEO::PrelimI915::prelim_drm_i915_query_distance_info; using NEO::PrelimI915::prelim_drm_i915_query_hw_ip_version; +using NEO::PrelimI915::prelim_drm_i915_reset_stats; using NEO::PrelimI915::prelim_drm_i915_uuid_control; using NEO::PrelimI915::prelim_drm_i915_vm_bind_ext_set_pat; using NEO::PrelimI915::prelim_drm_i915_vm_bind_ext_user_fence; diff --git a/shared/source/os_interface/linux/ioctl_helper.h b/shared/source/os_interface/linux/ioctl_helper.h index a25821f70f..8b45b79c99 100644 --- a/shared/source/os_interface/linux/ioctl_helper.h +++ b/shared/source/os_interface/linux/ioctl_helper.h @@ -72,6 +72,14 @@ struct UuidRegisterResult { uint32_t handle; }; +struct ResetStatsFault { + uint64_t addr; + uint16_t type; + uint16_t level; + uint16_t access; + uint16_t flags; +}; + using MemRegionsVec = StackVec; using VmBindExtSetPatT = uint8_t[40]; using VmBindExtUserFenceT = uint8_t[56]; @@ -123,6 +131,7 @@ class IoctlHelper { virtual uint32_t getVmAdviseAtomicAttribute() = 0; virtual int vmBind(const VmBindParams &vmBindParams) = 0; virtual int vmUnbind(const VmBindParams &vmBindParams) = 0; + virtual int getResetStats(ResetStats &resetStats, uint32_t *status, ResetStatsFault *resetStatsFault) = 0; virtual bool getEuStallProperties(std::array &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance, uint64_t notifyNReports) = 0; virtual uint32_t getEuStallFdParameter() = 0; @@ -177,6 +186,9 @@ class IoctlHelper { virtual int getEuDebugSysFsEnable() { return false; } virtual bool isVmBindPatIndexExtSupported() { return false; } + virtual bool validPageFault(uint16_t flags) { return false; } + virtual uint32_t getStatusForResetStats(bool banned) { return 0u; } + protected: Drm &drm; }; @@ -256,6 +268,7 @@ class IoctlHelperUpstream : public IoctlHelperI915 { uint32_t getVmAdviseAtomicAttribute() override; int vmBind(const VmBindParams &vmBindParams) override; int vmUnbind(const VmBindParams &vmBindParams) override; + int getResetStats(ResetStats &resetStats, uint32_t *status, ResetStatsFault *resetStatsFault) override; bool getEuStallProperties(std::array &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance, uint64_t notifyNReports) override; uint32_t getEuStallFdParameter() override; @@ -331,6 +344,7 @@ class IoctlHelperPrelim20 : public IoctlHelperI915 { uint32_t getVmAdviseAtomicAttribute() override; int vmBind(const VmBindParams &vmBindParams) override; int vmUnbind(const VmBindParams &vmBindParams) override; + int getResetStats(ResetStats &resetStats, uint32_t *status, ResetStatsFault *resetStatsFault) override; bool getEuStallProperties(std::array &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance, uint64_t notifyNReports) override; uint32_t getEuStallFdParameter() override; @@ -362,6 +376,9 @@ class IoctlHelperPrelim20 : public IoctlHelperI915 { int getEuDebugSysFsEnable() override; bool isVmBindPatIndexExtSupported() override { return true; } + bool validPageFault(uint16_t flags) override; + uint32_t getStatusForResetStats(bool banned) override; + protected: bool queryHwIpVersion(EngineClassInstance &engineInfo, HardwareIpVersion &ipVersion, int &ret); StackVec classHandles; diff --git a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp index 886ea3efdf..06c7eee3a4 100644 --- a/shared/source/os_interface/linux/ioctl_helper_prelim.cpp +++ b/shared/source/os_interface/linux/ioctl_helper_prelim.cpp @@ -725,6 +725,29 @@ int IoctlHelperPrelim20::vmUnbind(const VmBindParams &vmBindParams) { return IoctlHelper::ioctl(DrmIoctl::gemVmUnbind, &prelimVmBind); } +int IoctlHelperPrelim20::getResetStats(ResetStats &resetStats, uint32_t *status, ResetStatsFault *resetStatsFault) { + prelim_drm_i915_reset_stats prelimResetStats{}; + prelimResetStats.ctx_id = resetStats.contextId; + prelimResetStats.flags = resetStats.flags; + + const auto retVal = ioctl(DrmIoctl::getResetStatsPrelim, &prelimResetStats); + if (retVal != 0) { + return ioctl(DrmIoctl::getResetStats, &resetStats); + } + resetStats.resetCount = prelimResetStats.reset_count; + resetStats.batchActive = prelimResetStats.batch_active; + resetStats.batchPending = prelimResetStats.batch_pending; + if (status) { + *status = prelimResetStats.status; + } + if (resetStatsFault) { + auto fault = reinterpret_cast(&(prelimResetStats.fault)); + *resetStatsFault = *fault; + } + + return retVal; +} + UuidRegisterResult IoctlHelperPrelim20::registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) { prelim_drm_i915_uuid_control uuidControl = {}; memcpy_s(uuidControl.uuid, sizeof(uuidControl.uuid), uuid.c_str(), uuid.size()); @@ -802,8 +825,8 @@ unsigned int IoctlHelperPrelim20::getIoctlRequestValue(DrmIoctl ioctlRequest) co return PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE; case DrmIoctl::gemCacheReserve: return PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE; - case DrmIoctl::getResetStats: - return DRM_IOCTL_I915_GET_RESET_STATS; + case DrmIoctl::getResetStatsPrelim: + return PRELIM_DRM_IOCTL_I915_GET_RESET_STATS; default: return IoctlHelperI915::getIoctlRequestValue(ioctlRequest); } @@ -862,6 +885,8 @@ std::string IoctlHelperPrelim20::getIoctlString(DrmIoctl ioctlRequest) const { return "PRELIM_DRM_IOCTL_I915_GEM_CLOS_FREE"; case DrmIoctl::gemCacheReserve: return "PRELIM_DRM_IOCTL_I915_GEM_CACHE_RESERVE"; + case DrmIoctl::getResetStatsPrelim: + return "PRELIM_DRM_IOCTL_I915_GET_RESET_STATS"; default: return IoctlHelperI915::getIoctlString(ioctlRequest); } @@ -1102,8 +1127,23 @@ int IoctlHelperPrelim20::getEuDebugSysFsEnable() { return enabledEuDebug - '0'; } +bool IoctlHelperPrelim20::validPageFault(uint16_t flags) { + if ((flags & I915_RESET_STATS_FAULT_VALID) != 0) { + return true; + } + return false; +} + +uint32_t IoctlHelperPrelim20::getStatusForResetStats(bool banned) { + uint32_t retVal = 0u; + if (banned) { + retVal |= I915_RESET_STATS_BANNED; + } + return retVal; +} + static_assert(sizeof(MemoryClassInstance) == sizeof(prelim_drm_i915_gem_memory_class_instance)); static_assert(offsetof(MemoryClassInstance, memoryClass) == offsetof(prelim_drm_i915_gem_memory_class_instance, memory_class)); static_assert(offsetof(MemoryClassInstance, memoryInstance) == offsetof(prelim_drm_i915_gem_memory_class_instance, memory_instance)); - +static_assert(sizeof(ResetStatsFault) == sizeof(prelim_drm_i915_reset_stats::fault)); } // namespace NEO diff --git a/shared/source/os_interface/linux/ioctl_helper_upstream.cpp b/shared/source/os_interface/linux/ioctl_helper_upstream.cpp index 1aa990dd9b..56ae71bf3b 100644 --- a/shared/source/os_interface/linux/ioctl_helper_upstream.cpp +++ b/shared/source/os_interface/linux/ioctl_helper_upstream.cpp @@ -247,6 +247,10 @@ int IoctlHelperUpstream::vmUnbind(const VmBindParams &vmBindParams) { return 0; } +int IoctlHelperUpstream::getResetStats(ResetStats &resetStats, uint32_t *status, ResetStatsFault *resetStatsFault) { + return ioctl(DrmIoctl::getResetStats, &resetStats); +} + UuidRegisterResult IoctlHelperUpstream::registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) { return {0, 0}; } diff --git a/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp b/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp index 2e0f258522..044e4a6967 100644 --- a/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp +++ b/shared/source/os_interface/linux/xe/ioctl_helper_xe.cpp @@ -852,6 +852,10 @@ int IoctlHelperXe::vmUnbind(const VmBindParams &vmBindParams) { return xeVmBind(vmBindParams, false); } +int IoctlHelperXe::getResetStats(ResetStats &resetStats, uint32_t *status, ResetStatsFault *resetStatsFault) { + return ioctl(DrmIoctl::getResetStats, &resetStats); +} + UuidRegisterResult IoctlHelperXe::registerUuid(const std::string &uuid, uint32_t uuidClass, uint64_t ptr, uint64_t size) { xeLog(" -> IoctlHelperXe::%s\n", __FUNCTION__); return {}; diff --git a/shared/source/os_interface/linux/xe/ioctl_helper_xe.h b/shared/source/os_interface/linux/xe/ioctl_helper_xe.h index 0e62674555..828f69cd1b 100644 --- a/shared/source/os_interface/linux/xe/ioctl_helper_xe.h +++ b/shared/source/os_interface/linux/xe/ioctl_helper_xe.h @@ -94,6 +94,7 @@ class IoctlHelperXe : public IoctlHelper { uint32_t getVmAdviseAtomicAttribute() override; int vmBind(const VmBindParams &vmBindParams) override; int vmUnbind(const VmBindParams &vmBindParams) override; + int getResetStats(ResetStats &resetStats, uint32_t *status, ResetStatsFault *resetStatsFault) override; bool getEuStallProperties(std::array &properties, uint64_t dssBufferSize, uint64_t samplingRate, uint64_t pollPeriod, uint64_t engineInstance, uint64_t notifyNReports) override; uint32_t getEuStallFdParameter() override; diff --git a/shared/test/unit_test/os_interface/linux/drm_tests.cpp b/shared/test/unit_test/os_interface/linux/drm_tests.cpp index 33ab40b716..14e71caa51 100644 --- a/shared/test/unit_test/os_interface/linux/drm_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/drm_tests.cpp @@ -1393,6 +1393,41 @@ TEST(DrmTest, GivenBatchPendingGreaterThanZeroResetStatsWhenIsGpuHangIsCalledThe EXPECT_TRUE(isGpuHangDetected); } +class MockIoctlHelperResetStats : public MockIoctlHelper { + public: + using MockIoctlHelper::MockIoctlHelper; + bool validPageFault(uint16_t flags) override { + return validPageFaultReturnValue; + } + uint32_t getStatusForResetStats(bool banned) override { + return getStatusForResetStatsReturnValue; + } + bool validPageFaultReturnValue = 0; + uint32_t getStatusForResetStatsReturnValue = 0; +}; + +TEST(DrmDeathTest, GivenResetStatsWithValidFaultWhenIsGpuHangIsCalledThenProcessTerminated) { + MockExecutionEnvironment executionEnvironment{}; + + DrmMock drm{*executionEnvironment.rootDeviceEnvironments[0]}; + uint32_t contextId{0}; + EngineDescriptor engineDescriptor{EngineDescriptorHelper::getDefaultDescriptor({aub_stream::ENGINE_BCS, EngineUsage::regular})}; + auto ioctlHelper = std::make_unique(drm); + + MockOsContextLinux mockOsContextLinux{drm, 0, contextId, engineDescriptor}; + mockOsContextLinux.drmContextIds.push_back(0); + + ResetStats resetStats{}; + resetStats.contextId = 0; + drm.resetStatsToReturn.push_back(resetStats); + + ioctlHelper->getStatusForResetStatsReturnValue = 1; + ioctlHelper->validPageFaultReturnValue = true; + drm.ioctlHelper = std::move(ioctlHelper); + + EXPECT_THROW(drm.isGpuHangDetected(mockOsContextLinux), std::runtime_error); +} + TEST(DrmTest, givenSetupIoctlHelperWhenCalledTwiceThenIoctlHelperIsSetOnlyOnce) { auto executionEnvironment = std::make_unique(); DrmMock drm{*executionEnvironment->rootDeviceEnvironments[0]}; diff --git a/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp b/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp index 6eee015c81..3a786a2882 100644 --- a/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp +++ b/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_prelim.cpp @@ -64,6 +64,7 @@ TEST_F(IoctlPrelimHelperTests, whenGettingIoctlRequestValueThenPropertValueIsRet EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::gemContextDestroy), static_cast(DRM_IOCTL_I915_GEM_CONTEXT_DESTROY)); EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::regRead), static_cast(DRM_IOCTL_I915_REG_READ)); EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::getResetStats), static_cast(DRM_IOCTL_I915_GET_RESET_STATS)); + EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::getResetStatsPrelim), static_cast(PRELIM_DRM_IOCTL_I915_GET_RESET_STATS)); EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::gemContextGetparam), static_cast(DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM)); EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::gemContextSetparam), static_cast(DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM)); EXPECT_EQ(ioctlHelper.getIoctlRequestValue(DrmIoctl::query), static_cast(DRM_IOCTL_I915_QUERY)); @@ -116,6 +117,7 @@ TEST_F(IoctlPrelimHelperTests, whenGettingIoctlRequestStringThenProperStringIsRe EXPECT_STREQ(ioctlHelper.getIoctlString(DrmIoctl::gemContextDestroy).c_str(), "DRM_IOCTL_I915_GEM_CONTEXT_DESTROY"); EXPECT_STREQ(ioctlHelper.getIoctlString(DrmIoctl::regRead).c_str(), "DRM_IOCTL_I915_REG_READ"); EXPECT_STREQ(ioctlHelper.getIoctlString(DrmIoctl::getResetStats).c_str(), "DRM_IOCTL_I915_GET_RESET_STATS"); + EXPECT_STREQ(ioctlHelper.getIoctlString(DrmIoctl::getResetStatsPrelim).c_str(), "PRELIM_DRM_IOCTL_I915_GET_RESET_STATS"); EXPECT_STREQ(ioctlHelper.getIoctlString(DrmIoctl::gemContextGetparam).c_str(), "DRM_IOCTL_I915_GEM_CONTEXT_GETPARAM"); EXPECT_STREQ(ioctlHelper.getIoctlString(DrmIoctl::gemContextSetparam).c_str(), "DRM_IOCTL_I915_GEM_CONTEXT_SETPARAM"); EXPECT_STREQ(ioctlHelper.getIoctlString(DrmIoctl::query).c_str(), "DRM_IOCTL_I915_QUERY"); @@ -389,6 +391,27 @@ struct MockIoctlHelperPrelim20 : IoctlHelperPrelim20 { return *overrideGemCreateExtReturnValue; } } + if (request == DrmIoctl::getResetStatsPrelim) { + resetStatsPrelimCalled++; + if (overrideResetStatsPrelim.has_value()) { + auto resetStats = reinterpret_cast(arg); + *resetStats = std::get<0>(overrideResetStatsPrelim.value()); + auto resetStatsPrelim = reinterpret_cast(arg); + resetStatsPrelim->status = std::get<1>(overrideResetStatsPrelim.value()); + auto fault = std::get<2>(overrideResetStatsPrelim.value()); + resetStatsPrelim->fault = {fault.addr, fault.type, fault.level, fault.access, fault.flags}; + return overrideResetStatsPrelimReturnValue; + } + } + if (request == DrmIoctl::getResetStats) { + resetStatsCalled++; + if (overrideResetStats.has_value()) { + auto resetStats = reinterpret_cast(arg); + *resetStats = overrideResetStats.value(); + return overrideResetStatsReturnValue; + } + } + return IoctlHelperPrelim20::ioctl(request, arg); } bool checkWhetherGemCreateExtContainsMemPolicy(void *arg) { @@ -416,6 +439,12 @@ struct MockIoctlHelperPrelim20 : IoctlHelperPrelim20 { uint32_t lastPolicyMode = 0; uint32_t lastPolicyFlags = 0; std::vector lastPolicyNodeMask{}; + std::optional> overrideResetStatsPrelim{}; + int overrideResetStatsPrelimReturnValue = 0; + std::optional overrideResetStats{}; + int overrideResetStatsReturnValue = 0; + size_t resetStatsPrelimCalled = 0; + size_t resetStatsCalled = 0; }; TEST(IoctlPrelimHelperCreateGemExtTests, givenPrelimWhenCreateGemExtWithMemPolicyThenMemPolicyExtensionsIsAdded) { @@ -810,8 +839,74 @@ TEST_F(IoctlPrelimHelperTests, givenInitializeGetGpuTimeFunctionNotCalledWhenSet EXPECT_EQ(false, ret); } -TEST_F(IoctlPrelimHelperTests, givenUpstreamWhenGetFdFromVmExportIsCalledThenFalseIsReturned) { +TEST_F(IoctlPrelimHelperTests, givenPrelimWhenGetFdFromVmExportIsCalledThenFalseIsReturned) { uint32_t vmId = 0, flags = 0; int32_t fd = 0; EXPECT_FALSE(ioctlHelper.getFdFromVmExport(vmId, flags, &fd)); } + +TEST_F(IoctlPrelimHelperTests, whenGetResetStatsIsCalledThenCorrectValueIsReturned) { + auto executionEnvironment = std::make_unique(); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + MockIoctlHelperPrelim20 mockIoctlHelper{*drm}; + + uint32_t status = 1; + ResetStatsFault fault{}; + fault.flags = 1; + + ResetStats resetStats{}; + resetStats.contextId = 0; + mockIoctlHelper.overrideResetStatsPrelim = {resetStats, status, fault}; + + status = 0; + fault.flags = 0; + + EXPECT_EQ(0, mockIoctlHelper.getResetStats(resetStats, nullptr, nullptr)); + EXPECT_EQ(1u, mockIoctlHelper.resetStatsPrelimCalled); + EXPECT_EQ(0u, mockIoctlHelper.resetStatsCalled); + + EXPECT_EQ(0, mockIoctlHelper.getResetStats(resetStats, &status, nullptr)); + EXPECT_EQ(1u, status); + EXPECT_EQ(2u, mockIoctlHelper.resetStatsPrelimCalled); + EXPECT_EQ(0u, mockIoctlHelper.resetStatsCalled); + + status = 0; + EXPECT_EQ(0, mockIoctlHelper.getResetStats(resetStats, &status, &fault)); + EXPECT_EQ(1u, status); + EXPECT_EQ(1, fault.flags); + EXPECT_EQ(3u, mockIoctlHelper.resetStatsPrelimCalled); + EXPECT_EQ(0u, mockIoctlHelper.resetStatsCalled); +} + +TEST_F(IoctlPrelimHelperTests, givenNonZeroReturnValuewhenGetResetStatsIsCalledThenReturnsValueFromRegularResetStatsIoctl) { + auto executionEnvironment = std::make_unique(); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + MockIoctlHelperPrelim20 mockIoctlHelper{*drm}; + + uint32_t status = 1; + ResetStatsFault fault{}; + fault.flags = 1; + + ResetStats resetStats{}; + resetStats.contextId = 0; + mockIoctlHelper.overrideResetStatsPrelim = {resetStats, status, fault}; + mockIoctlHelper.overrideResetStats = resetStats; + + status = 0; + fault.flags = 0; + mockIoctlHelper.overrideResetStatsPrelimReturnValue = -1; + EXPECT_EQ(0, mockIoctlHelper.getResetStats(resetStats, &status, &fault)); + EXPECT_EQ(1u, mockIoctlHelper.resetStatsPrelimCalled); + EXPECT_EQ(1u, mockIoctlHelper.resetStatsCalled); +} +TEST_F(IoctlPrelimHelperTests, whenCallingGetStatusAndFlagsForResetStatsThenExpectedValueIsReturned) { + auto executionEnvironment = std::make_unique(); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + MockIoctlHelperPrelim20 ioctlHelper{*drm}; + + EXPECT_EQ(static_cast(I915_RESET_STATS_BANNED), ioctlHelper.getStatusForResetStats(true)); + EXPECT_EQ(0u, ioctlHelper.getStatusForResetStats(false)); + + EXPECT_TRUE(ioctlHelper.validPageFault(static_cast(I915_RESET_STATS_FAULT_VALID))); + EXPECT_FALSE(ioctlHelper.validPageFault(0u)); +} diff --git a/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp b/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp index b26b3349f2..0894783516 100644 --- a/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp +++ b/shared/test/unit_test/os_interface/linux/ioctl_helper_tests_upstream.cpp @@ -816,3 +816,26 @@ TEST(IoctlHelperTestsUpstream, givenUpstreamWhenGetFdFromVmExportIsCalledThenFal int32_t fd = 0; EXPECT_FALSE(ioctlHelper.getFdFromVmExport(vmId, flags, &fd)); } + +TEST(IoctlHelperTestsUpstream, whenCallingGetResetStatsThenSuccessIsReturned) { + auto executionEnvironment = std::make_unique(); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + IoctlHelperUpstream ioctlHelper{*drm}; + + ResetStats resetStats{}; + resetStats.contextId = 0; + drm->resetStatsToReturn.push_back(resetStats); + + EXPECT_EQ(0, ioctlHelper.getResetStats(resetStats, nullptr, nullptr)); +} + +TEST(IoctlHelperTestsUpstream, whenCallingGetStatusAndFlagsForResetStatsThenZeroIsReturned) { + auto executionEnvironment = std::make_unique(); + auto drm = std::make_unique(*executionEnvironment->rootDeviceEnvironments[0]); + IoctlHelperUpstream ioctlHelper{*drm}; + + EXPECT_EQ(0u, ioctlHelper.getStatusForResetStats(true)); + EXPECT_EQ(0u, ioctlHelper.getStatusForResetStats(false)); + + EXPECT_FALSE(ioctlHelper.validPageFault(0u)); +} diff --git a/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp b/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp index 5394b13984..3b2e3295a7 100644 --- a/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp +++ b/shared/test/unit_test/os_interface/linux/xe/ioctl_helper_xe_tests.cpp @@ -1740,3 +1740,29 @@ TEST(IoctlHelperXeTest, whenCallingVmBindThenPatIndexIsSet) { EXPECT_EQ(drm.vmBindInputs[0].bind.pat_index, expectedPatIndex); } + +TEST(IoctlHelperXeTest, whenCallingGetResetStatsThenSuccessIsReturned) { + auto executionEnvironment = std::make_unique(); + DrmMockXe drm{*executionEnvironment->rootDeviceEnvironments[0]}; + + auto xeIoctlHelper = std::make_unique(drm); + drm.memoryInfo.reset(xeIoctlHelper->createMemoryInfo().release()); + ASSERT_NE(nullptr, xeIoctlHelper); + + ResetStats resetStats{}; + resetStats.contextId = 0; + + EXPECT_EQ(0, xeIoctlHelper->getResetStats(resetStats, nullptr, nullptr)); +} + +TEST(IoctlHelperXeTest, whenCallingGetStatusAndFlagsForResetStatsThenZeroIsReturned) { + auto executionEnvironment = std::make_unique(); + DrmMockXe drm{*executionEnvironment->rootDeviceEnvironments[0]}; + + auto ioctlHelper = std::make_unique(drm); + + EXPECT_EQ(0u, ioctlHelper->getStatusForResetStats(true)); + EXPECT_EQ(0u, ioctlHelper->getStatusForResetStats(false)); + + EXPECT_FALSE(ioctlHelper->validPageFault(0u)); +}