include/pedigree/kernel/processor/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_VIRTUALADDRESSSPACE_H
#define KERNEL_PROCESSOR_VIRTUALADDRESSSPACE_H

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

class VirtualAddressSpace
{
  public:
    friend class Debugger;

    class Stack;

    static const size_t KernelMode = 0x01;
    static const size_t Write = 0x02;
    static const size_t Execute = 0x04;
    static const size_t WriteThrough = 0x08;
    static const size_t CacheDisable = 0x10;
    static const size_t CopyOnWrite = 0x20;
    static const size_t Swapped = 0x40;
    static const size_t MemoryCoherent = 0x80;
    static const size_t Guarded = 0x100;
    static const size_t Shared = 0x200;
    static const size_t WriteCombine = 0x400;
    static const size_t Accessed = 0x800;
    static const size_t Dirty = 0x1000;
    static const size_t ClearDirty = 0x2000;

    EXPORTED_PUBLIC static VirtualAddressSpace &getKernelAddressSpace();

    virtual void *expandHeap(ssize_t incr, size_t flags);

    virtual bool isAddressValid(void *virtualAddress) = 0;
    virtual bool isMapped(void *virtualAddress) = 0;

    virtual bool
    map(physical_uintptr_t physicalAddress, void *virtualAddress,
        size_t flags) = 0;
    virtual bool mapHuge(
        physical_uintptr_t physAddress, void *virtualAddress, size_t count,
        size_t flags);
    virtual void getMapping(
        void *virtualAddress, physical_uintptr_t &physicalAddress,
        size_t &flags) = 0;
    virtual void setFlags(void *virtualAddress, size_t newFlags) = 0;
    virtual void unmap(void *virtualAddress) = 0;

    virtual Stack *allocateStack() = 0;
    virtual Stack *allocateStack(size_t stackSz)
    {
        // Default implementation just ignores the stack size.
        return allocateStack();
    }
    virtual void freeStack(Stack *pStack) = 0;

    static VirtualAddressSpace *create();

    virtual VirtualAddressSpace *clone(bool copyOnWrite = true) = 0;

    virtual void revertToKernelAddressSpace() = 0;

    inline virtual ~VirtualAddressSpace()
    {
    }

    void setHeap(void *heap, void *heapEnd)
    {
        m_Heap = heap;
        m_HeapEnd = heapEnd;
    }

    virtual bool memIsInKernelHeap(void *pMem) = 0;

    virtual bool memIsInHeap(void *pMem) = 0;

    virtual void *getEndOfHeap() = 0;

    virtual uintptr_t getKernelStart() const = 0;

    virtual uintptr_t getUserStart() const = 0;

    virtual uintptr_t getUserReservedStart() const = 0;

    virtual uintptr_t getDynamicLinkerAddress() const = 0;

    virtual uintptr_t getKernelHeapStart() const = 0;

    virtual uintptr_t getKernelHeapEnd() const = 0;

    virtual uintptr_t getKernelCacheStart() const = 0;

    virtual uintptr_t getKernelCacheEnd() const = 0;

    virtual uintptr_t getKernelEventBlockStart() const = 0;

    virtual uintptr_t getKernelModulesStart() const = 0;

    virtual uintptr_t getKernelModulesEnd() const = 0;

    virtual uintptr_t getDynamicStart() const
    {
        return 0;
    }
    virtual uintptr_t getDynamicEnd() const
    {
        return 0;
    }

    virtual uintptr_t getGlobalInfoBlock() const
    {
        return 0;
    }

    void *m_Heap;
    void *m_HeapEnd;
    static physical_uintptr_t m_ZeroPage;

    class Stack
    {
      public:
        Stack(void *top, size_t size) : m_Top(top), m_Size(size)
        {
        }

        void *getTop() const
        {
            return m_Top;
        }

        size_t getSize() const
        {
            return m_Size;
        }

        operator void *() const
        {
            return m_Top;
        }

      private:
        void *m_Top;
        size_t m_Size;
    };

  protected:
    inline VirtualAddressSpace(void *Heap) : m_Heap(Heap), m_HeapEnd(Heap)
    {
    }

  private:
    VirtualAddressSpace();
    VirtualAddressSpace(const VirtualAddressSpace &);
    VirtualAddressSpace &operator=(const VirtualAddressSpace &);

    void rollbackHeapExpansion(void *virtualAddress, size_t pageCount);
};

#endif