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/Log.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/UserMemoryPolicy.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Pointers.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include <config.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 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;
  static const size_t NoAccess = 0x4000;
  static const size_t WriteProtected = 0x8000;
  static const size_t Borrowed = 0x10000;
  static const size_t RuntimeMapping = 0x20000;
 
  RawUserMemory& rawUserMemory() {
    return m_RawUserMemory;
  }
  virtual size_t runtimeMappingPages(uintptr_t, size_t) {
    return 0;
  }
  MemoryLockAccount* memoryLockAccount() const {
    return m_MemoryLockAccount;
  }
  void setMemoryLockAccount(MemoryLockAccount* account) {
    m_MemoryLockAccount = account;
  }
  UserMemoryPolicy* userMemoryPolicy() const {
    return m_UserMemoryPolicy;
  }
  void setUserMemoryPolicy(UserMemoryPolicy* policy) {
    m_UserMemoryPolicy = policy;
  }
 
  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;
  // Fallible user-page publication; the caller retains the page on failure.
  // These checked paging helpers leave process accounting to the admitted owner.
  // Report only new table pages committed by a successful publication.
  virtual bool tryMapUserPage(physical_uintptr_t physical, void* address, size_t flags,
                              size_t* committedTablePages = nullptr) {
    if (committedTablePages)
      *committedTablePages = 0;
    return false;
  }
  // Detach only the expected, access-revoked user page. No ownership transfers
  // until success, including host mapping failures.
  virtual bool tryDetachUserPage(void* address, physical_uintptr_t expected) {
    return false;
  }
  virtual bool mapHuge(physical_uintptr_t physAddress, void* virtualAddress, size_t count,
                       size_t flags);
  virtual bool getMapping(void* virtualAddress, physical_uintptr_t& physicalAddress,
                          size_t& flags) = 0;
 
  virtual bool handleCopyOnWriteFault(void* virtualAddress, bool userMode) = 0;
 
  enum class ResidentCopyStatus { Success, Inaccessible, Unsupported };
 
  virtual ResidentCopyStatus copyResidentUserPage(uintptr_t userAddress, void* kernelBuffer,
                                                  size_t bytes, bool write) {
    (void)userAddress;
    (void)kernelBuffer;
    (void)bytes;
    (void)write;
    return ResidentCopyStatus::Unsupported;
  }
 
  virtual bool tryWriteUser32(uintptr_t address, uint32_t value) {
    (void)address;
    (void)value;
    return false;
  }
 
  virtual bool tryReadUser32(uintptr_t address, uint32_t& value) {
    (void)address;
    (void)value;
    return false;
  }
 
  virtual bool tryReadUserPointer(uintptr_t address, uintptr_t& value) {
    (void)address;
    (void)value;
    return false;
  }
 
  virtual bool tryCompareExchangeUser32(uintptr_t address, uint32_t& expected, uint32_t desired,
                                        bool& exchanged) {
    (void)address;
    (void)expected;
    (void)desired;
    exchanged = false;
    return false;
  }
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  using CopyOnWritePreCommitHook = void (*)(void*);
 
  static EXPORTED_PUBLIC void setCopyOnWritePreCommitHookForTest(CopyOnWritePreCommitHook hook);
#endif
 
  virtual void setFlags(void* virtualAddress, size_t newFlags) = 0;
 
  MUST_USE_RESULT virtual bool trySetFlags(void* virtualAddress, size_t newFlags) {
    (void)virtualAddress;
    (void)newFlags;
    return false;
  }
  virtual void unmap(void* virtualAddress) = 0;
 
  virtual bool detachMapping(void* virtualAddress, physical_uintptr_t& physical, size_t& flags,
                             size_t requiredFlags = 0) {
    physical = 0;
    flags = 0;
    return false;
  }
 
  enum class RemapStatus { Success, InvalidRange, Unsupported, NoMemory, Retry };
  static constexpr size_t MaximumRemapPages = 65536;
  struct RemapRange {
    uintptr_t base;
    size_t length;
  };
  struct PageRemapRequest {
    uintptr_t source, destination;
    size_t oldLength, newLength;
    bool replace;
    const RemapRange* victims = nullptr;
    size_t victimCount = 0;
  };
  struct DetachedPage {
    uintptr_t address;
    physical_uintptr_t physical;
    size_t flags;
    bool mapped;
  };
  using RemapAdmission = bool (*)(void* context);
  class PreparedPageRemap {
   public:
    virtual ~PreparedPageRemap() = default;
    virtual RemapStatus commit(RemapAdmission admission, void* context) = 0;
    virtual const DetachedPage* detachedPages() const = 0;
    virtual size_t detachedPageCount() const = 0;
  };
  virtual RemapStatus prepareRemap(const PageRemapRequest& request,
                                   UniquePointer<PreparedPageRemap>& plan) {
    (void)request;
    plan.reset();
    return RemapStatus::Unsupported;
  }
 
  virtual void setRemapPreparationFailureForTest(ssize_t allocations) {
    (void)allocations;
  }
 
  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 getKernelVirtualPagestack() const {
    return 0;
  }
 
  virtual uintptr_t getKernelVirtualPagestackAdd1() const {
    return 0;
  }
 
  virtual uintptr_t getKernelVirtualPagestackAdd2() const {
    return 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, uint64_t regionId = 0)
        : m_Top(top), m_Size(size), m_RegionId(regionId) {}
    uint64_t regionId() const {
      return m_RegionId;
    }
 
    void* getTop() const {
      return m_Top;
    }
 
    void* getBase() const {
      if (m_Top) {
        return adjust_pointer(m_Top, -m_Size);
      } else {
        return nullptr;
      }
    }
 
    size_t getSize() const {
      return m_Size;
    }
 
    operator void*() const {
      return m_Top;
    }
 
   private:
    void* m_Top;
    size_t m_Size;
    uint64_t m_RegionId;
  };
 
 protected:
  bool admitRawMemoryChange(const PreparedMemoryLock& plan, bool privileged,
                            MemoryLockCharge& charge) const;
  void commitRawMemoryChange(PreparedMemoryLock& plan, MemoryLockCharge charge);
  bool prepareZeroPage();
  uint64_t m_HeapRegionId = 0;
 
  inline VirtualAddressSpace(void* Heap) : m_Heap(Heap), m_HeapEnd(Heap), m_RawUserMemory(*this) {}
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static void copyOnWritePreCommitForTest(void* virtualAddress);
#endif
 
 private:
  RawUserMemory m_RawUserMemory;
  MemoryLockAccount* m_MemoryLockAccount = nullptr;
  UserMemoryPolicy* m_UserMemoryPolicy = nullptr;
 
  VirtualAddressSpace();
  VirtualAddressSpace(const VirtualAddressSpace&);
  VirtualAddressSpace& operator=(const VirtualAddressSpace&);
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static CopyOnWritePreCommitHook m_CopyOnWritePreCommitHook;
#endif
 
  void rollbackHeapExpansion(void* virtualAddress, size_t pageCount);
};
 
#endif