Revert "feature: capture multiple cpu pagefault handler"

This reverts commit 44f2912195.

Signed-off-by: Compute-Runtime-Validation <compute-runtime-validation@intel.com>

shared/test/unit_test/page_fault_manager/cpu_page_fault_manager_tests.cpp

@@ -253,8 +253,6 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainThenTrans
 }
 
 TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThenCheckFaultHandlerFromPageFaultManagerReturnsTrue) {
-    DebugManagerStateRestore restorer;
-    debugManager.flags.RegisterPageFaultHandlerOnMigration.set(true);
     void *cmdQ = reinterpret_cast<void *>(0xFFFF);
     void *alloc1 = reinterpret_cast<void *>(0x1);
     void *alloc2 = reinterpret_cast<void *>(0x2);
@@ -264,7 +262,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThen
     EXPECT_EQ(pageFaultManager->memoryData.size(), 2u);
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
 
-    pageFaultManager->isFaultHandlerFromPageFaultManager = false;
+    EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager());
 
     pageFaultManager->moveAllocationToGpuDomain(alloc1);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0);
@@ -276,9 +274,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThen
     EXPECT_EQ(pageFaultManager->protectedSize, 10u);
     EXPECT_EQ(pageFaultManager->transferToGpuAddress, alloc1);
 
-    EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager());
-
-    pageFaultManager->isFaultHandlerFromPageFaultManager = true;
+    EXPECT_TRUE(pageFaultManager->checkFaultHandlerFromPageFaultManager());
 
     pageFaultManager->moveAllocationToGpuDomain(alloc2);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0);
@@ -293,44 +289,6 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThen
     EXPECT_TRUE(pageFaultManager->checkFaultHandlerFromPageFaultManager());
 }
 
-TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMoveToGpuDomainTwiceThenRegisterFaultHandlerIsCalledTwice) {
-    DebugManagerStateRestore restorer;
-    debugManager.flags.RegisterPageFaultHandlerOnMigration.set(true);
-
-    void *cmdQ = reinterpret_cast<void *>(0xFFFF);
-    void *alloc1 = reinterpret_cast<void *>(0x1);
-    void *alloc2 = reinterpret_cast<void *>(0x2);
-
-    pageFaultManager->insertAllocation(alloc1, 10u, unifiedMemoryManager.get(), cmdQ, {});
-    pageFaultManager->insertAllocation(alloc2, 20u, unifiedMemoryManager.get(), cmdQ, {});
-    EXPECT_EQ(pageFaultManager->memoryData.size(), 2u);
-    EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
-
-    pageFaultManager->isFaultHandlerFromPageFaultManager = false;
-
-    pageFaultManager->moveAllocationToGpuDomain(alloc1);
-    EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0);
-    EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1);
-    EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
-    EXPECT_EQ(pageFaultManager->transferToGpuCalled, 1);
-    EXPECT_EQ(pageFaultManager->registerFaultHandlerCalled, 1);
-    EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc1);
-    EXPECT_EQ(pageFaultManager->protectedSize, 10u);
-    EXPECT_EQ(pageFaultManager->transferToGpuAddress, alloc1);
-    EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager());
-
-    pageFaultManager->moveAllocationToGpuDomain(alloc2);
-    EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0);
-    EXPECT_EQ(pageFaultManager->protectMemoryCalled, 2);
-    EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
-    EXPECT_EQ(pageFaultManager->transferToGpuCalled, 2);
-    EXPECT_EQ(pageFaultManager->registerFaultHandlerCalled, 2);
-    EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc2);
-    EXPECT_EQ(pageFaultManager->protectedSize, 20u);
-    EXPECT_EQ(pageFaultManager->transferToGpuAddress, alloc2);
-    EXPECT_FALSE(pageFaultManager->checkFaultHandlerFromPageFaultManager());
-}
-
 TEST_F(PageFaultManagerTest, givenRegisterPageFaultHandlerOnMigrationDisabledWhenMoveToGpuDomainThenDoNotRegisterHandler) {
     DebugManagerStateRestore restorer;
     debugManager.flags.RegisterPageFaultHandlerOnMigration.set(false);
@@ -446,7 +404,7 @@ TEST_F(PageFaultManagerTest, givenHandlerRegisteredAndUntrackedPageFaultAddressW
     pageFaultManager->insertAllocation(alloc2, 20, unifiedMemoryManager.get(), nullptr, {});
     EXPECT_EQ(pageFaultManager->memoryData.size(), 2u);
 
-    auto retVal = pageFaultManager->verifyAndHandlePageFault(alloc3, true);
+    auto retVal = pageFaultManager->verifyPageFault(alloc3);
     EXPECT_FALSE(retVal);
 }
 
@@ -459,7 +417,7 @@ TEST_F(PageFaultManagerTest, givenTrackedPageFaultAddressWhenVerifyingThenProper
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
     EXPECT_EQ(pageFaultManager->memoryData.size(), 2u);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc1, true);
+    pageFaultManager->verifyPageFault(alloc1);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1);
     EXPECT_EQ(pageFaultManager->protectMemoryCalled, 0);
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
@@ -480,7 +438,7 @@ TEST_F(PageFaultManagerTest, givenInitialPlacementCpuWhenVerifyingPagefaultThenF
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc, true);
+    pageFaultManager->verifyPageFault(alloc);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1);
     EXPECT_EQ(pageFaultManager->protectMemoryCalled, 0);
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
@@ -506,13 +464,13 @@ TEST_F(PageFaultManagerTest, givenAllocsMovedToGpuDomainWhenVerifyingPageFaultTh
     pageFaultManager->moveAllocationsWithinUMAllocsManagerToGpuDomain(unifiedMemoryManager.get());
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc2, true);
+    pageFaultManager->verifyPageFault(alloc2);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc2);
 
     pageFaultManager->gpuDomainHandler = &MockPageFaultManager::unprotectAndTransferMemory;
 
-    pageFaultManager->verifyAndHandlePageFault(alloc1, true);
+    pageFaultManager->verifyPageFault(alloc1);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 2u);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[1], alloc1);
 }
@@ -531,13 +489,13 @@ TEST_F(PageFaultManagerTest, givenAllocsFromCpuDomainWhenVerifyingPageFaultThenD
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u);
 
     pageFaultManager->memoryData.at(alloc2).domain = PageFaultManager::AllocationDomain::none;
-    pageFaultManager->verifyAndHandlePageFault(alloc2, true);
+    pageFaultManager->verifyPageFault(alloc2);
     EXPECT_EQ(pageFaultManager->memoryData.at(alloc2).domain, PageFaultManager::AllocationDomain::cpu);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u);
 
     pageFaultManager->gpuDomainHandler = &MockPageFaultManager::unprotectAndTransferMemory;
     pageFaultManager->memoryData.at(alloc1).domain = PageFaultManager::AllocationDomain::none;
-    pageFaultManager->verifyAndHandlePageFault(alloc1, true);
+    pageFaultManager->verifyPageFault(alloc1);
     EXPECT_EQ(pageFaultManager->memoryData.at(alloc1).domain, PageFaultManager::AllocationDomain::cpu);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u);
 }
@@ -556,7 +514,7 @@ TEST_F(PageFaultManagerTest, givenTbxWhenVerifyingPagefaultThenVerifyPagefaultUn
     EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1);
     EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc, true);
+    pageFaultManager->verifyPageFault(alloc);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1);
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 1);
     EXPECT_EQ(pageFaultManager->allowedMemoryAccessAddress, alloc);
@@ -583,7 +541,7 @@ TEST_F(PageFaultManagerTest, whenVerifyingPagefaultWithPrintUsmSharedMigrationDe
     EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc);
     EXPECT_EQ(pageFaultManager->protectedSize, 10u);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc, true);
+    pageFaultManager->verifyPageFault(alloc);
 
     std::string output = testing::internal::GetCapturedStdout(); // stop capturing
 
@@ -622,7 +580,7 @@ TEST_F(PageFaultManagerTest, givenTbxWhenVerifyingPagefaultWithPrintUsmSharedMig
     EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc);
     EXPECT_EQ(pageFaultManager->protectedSize, 10u);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc, true);
+    pageFaultManager->verifyPageFault(alloc);
 
     std::string output = testing::internal::GetCapturedStdout(); // stop capturing
 
@@ -656,7 +614,7 @@ TEST_F(PageFaultManagerTest, givenTbxAndInitialPlacementGpuWhenVerifyingPagefaul
     EXPECT_EQ(pageFaultManager->protectedSize, 10u);
     EXPECT_EQ(pageFaultManager->memoryData.size(), 1u);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc, true);
+    pageFaultManager->verifyPageFault(alloc);
 
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1);
     EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0);
@@ -712,7 +670,7 @@ TEST_F(PageFaultManagerTest, givenAllocationMovedToGpuDomainWhenVerifyingPagefau
     EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0);
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u);
 
-    pageFaultManager->verifyAndHandlePageFault(alloc, true);
+    pageFaultManager->verifyPageFault(alloc);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1);
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 1);
     EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0);
@@ -724,35 +682,6 @@ TEST_F(PageFaultManagerTest, givenAllocationMovedToGpuDomainWhenVerifyingPagefau
     EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc);
 }
 
-TEST_F(PageFaultManagerTest, givenAllocationMovedToGpuDomainWhenVerifyingPagefaultWithHandlePageFaultFalseThenAllocationIsNotMovedToCpuDomain) {
-    void *cmdQ = reinterpret_cast<void *>(0xFFFF);
-    void *alloc = reinterpret_cast<void *>(0x1);
-
-    memoryProperties.allocFlags.usmInitialPlacementGpu = 1;
-    pageFaultManager->insertAllocation(alloc, 10, unifiedMemoryManager.get(), cmdQ, memoryProperties);
-    EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
-    EXPECT_EQ(pageFaultManager->memoryData.size(), 1u);
-    EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1);
-    EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, alloc);
-    EXPECT_EQ(pageFaultManager->protectedSize, 10u);
-    EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 1u);
-    EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs[0], alloc);
-
-    pageFaultManager->moveAllocationToGpuDomain(alloc);
-    EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0);
-    EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1);
-    EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
-    EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0);
-    EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u);
-
-    pageFaultManager->verifyAndHandlePageFault(alloc, false);
-    EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 0);
-    EXPECT_EQ(pageFaultManager->protectMemoryCalled, 1);
-    EXPECT_EQ(pageFaultManager->transferToCpuCalled, 0);
-    EXPECT_EQ(pageFaultManager->transferToGpuCalled, 0);
-    EXPECT_EQ(unifiedMemoryManager->nonGpuDomainAllocs.size(), 0u);
-}
-
 TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenSetAubWritableIsCalledThenAllocIsAubWritable) {
     REQUIRE_SVM_OR_SKIP(executionEnvironment.rootDeviceEnvironments[0]->getHardwareInfo());
 
@@ -798,7 +727,7 @@ TEST_F(PageFaultManagerTest, givenUnifiedMemoryAllocWhenMigratedBetweenCpuAndGpu
     EXPECT_EQ(pageFaultManager->protectedMemoryAccessAddress, ptr);
     EXPECT_EQ(pageFaultManager->protectedSize, 10u);
 
-    pageFaultManager->verifyAndHandlePageFault(ptr, true);
+    pageFaultManager->verifyPageFault(ptr);
     EXPECT_EQ(pageFaultManager->transferToCpuCalled, 1);
     EXPECT_EQ(pageFaultManager->allowMemoryAccessCalled, 1);
     EXPECT_EQ(pageFaultManager->setCpuAllocEvictableCalled, 2);

shared/test/unit_test/page_fault_manager/linux/cpu_page_fault_manager_linux_tests.cpp

@@ -125,14 +125,10 @@ class MockFailPageFaultManager : public PageFaultManagerLinux {
     using PageFaultManagerLinux::checkFaultHandlerFromPageFaultManager;
     using PageFaultManagerLinux::PageFaultManagerLinux;
     using PageFaultManagerLinux::previousHandlerRestored;
-    using PageFaultManagerLinux::previousPageFaultHandlers;
     using PageFaultManagerLinux::registerFaultHandler;
 
-    bool verifyAndHandlePageFault(void *ptr, bool handlePageFault) override {
+    bool verifyPageFault(void *ptr) override {
         verifyCalled = true;
-        if (handlePageFault) {
-            numPageFaultHandled++;
-        }
         return false;
     }
 
@@ -140,38 +136,22 @@ class MockFailPageFaultManager : public PageFaultManagerLinux {
         mockCalled = true;
     }
 
-    static void mockPageFaultHandler2(int signal, siginfo_t *info, void *context) {
-        mockCalled2 = true;
-        pageFaultHandlerWrapper(signal, info, context);
-    }
-
     static void mockPageFaultSimpleHandler(int signal) {
         simpleMockCalled = true;
     }
 
-    static void mockPageFaultSimpleHandler2(int signal) {
-        simpleMockCalled2 = true;
-    }
-
     ~MockFailPageFaultManager() override {
         mockCalled = false;
-        mockCalled2 = false;
         simpleMockCalled = false;
-        simpleMockCalled2 = false;
     }
 
     static bool mockCalled;
-    static bool mockCalled2;
     static bool simpleMockCalled;
-    static bool simpleMockCalled2;
     bool verifyCalled = false;
-    int numPageFaultHandled = 0;
 };
 
 bool MockFailPageFaultManager::mockCalled = false;
-bool MockFailPageFaultManager::mockCalled2 = false;
 bool MockFailPageFaultManager::simpleMockCalled = false;
-bool MockFailPageFaultManager::simpleMockCalled2 = false;
 
 TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleAndSigInfoFlagSetThenSaSigactionIsCalled) {
     struct sigaction previousHandler = {};
@@ -204,7 +184,6 @@ TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleThenSaHand
     auto mockPageFaultManager = std::make_unique<MockFailPageFaultManager>();
     EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
     EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size());
 
     std::raise(SIGSEGV);
     EXPECT_TRUE(mockPageFaultManager->verifyCalled);
@@ -264,170 +243,3 @@ TEST_F(PageFaultManagerLinuxTest, givenDefaultSaHandlerWhenOverwritingNewHandler
     mockPageFaultManager.reset();
     sigaction(SIGSEGV, &originalHandler, nullptr);
 }
-
-TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterSimpleHandlerTwiceThenSimpleHandlerIsRegisteredOnce) {
-    struct sigaction previousHandler = {};
-    struct sigaction previousHandler2 = {};
-    struct sigaction mockHandler = {};
-    struct sigaction mockHandler2 = {};
-    mockHandler.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler;
-    auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler);
-    EXPECT_EQ(retVal, 0);
-
-    auto mockPageFaultManager = std::make_unique<MockFailPageFaultManager>();
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_EQ(1, mockPageFaultManager->numPageFaultHandled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled);
-
-    MockFailPageFaultManager::simpleMockCalled = false;
-
-    mockHandler2.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler;
-    retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2);
-    EXPECT_EQ(retVal, 0);
-    mockPageFaultManager->registerFaultHandler();
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_EQ(2, mockPageFaultManager->numPageFaultHandled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    mockPageFaultManager.reset();
-    sigaction(SIGSEGV, &previousHandler, nullptr);
-}
-
-TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterTwoSimpleHandlersThenBothHandlersAreRegistered) {
-    struct sigaction previousHandler = {};
-    struct sigaction previousHandler2 = {};
-    struct sigaction mockHandler = {};
-    struct sigaction mockHandler2 = {};
-    mockHandler.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler;
-    auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler);
-    EXPECT_EQ(retVal, 0);
-
-    auto mockPageFaultManager = std::make_unique<MockFailPageFaultManager>();
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-    EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-
-    MockFailPageFaultManager::simpleMockCalled = false;
-
-    mockHandler2.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler2;
-    retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2);
-    EXPECT_EQ(retVal, 0);
-    mockPageFaultManager->registerFaultHandler();
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled2);
-    EXPECT_EQ(2ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    mockPageFaultManager.reset();
-    sigaction(SIGSEGV, &previousHandler, nullptr);
-}
-
-TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterTwoHandlersThenBothHandlersAreRegistered) {
-    struct sigaction previousHandler = {};
-    struct sigaction previousHandler2 = {};
-    struct sigaction mockHandler = {};
-    struct sigaction mockHandler2 = {};
-    mockHandler.sa_flags = SA_SIGINFO;
-    mockHandler.sa_sigaction = MockFailPageFaultManager::mockPageFaultHandler;
-    auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler);
-    EXPECT_EQ(retVal, 0);
-
-    auto mockPageFaultManager = std::make_unique<MockFailPageFaultManager>();
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-    EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_TRUE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-
-    MockFailPageFaultManager::mockCalled = false;
-
-    mockHandler2.sa_flags = SA_SIGINFO;
-    mockHandler2.sa_sigaction = MockFailPageFaultManager::mockPageFaultHandler2;
-    retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2);
-    EXPECT_EQ(retVal, 0);
-    mockPageFaultManager->registerFaultHandler();
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_TRUE(MockFailPageFaultManager::mockCalled);
-    EXPECT_TRUE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-    EXPECT_EQ(2ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    mockPageFaultManager.reset();
-    sigaction(SIGSEGV, &previousHandler, nullptr);
-}
-
-TEST_F(PageFaultManagerLinuxTest, givenPageFaultThatNEOShouldNotHandleWhenRegisterSimpleAndRegularHandlersThenBothHandlersAreRegistered) {
-    struct sigaction previousHandler = {};
-    struct sigaction previousHandler2 = {};
-    struct sigaction mockHandler = {};
-    struct sigaction mockHandler2 = {};
-    mockHandler.sa_handler = MockFailPageFaultManager::mockPageFaultSimpleHandler;
-    auto retVal = sigaction(SIGSEGV, &mockHandler, &previousHandler);
-    EXPECT_EQ(retVal, 0);
-
-    auto mockPageFaultManager = std::make_unique<MockFailPageFaultManager>();
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-    EXPECT_EQ(1ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-
-    MockFailPageFaultManager::simpleMockCalled = false;
-
-    mockHandler2.sa_flags = SA_SIGINFO;
-    mockHandler2.sa_sigaction = MockFailPageFaultManager::mockPageFaultHandler2;
-    retVal = sigaction(SIGSEGV, &mockHandler2, &previousHandler2);
-    EXPECT_EQ(retVal, 0);
-    mockPageFaultManager->registerFaultHandler();
-
-    std::raise(SIGSEGV);
-    EXPECT_TRUE(mockPageFaultManager->verifyCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::mockCalled);
-    EXPECT_TRUE(MockFailPageFaultManager::mockCalled2);
-    EXPECT_TRUE(MockFailPageFaultManager::simpleMockCalled);
-    EXPECT_FALSE(MockFailPageFaultManager::simpleMockCalled2);
-    EXPECT_EQ(2ul, mockPageFaultManager->previousPageFaultHandlers.size());
-
-    mockPageFaultManager.reset();
-    sigaction(SIGSEGV, &previousHandler, nullptr);
-}

shared/test/unit_test/page_fault_manager/windows/cpu_page_fault_manager_windows_tests.cpp

@@ -70,7 +70,7 @@ class MockFailPageFaultManager : public PageFaultManagerWindows {
     using PageFaultManagerWindows::checkFaultHandlerFromPageFaultManager;
     using PageFaultManagerWindows::PageFaultManagerWindows;
 
-    bool verifyAndHandlePageFault(void *ptr, bool handlePageFault) override {
+    bool verifyPageFault(void *ptr) override {
         verifyCalled = true;
         return false;
     }