kernel/core/processor/hosted/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_HOSTED_VIRTUALADDRESSSPACE_H
#define KERNEL_PROCESSOR_HOSTED_VIRTUALADDRESSSPACE_H

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

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

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

#define USERSPACE_VIRTUAL_START reinterpret_cast<void *>(0x20000000)
#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 *>(0x0000400000000000)
#define USERSPACE_DYNAMIC_END reinterpret_cast<void *>(0x0000500000000000)
#define USERSPACE_VIRTUAL_LOWEST_STACK \
    reinterpret_cast<void *>(          \
        USERSPACE_DYNAMIC_END + USERSPACE_VIRTUAL_MAX_STACK_SIZE)
#define USERSPACE_VIRTUAL_STACK reinterpret_cast<void *>(0x00006FFFFFFFF000)
#define KERNEL_VIRTUAL_MODULE_BASE reinterpret_cast<void *>(0x70000000)
#define KERNEL_VIRTUAL_MODULE_SIZE 0x10000000
#define KERNEL_VIRTUAL_EVENT_BASE reinterpret_cast<void *>(0x300000000000)
#define KERNEL_VIRTUAL_HEAP reinterpret_cast<void *>(0x0000700000000000)
#define KERNEL_VIRTUAL_HEAP_SIZE 0x40000000
#define KERNEL_VIRTUAL_ADDRESS reinterpret_cast<void *>(0x400000)
#define KERNEL_VIRTUAL_CACHE reinterpret_cast<void *>(0x200000000000)
#define KERNEL_VIRTUAL_CACHE_SIZE 0x10000000
#define KERNEL_VIRTUAL_MEMORYREGION_ADDRESS \
    reinterpret_cast<void *>(0x0000700040000000)
#define KERNEL_VIRTUAL_MEMORYREGION_SIZE 0x40000000
#define KERNEL_VIRTUAL_PAGESTACK_4GB \
    reinterpret_cast<void *>(0x0000700080000000)
#define KERNEL_VIRTUAL_STACK reinterpret_cast<void *>(0x0000700FFFFFF000)
#define KERNEL_STACK_SIZE 0x10000

class HostedVirtualAddressSpace : 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 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 memIsInHeap(void *pMem);
    virtual void *getEndOfHeap();

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

    virtual ~HostedVirtualAddressSpace();

    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 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:
    HostedVirtualAddressSpace();
    HostedVirtualAddressSpace(void *Heap, void *VirtualStack);

    HostedVirtualAddressSpace(const HostedVirtualAddressSpace &);
    HostedVirtualAddressSpace &operator=(const HostedVirtualAddressSpace &);

    static void switchAddressSpace(
        VirtualAddressSpace &oldSpace, VirtualAddressSpace &newSpace);

    uint64_t toFlags(size_t flags, bool bFinal = false);
    size_t fromFlags(uint64_t Flags, bool bFinal = false);

    Stack *doAllocateStack(size_t sSize);

    typedef struct
    {
        bool active;
        void *vaddr;
        physical_uintptr_t paddr;
        size_t flags;  // Real flags, not the mmap-specific ones.
    } mapping_t;

    void *m_pStackTop;
    Vector<Stack *> m_freeStacks;
    bool m_bKernelSpace;
    Spinlock m_Lock;
    mapping_t *m_pKnownMaps;
    size_t m_KnownMapsSize;
    size_t m_numKnownMaps;
    size_t m_nLastUnmap;

    static HostedVirtualAddressSpace m_KernelSpace;
};

#endif