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"
 
#include <config.h>
 
#include "MappingIndex.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*>(0x0000700000000000ULL - PEDIGREE_TARGET_PAGE_SIZE)
#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*>(0x0000701000000000ULL - PEDIGREE_TARGET_PAGE_SIZE)
#define KERNEL_STACK_SIZE 0x10000
 
class HostedVirtualAddressSpace : public VirtualAddressSpace {
  friend class HostedProcessor;
  friend class ProcessorBase;
  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);
  bool tryMapUserPage(physical_uintptr_t physical, void* address, size_t flags,
                      size_t* committedTablePages = nullptr) override;
  bool tryDetachUserPage(void* address, physical_uintptr_t expected) override;
  virtual bool getMapping(void* virtualAddress, physical_uintptr_t& physAddress, size_t& flags);
  virtual bool handleCopyOnWriteFault(void* virtualAddress, bool userMode);
  virtual bool tryWriteUser32(uintptr_t address, uint32_t value);
  virtual bool tryReadUser32(uintptr_t address, uint32_t& value);
  virtual bool tryReadUserPointer(uintptr_t address, uintptr_t& value);
  virtual bool tryCompareExchangeUser32(uintptr_t address, uint32_t& expected, uint32_t desired,
                                        bool& exchanged);
  virtual void setFlags(void* virtualAddress, size_t newFlags);
  MUST_USE_RESULT bool trySetFlags(void* virtualAddress, size_t newFlags) override;
  virtual void unmap(void* virtualAddress);
  virtual bool detachMapping(void* virtualAddress, physical_uintptr_t& physical, size_t& flags,
                             size_t requiredFlags = 0);
  virtual Stack* allocateStack();
  virtual Stack* allocateStack(size_t stackSz);
  virtual void freeStack(Stack* pStack);
 
  virtual bool memIsInHeap(void* pMem);
  virtual void* getEndOfHeap();
 
  virtual bool memIsInKernelHeap(void* pMem);
 
  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;
  }
 
  virtual uintptr_t getKernelVirtualPagestack() const {
    return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_PAGESTACK_4GB);
  }
 
 private:
  bool tryAccessUserWord(uintptr_t address, size_t width, uintptr_t& value,
                         const uintptr_t* replacement);
  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;
 
  // Mapping records can move during growth; the index stores array slots.
  mapping_t* findMapping(void* address);
 
  void* m_pStackTop;
  Vector<Stack*> m_freeStacks;
  bool m_bKernelSpace;
  Spinlock m_Lock;
  Spinlock m_StacksLock;
  mapping_t* m_pKnownMaps;
  HostedMappingIndex m_MappingIndex;
  size_t m_KnownMapsSize;
  size_t m_numKnownMaps;
  size_t m_nLastUnmap;
 
  static HostedVirtualAddressSpace m_KernelSpace;
};
 
#endif