kernel/core/processor/x86_common/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_X86_COMMON_PHYSICALMEMORYMANAGER_H
#define KERNEL_PROCESSOR_X86_COMMON_PHYSICALMEMORYMANAGER_H
#include "pedigree/kernel/Atomic.h"
#include "pedigree/kernel/Spinlock.h"
#include "pedigree/kernel/compiler.h"
#include "pedigree/kernel/processor/PhysicalMemoryManager.h"
#include "pedigree/kernel/processor/types.h"
#include "pedigree/kernel/utilities/HashTable.h"
#include "pedigree/kernel/utilities/RangeList.h"
#include "pedigree/kernel/utilities/utility.h"
 
#include <config.h>
 
class BootstrapStruct_t;
class MemoryRegion;
 
extern size_t g_AllocedPages;
extern size_t g_FreePages;
 
class X86CommonPhysicalMemoryManager : public PhysicalMemoryManager {
  friend class CacheManager;
  friend class Cache;
 
#if HOSTED
  friend class HostedPhysicalMemoryManager;
#endif
 
 public:
  inline static X86CommonPhysicalMemoryManager& instance() {
    return m_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 initialise64(const BootstrapStruct_t& Info) INITIALISATION_ONLY;
 
  void initialisationDone();
 
  void shutdown();
 
  const RangeList<uint64_t>& getAcpiRanges() const {
    return m_AcpiRanges;
  }
 
  virtual size_t freePageCount() const override;
 
 protected:
  X86CommonPhysicalMemoryManager() INITIALISATION_ONLY;
  virtual ~X86CommonPhysicalMemoryManager() override;
 
 private:
  X86CommonPhysicalMemoryManager(const X86CommonPhysicalMemoryManager&);
  X86CommonPhysicalMemoryManager& operator=(const X86CommonPhysicalMemoryManager&);
 
  void unmapRegion(MemoryRegion* pRegion) override;
 
  virtual void freePageUnlocked(physical_uintptr_t page) override;
 
  class PageStack {
    friend class X86CommonPhysicalMemoryManager;
#if HOSTED
    friend class HostedPhysicalMemoryManager;
#endif
 
   public:
    PageStack() INITIALISATION_ONLY;
    physical_uintptr_t allocate(size_t constraints, bool waitForReady = true);
    void free(uint64_t physicalAddress, size_t length, bool newMemory = false);
    inline ~PageStack() {}
 
    inline size_t freePages() const {
      return m_FreePages;
    }
 
    size_t totalPages() const {
      return m_TotalPages;
    }
 
   protected:
    void markAbove4GReady();
 
    void markBelow4GReady();
 
   private:
    PageStack(const PageStack&);
    PageStack& operator=(const PageStack&);
 
    void initialise();
 
    bool maybeMap(size_t index, uint64_t physicalAddress);
 
    static const size_t StackCount = 3;
 
    void* m_Stack[StackCount];
    size_t m_StackMax[StackCount];
    size_t m_StackSize[StackCount];
    size_t m_FreePages;
    size_t m_TotalPages;
    size_t m_DesiredCapacity[StackCount];
 
    Atomic<bool> m_StackReady[StackCount];
  };
 
  PageStack m_PageStack;
 
  RangeList<uint32_t> m_RangeBelow1MB;
  RangeList<uint32_t> m_RangeBelow16MB;
 
  RangeList<uint64_t> m_PhysicalRanges;
 
  RangeList<uint64_t> m_AcpiRanges;
 
  RangeList<uintptr_t> m_MemoryRegions;
 
  static X86CommonPhysicalMemoryManager m_Instance;
 
  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;
 
  bool m_PageMetadataReady;
  physical_uintptr_t m_BootstrapPinnedPage;
  size_t m_BootstrapPinnedPageRefcount;
};
 
#endif