include/pedigree/kernel/processor/PhysicalMemoryManager.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_PHYSICALMEMORYMANAGER_H
#define KERNEL_PROCESSOR_PHYSICALMEMORYMANAGER_H
 
#include "pedigree/kernel/TargetInfo.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/Vector.h"
 
class MemoryRegion;
 
class EXPORTED_PUBLIC PhysicalMemoryManager {
  friend class CacheManager;
  friend class Cache;
 
 public:
  friend class MemoryRegion;
 
  static const size_t continuous = 1 << 0;
  static const size_t nonRamMemory = 1 << 1;
  static const size_t force = 1 << 2;
  static const size_t virtualOnly = 1 << 3;
 
  static const size_t below1MB = 1 << 4;
  static const size_t below16MB = 1 << 5;
  static const size_t below4GB = 1 << 6;
  static const size_t below64GB = 1 << 7;
 
  static const size_t addressConstraints = below1MB | below16MB | below4GB | below64GB;
 
  static const size_t anonymous = 1 << 8;
 
  static PhysicalMemoryManager& instance();
 
  inline static constexpr size_t getPageSize() PURE {
    return TargetInfo::getPageSize();
  }
  virtual physical_uintptr_t allocatePage(size_t pageConstraints = 0) = 0;
  // This path never invokes reclaim and reports exhaustion without panicking.
  virtual physical_uintptr_t tryAllocatePage() {
    return 0;
  }
  // The caller owns the entire aligned physical page throughout the copy.
  virtual bool copyPhysicalPageToBuffer(physical_uintptr_t page, void* buffer) {
    return false;
  }
  virtual bool copyPhysicalPageFromBuffer(physical_uintptr_t page, const void* buffer) {
    return false;
  }
  struct MemorySnapshot {
    uint64_t totalPages = 0;
    uint64_t freePages = 0;
    bool available = false;
  };
  virtual MemorySnapshot memorySnapshot() const {
    return {};
  }
  virtual void freePage(physical_uintptr_t page) = 0;
 
  virtual void pin(physical_uintptr_t page) = 0;
 
#if HOSTED && PEDIGREE_HOSTED_SMOKE_TESTS
  static EXPORTED_PUBLIC void setTryAllocationFailureForTest(ssize_t after);
  static EXPORTED_PUBLIC size_t pageReferenceCountForTest(physical_uintptr_t page);
#endif
 
  virtual bool allocateRegion(MemoryRegion& Region, size_t cPages, size_t pageConstraints,
                              size_t Flags, physical_uintptr_t start = -1) = 0;
 
  struct MemoryRegionInfo {
    inline MemoryRegionInfo(void* VirtualAddress, physical_uintptr_t PhysicalAddress, size_t size,
                            const char* name)
        : pVirtualAddress(VirtualAddress),
          physicalAddress(PhysicalAddress),
          sVirtualAddress(size),
          pName(name) {}
 
    void* pVirtualAddress;
    physical_uintptr_t physicalAddress;
    size_t sVirtualAddress;
    const char* pName;
  };
 
  void allocateMemoryRegionList(Vector<MemoryRegionInfo*>& MemoryRegions);
  void freeMemoryRegionList(Vector<MemoryRegionInfo*>& MemoryRegions);
 
  virtual size_t freePageCount() const;
 
 protected:
  PhysicalMemoryManager();
  virtual ~PhysicalMemoryManager();
 
  Vector<MemoryRegion*> m_MemoryRegions;
 
 private:
  PhysicalMemoryManager(const PhysicalMemoryManager&);
  PhysicalMemoryManager& operator=(const PhysicalMemoryManager&);
 
  virtual void freePageUnlocked(physical_uintptr_t page) = 0;
 
  virtual void unmapRegion(MemoryRegion* pRegion) = 0;
};
 
#endif