kernel/core/processor/hosted/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_HOSTED_PHYSICALMEMORYMANAGER_H
#define KERNEL_PROCESSOR_HOSTED_PHYSICALMEMORYMANAGER_H
#include "pedigree/kernel/BootstrapInfo.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/utilities/HashTable.h"
#include "pedigree/kernel/utilities/RangeList.h"
 
#include <config.h>
 
#include "../x86_common/PhysicalMemoryManager.h"
 
#define HOSTED_PHYSICAL_MEMORY_SIZE (1UL << 31)
 
class HostedPhysicalMemoryManager : public PhysicalMemoryManager {
  friend class CacheManager;
  friend class Cache;
  friend class PhysicalMemoryManager;
  friend class HostedVirtualAddressSpace;
 
 public:
  static HostedPhysicalMemoryManager& instance();
 
  //
  // PhysicalMemoryManager Interface
  //
  virtual physical_uintptr_t allocatePage(size_t pageConstraints = 0) override;
  physical_uintptr_t tryAllocatePage() override;
  bool copyPhysicalPageToBuffer(physical_uintptr_t page, void* buffer) override;
  bool copyPhysicalPageFromBuffer(physical_uintptr_t page, const void* buffer) override;
  MemorySnapshot memorySnapshot() const override;
  virtual void freePage(physical_uintptr_t page) override;
  virtual bool allocateRegion(MemoryRegion& Region, size_t cPages, size_t pageConstraints,
                              size_t Flags, physical_uintptr_t start = -1) override;
 
  virtual void pin(physical_uintptr_t page) override;
 
  void initialise(const BootstrapStruct_t& Info) INITIALISATION_ONLY;
 
  void initialisationDone();
 
  const RangeList<uint64_t>& getAcpiRanges() const {
    return m_AcpiRanges;
  }
 
 protected:
  HostedPhysicalMemoryManager() INITIALISATION_ONLY;
  virtual ~HostedPhysicalMemoryManager() override;
 
 private:
  HostedPhysicalMemoryManager(const HostedPhysicalMemoryManager&);
  HostedPhysicalMemoryManager& operator=(const HostedPhysicalMemoryManager&);
 
  inline int getBackingFile() const {
    return m_BackingFile;
  }
 
#if PEDIGREE_HOSTED_SMOKE_TESTS
  size_t pageReferenceCountForTestImpl(physical_uintptr_t page);
#endif
 
  void unmapRegion(MemoryRegion* pRegion) override;
 
  virtual void freePageUnlocked(physical_uintptr_t page) override;
 
  using PageStack = X86CommonPhysicalMemoryManager::PageStack;
 
  PageStack m_PageStack;
 
  RangeList<uint64_t> m_PhysicalRanges;
 
  RangeList<uintptr_t> m_MemoryRegions;
 
  RangeList<uint64_t> m_AcpiRanges;
 
  Spinlock m_Lock, m_RegionLock;
 
  class PageHashable {
   public:
    PageHashable() {
      m_Hash = m_Page = 0;
    }
 
    PageHashable(physical_uintptr_t p) {
      m_Hash = p / getPageSize();
      m_Page = p;
    }
 
    size_t hash() const {
      return m_Hash;
    }
 
    bool operator==(const PageHashable& p) const {
      return p.m_Page == m_Page;
    }
 
   private:
    size_t m_Hash;
    physical_uintptr_t m_Page;
  };
 
  struct page {
    page() : active(false), refcount(0) {}
 
    bool active;
    size_t refcount;
  };
 
  typedef HashTable<PageHashable, struct page> MetadataTable;
 
  HashTable<PageHashable, struct page> m_PageMetadata;
 
  int m_BackingFile;
 
  static HostedPhysicalMemoryManager* m_Instance;
};
 
#endif