Reorganization directory structure [3/n]

Change-Id: If3dfa3f6007f8810a6a1ae1a4f0c7da38544648d

shared/source/page_fault_manager/linux/CMakeLists.txt

@@ -0,0 +1,13 @@
+#
+# Copyright (C) 2019-2020 Intel Corporation
+#
+# SPDX-License-Identifier: MIT
+#
+
+set(NEO_CORE_PAGE_FAULT_MANAGER_LINUX
+  ${CMAKE_CURRENT_SOURCE_DIR}/CMakeLists.txt
+  ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager_linux.cpp
+  ${CMAKE_CURRENT_SOURCE_DIR}/cpu_page_fault_manager_linux.h
+)
+
+set_property(GLOBAL PROPERTY NEO_CORE_PAGE_FAULT_MANAGER_LINUX ${NEO_CORE_PAGE_FAULT_MANAGER_LINUX})

shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.cpp

@@ -0,0 +1,71 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#include "page_fault_manager/linux/cpu_page_fault_manager_linux.h"
+
+#include "helpers/debug_helpers.h"
+
+#include <sys/mman.h>
+
+namespace NEO {
+std::unique_ptr<PageFaultManager> PageFaultManager::create() {
+    return std::make_unique<PageFaultManagerLinux>();
+}
+
+std::function<void(int signal, siginfo_t *info, void *context)> PageFaultManagerLinux::pageFaultHandler;
+
+PageFaultManagerLinux::PageFaultManagerLinux() {
+    pageFaultHandler = [&](int signal, siginfo_t *info, void *context) {
+        if (!this->verifyPageFault(info->si_addr)) {
+            callPreviousHandler(signal, info, context);
+        }
+    };
+
+    struct sigaction pageFaultManagerHandler = {};
+    pageFaultManagerHandler.sa_flags = SA_SIGINFO;
+    pageFaultManagerHandler.sa_sigaction = pageFaultHandlerWrapper;
+    auto retVal = sigaction(SIGSEGV, &pageFaultManagerHandler, &previousHandler);
+    UNRECOVERABLE_IF(retVal != 0);
+}
+
+PageFaultManagerLinux::~PageFaultManagerLinux() {
+    if (!previousHandlerRestored) {
+        auto retVal = sigaction(SIGSEGV, &previousHandler, nullptr);
+        UNRECOVERABLE_IF(retVal != 0);
+    }
+}
+
+void PageFaultManagerLinux::pageFaultHandlerWrapper(int signal, siginfo_t *info, void *context) {
+    pageFaultHandler(signal, info, context);
+}
+
+void PageFaultManagerLinux::allowCPUMemoryAccess(void *ptr, size_t size) {
+    auto retVal = mprotect(ptr, size, PROT_READ | PROT_WRITE);
+    UNRECOVERABLE_IF(retVal != 0);
+}
+
+void PageFaultManagerLinux::protectCPUMemoryAccess(void *ptr, size_t size) {
+    auto retVal = mprotect(ptr, size, PROT_NONE);
+    UNRECOVERABLE_IF(retVal != 0);
+}
+
+void PageFaultManagerLinux::callPreviousHandler(int signal, siginfo_t *info, void *context) {
+    if (previousHandler.sa_flags & SA_SIGINFO) {
+        previousHandler.sa_sigaction(signal, info, context);
+    } else {
+        if (previousHandler.sa_handler == SIG_DFL) {
+            auto retVal = sigaction(SIGSEGV, &previousHandler, nullptr);
+            UNRECOVERABLE_IF(retVal != 0);
+            previousHandlerRestored = true;
+        } else if (previousHandler.sa_handler == SIG_IGN) {
+            return;
+        } else {
+            previousHandler.sa_handler(signal);
+        }
+    }
+}
+} // namespace NEO

shared/source/page_fault_manager/linux/cpu_page_fault_manager_linux.h

@@ -0,0 +1,33 @@
+/*
+ * Copyright (C) 2019-2020 Intel Corporation
+ *
+ * SPDX-License-Identifier: MIT
+ *
+ */
+
+#pragma once
+
+#include "page_fault_manager/cpu_page_fault_manager.h"
+
+#include <csignal>
+#include <functional>
+
+namespace NEO {
+class PageFaultManagerLinux : public PageFaultManager {
+  public:
+    PageFaultManagerLinux();
+    ~PageFaultManagerLinux() override;
+
+    static void pageFaultHandlerWrapper(int signal, siginfo_t *info, void *context);
+
+  protected:
+    void allowCPUMemoryAccess(void *ptr, size_t size) override;
+    void protectCPUMemoryAccess(void *ptr, size_t size) override;
+
+    void callPreviousHandler(int signal, siginfo_t *info, void *context);
+    bool previousHandlerRestored = false;
+
+    static std::function<void(int signal, siginfo_t *info, void *context)> pageFaultHandler;
+    struct sigaction previousHandler = {};
+};
+} // namespace NEO