x64/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/linker/KernelElf.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/PhysicalMemoryManager.h"
#include "pedigree/kernel/processor/Processor.h"
#include "pedigree/kernel/processor/ProcessorInformation.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/state.h"
#include "pedigree/kernel/utilities/Iterator.h"
#include "pedigree/kernel/utilities/StaticString.h"
#include "pedigree/kernel/utilities/utility.h"
 
PageFaultHandler PageFaultHandler::m_Instance;
 
#define PAGE_FAULT_EXCEPTION 0x0E
#define PFE_PAGE_PRESENT 0x01
#define PFE_ATTEMPTED_WRITE 0x02
#define PFE_USER_MODE 0x04
#define PFE_RESERVED_BIT 0x08
#define PFE_INSTRUCTION_FETCH 0x10
#define PFE_PROTECTION_KEY 0x20
#define PFE_SHADOW_STACK 0x40
 
bool PageFaultHandler::initialise() {
  InterruptManager& IntManager = InterruptManager::instance();
 
  return (IntManager.registerInterruptHandler(PAGE_FAULT_EXCEPTION, this));
}
 
void PageFaultHandler::interrupt(size_t interruptNumber, InterruptState& state) {
  const bool collectMetrics = Processor::m_Initialised == 2;
  if (collectMetrics) {
    Metrics::increment(Metrics::PageFault);
  }
 
  uintptr_t cr2, code;
  asm volatile("mov %%cr2, %%rax" : "=a"(cr2));
  code = state.m_Errorcode;
 
  uintptr_t page = cr2 & ~(PhysicalMemoryManager::instance().getPageSize() - 1);
 
  VirtualAddressSpace& va = Processor::information().getVirtualAddressSpace();
  const bool copyOnWriteFault =
      (code & (PFE_PAGE_PRESENT | PFE_ATTEMPTED_WRITE)) ==
          (PFE_PAGE_PRESENT | PFE_ATTEMPTED_WRITE) &&
      !(code & (PFE_RESERVED_BIT | PFE_INSTRUCTION_FETCH | PFE_PROTECTION_KEY | PFE_SHADOW_STACK));
  if (copyOnWriteFault &&
      va.handleCopyOnWriteFault(reinterpret_cast<void*>(page), (code & PFE_USER_MODE) != 0)) {
    if (collectMetrics) {
      Metrics::increment(Metrics::PageFaultCopyOnWrite);
    }
    return;
  }
 
  if (!va.memIsInKernelHeap(reinterpret_cast<void*>(page))) {
    if (dispatchHandlers(state, cr2, code & PFE_ATTEMPTED_WRITE, code & PFE_PAGE_PRESENT)) {
      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), cr2, code);
      if (collectMetrics) {
        Metrics::increment(Metrics::PageFaultDeferred);
      }
      return;
    }
  }
 
  //  Get PFE location and error code
  LargeStaticString sError;
  sError.append("Page Fault Exception at 0x");
  sError.append(cr2, 16, 16, '0');
  sError.append(", EIP 0x");
  sError.append(state.getInstructionPointer(), 16, 16, '0');
  sError.append(", error code 0x");
  sError.append(code, 16, 8, '0');
 
  // Module teardown can retire debugger dependencies and process machinery.
  // The terminal panic path uses the retained display without log callbacks.
  if (state.kernelMode() && KernelElf::instance().isShuttingDown()) {
    panic(sError);
  }
 
  //  Extract error code information
  static LargeStaticString sCode;
  sCode.clear();
  sCode.append("Details: CPU=");
  sCode.append(Processor::id());
  if (pThread) {
    Process* pParent = pThread->getParent();
    if (pParent) {
      sCode.append(" PID=");
      sCode.append(pParent->getId());
    }
    sCode.append(" TID=");
    sCode.append(pThread->getId());
  }
  sCode.append(" ");
 
  if (!(code & PFE_PAGE_PRESENT))
    sCode.append("NOT ");
  sCode.append("PRESENT | ");
 
  if (code & PFE_ATTEMPTED_WRITE)
    sCode.append("WRITE | ");
  else
    sCode.append("READ | ");
 
  if (code & PFE_USER_MODE)
    sCode.append("USER ");
  else
    sCode.append("KERNEL ");
  sCode.append("MODE | ");
 
  if (code & PFE_RESERVED_BIT)
    sCode.append("RESERVED BIT SET | ");
  if (code & PFE_INSTRUCTION_FETCH)
    sCode.append("FETCH |");
 
  // Ensure the log spinlock isn't going to die on us...
  //  Log::instance().m_Lock.release();
 
  ERROR(static_cast<const char*>(sError));
  ERROR(static_cast<const char*>(sCode));
 
// static LargeStaticString eCode;
#if DEBUGGER
  // Page faults in usermode are usually useless to debug in the debugger
  // (some exceptions exist)
  if (!(code & PFE_USER_MODE))
    Debugger::instance().start(state, sError);
#endif
 
  Scheduler& scheduler = Scheduler::instance();
  if (UNLIKELY(scheduler.getNumProcesses() == 0) || (pThread == nullptr)) {
    // 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();
    Process* pProcess = pThread->getParent();
    Subsystem* pSubsystem = pProcess->getSubsystem();
    if (!pSubsystem || state.kernelMode()) {
      pProcess->kill();
    }
  }
}