hosted/PageFaultHandler.cc

/*
 * Copyright (c) 2008-2014, Pedigree Developers
 *
 * Please see the CONTRIB file in the root of the source tree for a full
 * list of contributors.
 *
 * Permission to use, copy, modify, and distribute this software for any
 * purpose with or without fee is hereby granted, provided that the above
 * copyright notice and this permission notice appear in all copies.
 *
 * THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES
 * WITH REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF
 * MERCHANTABILITY AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR
 * ANY SPECIAL, DIRECT, INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES
 * WHATSOEVER RESULTING FROM LOSS OF USE, DATA OR PROFITS, WHETHER IN AN
 * ACTION OF CONTRACT, NEGLIGENCE OR OTHER TORTIOUS ACTION, ARISING OUT OF
 * OR IN CONNECTION WITH THE USE OR PERFORMANCE OF THIS SOFTWARE.
 */
 
#include "pedigree/kernel/Log.h"
#include "pedigree/kernel/Metrics.h"
#include "pedigree/kernel/Subsystem.h"
#include "pedigree/kernel/debugger/Debugger.h"
#include "pedigree/kernel/panic.h"
#include "pedigree/kernel/process/Process.h"
#include "pedigree/kernel/process/Scheduler.h"
#include "pedigree/kernel/process/Thread.h"
#include "pedigree/kernel/processor/InterruptManager.h"
#include "pedigree/kernel/processor/PageFaultHandler.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/state.h"
 
#include "HostedPlatform.h"
#include "InterruptManager.h"
#include "VirtualAddressSpace.h"
 
namespace __pedigree_hosted {};
using namespace __pedigree_hosted;
 
#if HAS_ADDRESS_SANITIZER
extern "C" void __asan_report_error(void* pc, void* bp, void* sp, void* addr, int is_write,
                                    size_t access_size);
#endif
 
#include <signal.h>
#include <ucontext.h>
 
PageFaultHandler PageFaultHandler::m_Instance;
 
bool PageFaultHandler::initialise() {
  InterruptManager& IntManager = InterruptManager::instance();
  bool r1 = IntManager.registerInterruptHandler(SIGSEGV, this);
  bool r2 = IntManager.registerInterruptHandler(SIGBUS, this);
 
  return r1 && r2;
}
 
void PageFaultHandler::interrupt(size_t interruptNumber, InterruptState& state) {
  const bool collectMetrics = Processor::m_Initialised == 2;
  if (collectMetrics) {
    Metrics::increment(Metrics::PageFault);
  }
 
  siginfo_t* info = reinterpret_cast<siginfo_t*>(state.getRegister(1));
 
  uintptr_t page = reinterpret_cast<uintptr_t>(page_align(info->si_addr));
  uintptr_t unaligned_page = reinterpret_cast<uintptr_t>(info->si_addr);
  uintptr_t code = info->si_code;
  uintptr_t ucontext_loc = state.getRegister(2);
  ucontext_t* ctx = reinterpret_cast<ucontext_t*>(ucontext_loc);
 
  state.setInstructionPointer(HostedPlatform::instructionPointer(ctx));
  state.setStackPointer(HostedPlatform::stackPointer(ctx));
  state.setBasePointer(HostedPlatform::basePointer(ctx));
 
  bool isWrite = false;
  uintptr_t errorCode = code;
  bool wasPresent = code == SEGV_ACCERR;
#if defined(__APPLE__) && defined(__aarch64__)
  isWrite = (ctx->uc_mcontext->__es.__esr & (1U << 6U)) != 0;
  errorCode = (wasPresent ? 0x1 : 0) | (isWrite ? 0x2 : 0);
#elif defined(__APPLE__) && defined(__x86_64__)
  errorCode = ctx->uc_mcontext->__es.__err;
  isWrite = (errorCode & 0x2) != 0;
  wasPresent = (errorCode & 0x1) != 0;
#elif defined(REG_ERR)
  // SIGSEGV's si_code only distinguishes missing pages from protection
  // faults. The processor error code retains the read/write distinction.
  isWrite = (ctx->uc_mcontext.gregs[REG_ERR] & 0x2) != 0;
  errorCode = ctx->uc_mcontext.gregs[REG_ERR];
  wasPresent = (errorCode & 0x1) != 0;
#endif
 
  VirtualAddressSpace& va = Processor::information().getVirtualAddressSpace();
  if (wasPresent && isWrite &&
      va.handleCopyOnWriteFault(reinterpret_cast<void*>(page), !state.kernelMode())) {
    if (collectMetrics) {
      Metrics::increment(Metrics::PageFaultCopyOnWrite);
    }
    return;
  }
 
  if (page < reinterpret_cast<uintptr_t>(KERNEL_SPACE_START)) {
    if (dispatchHandlers(state, page, isWrite, wasPresent)) {
      if (collectMetrics) {
        Metrics::increment(Metrics::PageFaultHandled);
      }
      return;
    }
  }
 
  Thread* pThread = Processor::information().getCurrentThread();
  if (pThread && !state.kernelMode()) {
    Process* process = pThread->getParent();
    if (process && process->getSubsystem()) {
      pThread->deferSubsystemException(static_cast<size_t>(Subsystem::PageFault), unaligned_page,
                                       errorCode);
      if (collectMetrics) {
        Metrics::increment(Metrics::PageFaultDeferred);
      }
      return;
    }
  }
 
#if HAS_ADDRESS_SANITIZER
  // Escalate to the original signal handler - this is a real error, and in
  // asan we get asan-based analysis in the asan segv handler.
  struct sigaction oact = static_cast<HostedInterruptManager&>(InterruptManager::instance())
                              .getOriginalSigaction(info->si_signo);
  if (oact.sa_handler == SIG_IGN) {
    return;
  } else if (oact.sa_handler == SIG_DFL) {
    sigaction(info->si_signo, &oact, nullptr);
    raise(info->si_signo);
  } else if (oact.sa_flags & SA_SIGINFO) {
    oact.sa_sigaction(info->si_signo, info, ctx);
  } else {
    oact.sa_handler(info->si_signo);
  }
 
  return;
#endif
 
  //  Get PFE location and error code
  static LargeStaticString sError;
  sError.clear();
  sError.append("Page Fault Exception at 0x");
  sError.append(unaligned_page, 16, 8, '0');
  sError.append(", error code 0x");
  sError.append(code, 16, 8, '0');
  sError.append(", EIP 0x");
  sError.append(state.getInstructionPointer(), 16, 8, '0');
 
  //  Extract error code information
  static LargeStaticString sCode;
  sCode.clear();
  sCode.append("Details: PID=");
  sCode.append(Processor::information().getCurrentThread()->getParent()->getId());
  sCode.append(" ");
 
  if (code == SEGV_MAPERR)
    sCode.append("NOT ");
  sCode.append("PRESENT | ");
  if (code == SEGV_ACCERR)
    sCode.append("ACCESS ERROR");
 
  ERROR(static_cast<const char*>(sError));
  ERROR(static_cast<const char*>(sCode));
 
#if DEBUGGER
  if (state.kernelMode())
    Debugger::instance().start(state, sError);
#endif
 
  Scheduler& scheduler = Scheduler::instance();
  if (UNLIKELY(scheduler.getNumProcesses() == 0)) {
    //  We are in the early stages of the boot process (no processes
    //  started)
    panic(sError);
  } else {
    //  Unrecoverable PFE in a process - Kill the process and yield
    // Processor::information().getCurrentThread()->getParent()->kill();
    pThread = Processor::information().getCurrentThread();
    Process* pProcess = pThread->getParent();
    Subsystem* pSubsystem = pProcess->getSubsystem();
    if (!pSubsystem || state.kernelMode()) {
      pProcess->kill();
 
      //  kill member function also calls yield(), so shouldn't get here.
      for (;;)
        ;
    }
  }
}