kernel/core/processor/armv7/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_ARMV7_VIRTUALADDRESSSPACE_H
#define KERNEL_PROCESSOR_ARMV7_VIRTUALADDRESSSPACE_H

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

#define USERSPACE_DYNAMIC_LINKER_LOCATION reinterpret_cast<void *>(0x1FA00000)
#define USERSPACE_VIRTUAL_START reinterpret_cast<void *>(0x1000)
#define USERSPACE_VIRTUAL_HEAP reinterpret_cast<void *>(0x20000000)
#define USERSPACE_RESERVED_START USERSPACE_DYNAMIC_LINKER_LOCATION
#define USERSPACE_VIRTUAL_STACK reinterpret_cast<void *>(0x3FE00000)
#define USERSPACE_PAGEDIR \
    reinterpret_cast<void *>(0x3FFFF000)  
#define USERSPACE_PAGETABLES reinterpret_cast<void *>(0x3FE00000)
#define USERSPACE_VIRTUAL_STACK_SIZE 0x100000
#define KERNEL_SPACE_START reinterpret_cast<void *>(0x40000000)
#define KERNEL_VIRTUAL_HEAP reinterpret_cast<void *>(0x40000000)
#define KERNEL_VIRTUAL_HEAP_SIZE 0x20000000
#define KERNEL_VIRTUAL_MODULE_BASE reinterpret_cast<void *>(0x60000000)
#define KERNEL_VIRTUAL_MODULE_SIZE 0x400000
#define KERNEL_VIRTUAL_ADDRESS reinterpret_cast<void *>(0x80008000)
#define KERNEL_VIRTUAL_CACHE reinterpret_cast<void *>(0xA0000000)
#define KERNEL_VIRTUAL_CACHE_SIZE 0x10000000
#define KERNEL_VIRTUAL_MEMORYREGION_ADDRESS reinterpret_cast<void *>(0xB0000000)
#define KERNEL_VIRTUAL_EVENT_BASE reinterpret_cast<void *>(0xE0000000)
#define KERNEL_VIRTUAL_PAGESTACK_4GB reinterpret_cast<void *>(0xF0000000)
#define KERNEL_VIRTUAL_STACK reinterpret_cast<void *>(0xFEFFF000)
#define KERNEL_TEMP0 reinterpret_cast<void *>(0xFE000000)
#define KERNEL_TEMP1 reinterpret_cast<void *>(0xFE001000)
#define KERNEL_PAGEDIR \
    reinterpret_cast<void *>(0xFFFB0000)  // 0xFFFF0000 is where we'll put the
                                          // exception base vectors
#define KERNEL_PAGETABLES reinterpret_cast<void *>(0xFF000000)
#define KERNEL_VIRTUAL_MEMORYREGION_SIZE 0x30000000
#define KERNEL_STACK_SIZE 0x20000

class ArmV7VirtualAddressSpace : public VirtualAddressSpace
{
    friend class Processor;
    friend VirtualAddressSpace *VirtualAddressSpace::create();
    friend class ArmV7KernelVirtualAddressSpace;

  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();

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

    virtual VirtualAddressSpace *clone()
    {
        return 0;
    };

    virtual void revertToKernelAddressSpace(){};

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

  protected:
    virtual ~ArmV7VirtualAddressSpace();

    ArmV7VirtualAddressSpace(
        void *Heap, physical_uintptr_t PhysicalPageDirectory,
        void *VirtualPageDirectory, void *VirtualPageTables,
        void *VirtualStack);

    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:
    ArmV7VirtualAddressSpace(
        void *Heap, physical_uintptr_t PhysicalPageDirectory,
        void *VirtualPageDirectory, void *VirtualPageTables);

    ArmV7VirtualAddressSpace();
    ArmV7VirtualAddressSpace(const ArmV7VirtualAddressSpace &);
    ArmV7VirtualAddressSpace &operator=(const ArmV7VirtualAddressSpace &);

    bool initialise();

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

    struct FirstLevelDescriptor
    {

        union
        {
            struct
            {
                uint32_t type : 2;
                uint32_t ignore : 30;
            } PACKED fault;
            struct
            {
                uint32_t type : 2;
                uint32_t sbz1 : 1;
                uint32_t ns : 1;
                uint32_t sbz2 : 1;
                uint32_t domain : 4;
                uint32_t imp : 1;
                uint32_t baseaddr : 22;
            } PACKED pageTable;
            struct
            {
                uint32_t type : 2;
                uint32_t b : 1;
                uint32_t c : 1;
                uint32_t xn : 1;
                uint32_t domain : 4;  
                uint32_t imp : 1;
                uint32_t ap1 : 2;
                uint32_t tex : 3;
                uint32_t ap2 : 1;
                uint32_t s : 1;
                uint32_t nG : 1;
                uint32_t
                    sectiontype : 1;  
                uint32_t ns : 1;
                uint32_t base : 12;
            } PACKED section;

            uint32_t entry;
        } descriptor;
    } PACKED;

    struct SecondLevelDescriptor
    {

        union
        {
            struct
            {
                uint32_t type : 2;
                uint32_t ignore : 30;
            } PACKED fault;
            struct
            {
                uint32_t type : 2;
                uint32_t b : 1;
                uint32_t c : 1;
                uint32_t ap1 : 2;
                uint32_t sbz : 3;
                uint32_t ap2 : 1;
                uint32_t s : 1;
                uint32_t nG : 1;
                uint32_t tex : 3;
                uint32_t xn : 1;
                uint32_t base : 16;
            } PACKED largepage;
            struct
            {
                uint32_t type : 2;
                uint32_t b : 1;
                uint32_t c : 1;
                uint32_t ap1 : 2;
                uint32_t sbz : 3;
                uint32_t ap2 : 1;
                uint32_t s : 1;
                uint32_t nG : 1;
                uint32_t base : 20;
            } PACKED smallpage;

            uint32_t entry;
        } descriptor;
    } PACKED;

    physical_uintptr_t m_PhysicalPageDirectory;
    void *m_VirtualPageDirectory;
    void *m_VirtualPageTables;

    void *m_pStackTop;
    Vector<void *> m_freeStacks;

    Spinlock m_Lock;
};

class ArmV7KernelVirtualAddressSpace : public ArmV7VirtualAddressSpace
{
    friend class Processor;
    friend class ArmV7VirtualAddressSpace;
    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 bool initialiseKernelAddressSpace();

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

    static ArmV7KernelVirtualAddressSpace m_Instance;
};

#endif