kernel/core/processor/x64/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_X64_VIRTUALADDRESSSPACE_H
#define KERNEL_PROCESSOR_X64_VIRTUALADDRESSSPACE_H

#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/VirtualAddressSpace.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Vector.h"
#include "pedigree/kernel/utilities/utility.h"

#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_RESERVED_START USERSPACE_DYNAMIC_LINKER_LOCATION
#define USERSPACE_VIRTUAL_STACK_SIZE 0x100000
#define USERSPACE_VIRTUAL_MAX_STACK_SIZE 0x100000
#define USERSPACE_DYNAMIC_START reinterpret_cast<void *>(0x100000000)
#define USERSPACE_DYNAMIC_END reinterpret_cast<void *>(0x00000FFFFFFFFFFF)
#define USERSPACE_VIRTUAL_LOWEST_STACK \
    reinterpret_cast<void *>(          \
        USERSPACE_DYNAMIC_END + USERSPACE_VIRTUAL_MAX_STACK_SIZE)
#define USERSPACE_VIRTUAL_STACK \
    reinterpret_cast<void *>(0x00007FFFEFFFF000)  // right below the Event base
#define KERNEL_VIRTUAL_EVENT_BASE \
    reinterpret_cast<void *>(0x00007FFFF0000000)  // right above the stacks

#define KERNEL_SPACE_START reinterpret_cast<void *>(0xFFFF800000000000)
#define KERNEL_VIRTUAL_PAGESTACK_ABV4GB1 \
    reinterpret_cast<void *>(0xFFFF800100000000)
#define KERNEL_VIRTUAL_PAGESTACK_ABV4GB2 \
    reinterpret_cast<void *>(0xFFFF801000000000)
#define KERNEL_VIRTUAL_HEAP reinterpret_cast<void *>(0xFFFF900000000000)
#define KERNEL_VIRTUAL_CACHE reinterpret_cast<void *>(0xFFFFB00000000000)
#define KERNEL_VIRTUAL_MEMORYREGION_ADDRESS \
    reinterpret_cast<void *>(0xFFFFF00000000000)
#define KERNEL_VIRTUAL_PAGESTACK_4GB \
    reinterpret_cast<void *>(0xFFFFFFFF7FC00000)
#define KERNEL_VIRTUAL_ADDRESS reinterpret_cast<void *>(0xFFFFFFFF7FF00000)
#define KERNEL_VIRTUAL_INFO_BLOCK reinterpret_cast<void *>(0xFFFFFFFF8FFF0000)
#define KERNEL_VIRTUAL_MODULE_BASE reinterpret_cast<void *>(0xFFFFFFFF90000000)
#define KERNEL_VIRTUAL_LOWEST_STACK reinterpret_cast<void *>(0xFFFFFFFFE0000000)
#define KERNEL_VIRTUAL_STACK reinterpret_cast<void *>(0xFFFFFFFFFFFF7000)

#define KERNEL_VIRTUAL_MODULE_SIZE \
    pointer_diff_const(KERNEL_VIRTUAL_MODULE_BASE, KERNEL_VIRTUAL_LOWEST_STACK)
#define KERNEL_VIRTUAL_HEAP_SIZE \
    pointer_diff_const(KERNEL_VIRTUAL_HEAP, KERNEL_VIRTUAL_CACHE)
#define KERNEL_VIRTUAL_CACHE_SIZE \
    pointer_diff_const(           \
        KERNEL_VIRTUAL_CACHE, KERNEL_VIRTUAL_MEMORYREGION_ADDRESS)
#define KERNEL_VIRTUAL_MEMORYREGION_SIZE \
    pointer_diff_const(                  \
        KERNEL_VIRTUAL_MEMORYREGION_ADDRESS, KERNEL_VIRTUAL_PAGESTACK_4GB)
#define KERNEL_STACK_SIZE 0x8000

class X64VirtualAddressSpace : public VirtualAddressSpace
{
    friend class Processor;
    friend class Multiprocessor;
    friend VirtualAddressSpace &VirtualAddressSpace::getKernelAddressSpace();
    friend VirtualAddressSpace *VirtualAddressSpace::create();

  public:
    //
    // VirtualAddressSpace Interface
    //
    virtual bool isAddressValid(void *virtualAddress);
    virtual bool isMapped(void *virtualAddress);

    virtual bool
    map(physical_uintptr_t physAddress, void *virtualAddress, size_t flags);
    virtual bool mapHuge(
        physical_uintptr_t physAddress, void *virtualAddress, size_t count,
        size_t flags);
    virtual void getMapping(
        void *virtualAddress, physical_uintptr_t &physAddress, size_t &flags);
    virtual void setFlags(void *virtualAddress, size_t newFlags);
    virtual void unmap(void *virtualAddress);
    virtual Stack *allocateStack();
    virtual Stack *allocateStack(size_t stackSz);
    virtual void freeStack(Stack *pStack);

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

    virtual VirtualAddressSpace *clone(bool copyOnWrite = true);
    virtual void revertToKernelAddressSpace();

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

    virtual ~X64VirtualAddressSpace();

    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;
    }

    virtual uintptr_t getDynamicStart() const
    {
        return reinterpret_cast<uintptr_t>(USERSPACE_DYNAMIC_START);
    }

    virtual uintptr_t getDynamicEnd() const
    {
        return reinterpret_cast<uintptr_t>(USERSPACE_DYNAMIC_END);
    }

    virtual uintptr_t getGlobalInfoBlock() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_INFO_BLOCK);
    }

    virtual uintptr_t getKernelCacheStart() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_CACHE);
    }

    virtual uintptr_t getKernelCacheEnd() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_CACHE) +
               KERNEL_VIRTUAL_CACHE_SIZE;
    }

    virtual uintptr_t getKernelEventBlockStart() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_EVENT_BASE);
    }

    virtual uintptr_t getKernelModulesStart() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_MODULE_BASE);
    }

    virtual uintptr_t getKernelModulesEnd() const
    {
        return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_MODULE_BASE) +
               KERNEL_VIRTUAL_MODULE_SIZE;
    }

  private:
    X64VirtualAddressSpace();
    X64VirtualAddressSpace(
        void *Heap, physical_uintptr_t PhysicalPML4, void *VirtualStack);

    X64VirtualAddressSpace(const X64VirtualAddressSpace &);
    X64VirtualAddressSpace &operator=(const X64VirtualAddressSpace &);

    bool
    getPageTableEntry(void *virtualAddress, uint64_t *&pageTableEntry) const;
    void maybeFreeTables(void *virtualAddress);
    uint64_t toFlags(size_t flags, bool bFinal = false) const PURE;
    size_t fromFlags(uint64_t Flags, bool bFinal = false) const PURE;
    bool conditionalTableEntryAllocation(uint64_t *tableEntry, uint64_t flags);
    bool conditionalTableEntryMapping(
        uint64_t *tableEntry, uint64_t physAddress, uint64_t flags);

    bool mapUnlocked(
        physical_uintptr_t physAddress, void *virtualAddress, size_t flags,
        bool locked = false);

    void unmapUnlocked(void *virtualAddress, bool requireMapped = true);

    Stack *doAllocateStack(size_t sSize);

    physical_uintptr_t m_PhysicalPML4;
    void *m_pStackTop;
    Vector<Stack *> m_freeStacks;
    bool m_bKernelSpace;
    Spinlock m_Lock;
    Spinlock m_StacksLock;

    static X64VirtualAddressSpace m_KernelSpace;
};

#endif