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/processor/PageFaultHandler.h"
#include "pedigree/kernel/Log.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/MemoryRegion.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

bool PageFaultHandler::initialise()
{
    InterruptManager &IntManager = InterruptManager::instance();

    return (IntManager.registerInterruptHandler(PAGE_FAULT_EXCEPTION, this));
}

void PageFaultHandler::interrupt(size_t interruptNumber, InterruptState &state)
{
    uintptr_t cr2, code;
    asm volatile("mov %%cr2, %%rax" : "=a"(cr2));
    code = state.m_Errorcode;

    uintptr_t page =
        cr2 & ~(PhysicalMemoryManager::instance().getPageSize() - 1);

    // Check for copy-on-write.
    VirtualAddressSpace &va = Processor::information().getVirtualAddressSpace();
    if (va.isMapped(reinterpret_cast<void *>(page)))
    {
        physical_uintptr_t phys;
        size_t flags;
        va.getMapping(reinterpret_cast<void *>(page), phys, flags);
        if (flags & VirtualAddressSpace::CopyOnWrite)
        {
#ifdef SUPERDEBUG
            NOTICE_NOLOCK(
                Processor::information()
                    .getCurrentThread()
                    ->getParent()
                    ->getId()
                << " PageFaultHandler: copy-on-write for v=" << Hex << page);
#endif

            MemoryRegion tmpRegion("CoW Temporary Page");
            if (!PhysicalMemoryManager::instance().allocateRegion(
                    tmpRegion, 1,
                    PhysicalMemoryManager::force |
                        PhysicalMemoryManager::continuous |
                        PhysicalMemoryManager::anonymous,
                    VirtualAddressSpace::KernelMode, phys))
            {
                FATAL(
                    "PageFaultHandler: CoW temporary map() failed @" << Hex
                                                                     << page);
                return;
            }

            // Remap faulting page
            va.unmap(reinterpret_cast<void *>(page));
            physical_uintptr_t p =
                PhysicalMemoryManager::instance().allocatePage();
            if (!p)
            {
                FATAL("PageFaultHandler: CoW OOM'd!");
                return;
            }

            flags |= VirtualAddressSpace::Write;
            flags &= ~VirtualAddressSpace::CopyOnWrite;
            if (!va.map(p, reinterpret_cast<void *>(page), flags))
            {
                FATAL("PageFaultHandler: CoW new map() failed.");
                return;
            }

            // Perform the actual copy.
            MemoryCopy(
                reinterpret_cast<uint8_t *>(page),
                reinterpret_cast<uint8_t *>(tmpRegion.virtualAddress()),
                PhysicalMemoryManager::getPageSize());

            // Done with the memory region now - ready to release any additional
            // references too
            tmpRegion.free();

            // Clean up old reference to memory (may free the page, if we were
            // the last one to reference the CoW page)
            PhysicalMemoryManager::instance().freePage(phys);
            return;
        }
    }

    if (!va.memIsInKernelHeap(reinterpret_cast<void *>(page)))
    {
        // Check our handler list.
        for (List<MemoryTrapHandler *>::Iterator it = m_Handlers.begin();
             it != m_Handlers.end(); it++)
        {
            if ((*it)->trap(state, cr2, code & PFE_ATTEMPTED_WRITE))
            {
                return;
            }
        }
    }

    Thread *pThread = Processor::information().getCurrentThread();

    //  Get PFE location and error code
    static LargeStaticString sError;
    sError.clear();
    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');

    //  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;
#ifdef 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())
            pSubsystem->threadException(pThread, Subsystem::PageFault);
        else
        {
            pProcess->kill();
        }
    }
}

PageFaultHandler::PageFaultHandler() : m_Handlers()
{
}