kernel/core/processor/x86/VirtualAddressSpace.h

/*
 * 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.
 */

#ifndef KERNEL_PROCESSOR_X86_VIRTUALADDRESSSPACE_H
#define KERNEL_PROCESSOR_X86_VIRTUALADDRESSSPACE_H

#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/types.h"

//
// Virtual address space layout
//
#define KERNEL_SPACE_START reinterpret_cast<void *>(0xC0000000)

#define USERSPACE_DYNAMIC_LINKER_LOCATION reinterpret_cast<void *>(0x4FA00000)

#define USERSPACE_VIRTUAL_START reinterpret_cast<void *>(0x400000)
#define USERSPACE_VIRTUAL_HEAP reinterpret_cast<void *>(0x50000000)
#define USERSPACE_VIRTUAL_STACK reinterpret_cast<void *>(0xB0000000)
#define USERSPACE_RESERVED_START USERSPACE_VIRTUAL_HEAP
#define USERSPACE_VIRTUAL_MAX_STACK_SIZE 0x100000
#define USERSPACE_VIRTUAL_LOWEST_STACK reinterpret_cast<void *>(0x70000000)
#define VIRTUAL_PAGE_DIRECTORY reinterpret_cast<void *>(0xFFBFF000)
#define VIRTUAL_PAGE_TABLES reinterpret_cast<void *>(0xFFC00000)
#define KERNEL_VIRTUAL_TEMP1 reinterpret_cast<void *>(0xFFBFC000)
#define KERNEL_VIRTUAL_TEMP2 reinterpret_cast<void *>(0xFFBFD000)
#define KERNEL_VIRTUAL_TEMP3 reinterpret_cast<void *>(0xFFBFE000)
#define KERNEL_VIRTUAL_HEAP reinterpret_cast<void *>(0xC0000000)
#define KERNEL_VIRTUAL_HEAP_SIZE 0x10000000
#define KERNEL_VIRUTAL_PAGE_DIRECTORY reinterpret_cast<void *>(0xFF7FF000)
#define KERNEL_VIRTUAL_ADDRESS reinterpret_cast<void *>(0xFF400000 - 0x100000)
#define KERNEL_VIRTUAL_MEMORYREGION_ADDRESS reinterpret_cast<void *>(0xD0000000)
#define KERNEL_VIRTUAL_PAGESTACK_4GB reinterpret_cast<void *>(0xF0000000)
#define KERNEL_VIRTUAL_STACK reinterpret_cast<void *>(0xFF3F6000)
#define KERNEL_VIRTUAL_MEMORYREGION_SIZE 0x10000000
#define KERNEL_STACK_SIZE 0x8000

class X86VirtualAddressSpace : public VirtualAddressSpace
{
    friend class Processor;
    friend class Multiprocessor;
    friend VirtualAddressSpace *VirtualAddressSpace::create();

  public:
    //
    // VirtualAddressSpace Interface
    //
    virtual bool isAddressValid(void *virtualAddress);
    virtual bool isMapped(void *virtualAddress);
    virtual bool
    map(physical_uintptr_t physicalAddress, void *virtualAddress, size_t flags);
    virtual void getMapping(
        void *virtualAddress, physical_uintptr_t &physicalAddress,
        size_t &flags);
    virtual void setFlags(void *virtualAddress, size_t newFlags);
    virtual void unmap(void *virtualAddress);
    virtual void *allocateStack();
    virtual void *allocateStack(size_t stackSz);
    virtual void freeStack(void *pStack);

    virtual bool memIsInHeap(void *pMem);
    virtual void *getEndOfHeap();

    virtual VirtualAddressSpace *clone();
    virtual void revertToKernelAddressSpace();

    //
    // Needed for the PhysicalMemoryManager
    //
    bool mapPageStructures(
        physical_uintptr_t physicalAddress, void *virtualAddress, size_t flags);

    static void initialise() INITIALISATION_ONLY;
    virtual ~X86VirtualAddressSpace();

    virtual uintptr_t getKernelStart() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_SPACE_START);
    }

    virtual uintptr_t getUserStart() const
    {
        return reinterpret_cast<uintptr_t>(USERSPACE_VIRTUAL_START);
    }

    virtual uintptr_t getUserReservedStart() const
    {
        return reinterpret_cast<uintptr_t>(USERSPACE_RESERVED_START);
    }

    virtual uintptr_t getDynamicLinkerAddress() const
    {
        return reinterpret_cast<uintptr_t>(USERSPACE_DYNAMIC_LINKER_LOCATION);
    }

    virtual uintptr_t getKernelHeapStart() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_HEAP);
    }

    virtual uintptr_t getKernelHeapEnd() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_HEAP) +
               KERNEL_VIRTUAL_HEAP_SIZE;
    }

  protected:
    X86VirtualAddressSpace(
        void *Heap, physical_uintptr_t PhysicalPageDirectory,
        void *VirtualPageDirectory, void *VirtualPageTables,
        void *VirtualStack) INITIALISATION_ONLY;

    bool doIsMapped(void *virtualAddress);
    bool doMap(
        physical_uintptr_t physicalAddress, void *virtualAddress, size_t flags);
    void doGetMapping(
        void *virtualAddress, physical_uintptr_t &physicalAddress,
        size_t &flags);
    void doSetFlags(void *virtualAddress, size_t newFlags);
    void doUnmap(void *virtualAddress);
    void *doAllocateStack(size_t sSize);

  private:
    X86VirtualAddressSpace();

    X86VirtualAddressSpace(const X86VirtualAddressSpace &);
    X86VirtualAddressSpace &operator=(const X86VirtualAddressSpace &);

    bool getPageTableEntry(void *virtualAddress, uint32_t *&pageTableEntry);
    uint32_t toFlags(size_t flags, bool bFinal = false);
    size_t fromFlags(uint32_t Flags, bool bFinal = false);

    uintptr_t beginCrossSpace(X86VirtualAddressSpace *pOther);
    bool mapCrossSpace(
        uintptr_t &v, physical_uintptr_t physicalAddress, void *virtualAddress,
        size_t flags);
    void endCrossSpace();

    physical_uintptr_t m_PhysicalPageDirectory;
    void *m_VirtualPageDirectory;
    void *m_VirtualPageTables;
    void *m_pStackTop;
    Vector<void *> m_freeStacks;
    Spinlock m_Lock;
};

class X86KernelVirtualAddressSpace : public X86VirtualAddressSpace
{
    friend class X86VirtualAddressSpace;
    friend VirtualAddressSpace &VirtualAddressSpace::getKernelAddressSpace();

  public:
    //
    // VirtualAddressSpace Interface
    //
    virtual bool isMapped(void *virtualAddress);
    virtual bool
    map(physical_uintptr_t physicalAddress, void *virtualAddress, size_t flags);
    virtual void getMapping(
        void *virtualAddress, physical_uintptr_t &physicalAddress,
        size_t &flags);
    virtual void setFlags(void *virtualAddress, size_t newFlags);
    virtual void unmap(void *virtualAddress);
    virtual void *allocateStack();

  private:
    X86KernelVirtualAddressSpace();
    ~X86KernelVirtualAddressSpace();
    X86KernelVirtualAddressSpace(const X86KernelVirtualAddressSpace &);
    X86KernelVirtualAddressSpace &
    operator=(const X86KernelVirtualAddressSpace &);

    static X86KernelVirtualAddressSpace m_Instance;
};

#endif