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/Atomic.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"
 
#include <config.h>
 
class X64MappingMutationScope;
class X64PreparedPageRemap;
 
#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 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 size_t runtimeMappingPages(uintptr_t base, size_t length);
 
  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 mapHuge(physical_uintptr_t physAddress, void* virtualAddress, size_t count,
                       size_t flags);
  virtual bool getMapping(void* virtualAddress, physical_uintptr_t& physAddress, size_t& flags);
  virtual bool handleCopyOnWriteFault(void* virtualAddress, bool userMode);
  ResidentCopyStatus copyResidentUserPage(uintptr_t userAddress, void* kernelBuffer, size_t bytes,
                                          bool write) override;
  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);
  RemapStatus prepareRemap(const PageRemapRequest& request,
                           UniquePointer<PreparedPageRemap>& plan) override;
  void setRemapPreparationFailureForTest(ssize_t allocations) override {
    __atomic_store_n(&m_RemapPreparationFailure, allocations, __ATOMIC_RELEASE);
  }
  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;
  }
 
  virtual uintptr_t getKernelVirtualPagestack() const {
    return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_PAGESTACK_4GB);
  }
 
  virtual uintptr_t getKernelVirtualPagestackAdd1() const {
    return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_PAGESTACK_ABV4GB1);
  }
 
  virtual uintptr_t getKernelVirtualPagestackAdd2() const {
    return reinterpret_cast<uintptr_t>(KERNEL_VIRTUAL_PAGESTACK_ABV4GB2);
  }
 
 private:
  friend class X64PreparedPageRemap;
  bool tryAccessUserWord(uintptr_t address, size_t width, uintptr_t& value,
                         const uintptr_t* replacement);
  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;
  size_t detachEmptyTables(void* virtualAddress, physical_uintptr_t* detachedTables);
  bool invalidateMapping(void* virtualAddress, X64MappingMutationScope& mutation);
  uint64_t toFlags(size_t flags, void* virtualAddress, 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,
                   X64MappingMutationScope& mutation, bool locked = false);
 
  bool unmapUnlocked(void* virtualAddress, X64MappingMutationScope& mutation,
                     bool requireMapped = true);
 
  Stack* doAllocateStack(size_t sSize);
  Stack* allocateTrackedUserStack(size_t size);
 
  physical_uintptr_t m_PhysicalPML4;
  Atomic<uint64_t> m_ResidentProcessors;
  ssize_t m_RemapPreparationFailure = -1;
  void* m_pStackTop;
  Vector<Stack*> m_freeStacks;
  bool m_bKernelSpace;
  Spinlock m_Lock;
  Spinlock m_StacksLock;
 
  static X64VirtualAddressSpace m_KernelSpace;
};
 
#endif