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"

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;

  public:
    inline static X86CommonPhysicalMemoryManager &instance()
    {
        return m_Instance;
    }

    //
    // PhysicalMemoryManager Interface
    //
    virtual physical_uintptr_t allocatePage(size_t pageConstraints = 0);
    virtual void freePage(physical_uintptr_t page);
    virtual bool allocateRegion(
        MemoryRegion &Region, size_t cPages, size_t pageConstraints,
        size_t Flags, physical_uintptr_t start = -1);

    virtual void pin(physical_uintptr_t page);

    void initialise(const BootstrapStruct_t &Info) INITIALISATION_ONLY;

#ifdef X64
    void initialise64(const BootstrapStruct_t &Info) INITIALISATION_ONLY;
#endif

    void initialisationDone();

    void shutdown();

#if defined(ACPI)
    inline const RangeList<uint64_t> &getAcpiRanges() const
    {
        return m_AcpiRanges;
    }
#endif

    virtual size_t freePageCount() const;

  protected:
    X86CommonPhysicalMemoryManager() INITIALISATION_ONLY;
    virtual ~X86CommonPhysicalMemoryManager();

  private:
    X86CommonPhysicalMemoryManager(const X86CommonPhysicalMemoryManager &);
    X86CommonPhysicalMemoryManager &
    operator=(const X86CommonPhysicalMemoryManager &);

    void unmapRegion(MemoryRegion *pRegion);

    virtual void freePageUnlocked(physical_uintptr_t page);

    class PageStack
    {
        friend class X86CommonPhysicalMemoryManager;

      public:
        PageStack() INITIALISATION_ONLY;
        physical_uintptr_t allocate(size_t constraints);
        void free(uint64_t physicalAddress, size_t length);
        inline ~PageStack()
        {
        }

        inline size_t freePages() const
        {
            return m_FreePages;
        }

        void setCapacity(size_t newCapacity)
        {
            m_DesiredCapacity = newCapacity;
        }

        void increaseCapacity(size_t by)
        {
            m_DesiredCapacity += by;
        }

      protected:
        void markAbove4GReady();

        void markBelow4GReady();

      private:
        PageStack(const PageStack &);
        PageStack &operator=(const PageStack &);

        bool maybeMap(size_t index, uint64_t physicalAddress);

#if defined(X86)
        static const size_t StackCount = 1;
#elif defined(X64)
        static const size_t StackCount = 3;
#endif

        void *m_Stack[StackCount];
        size_t m_StackMax[StackCount];
        size_t m_StackSize[StackCount];
        size_t m_FreePages;
        size_t m_Capacity;
        size_t m_DesiredCapacity;

        Atomic<bool> m_StackReady[StackCount];
    };

    PageStack m_PageStack;

    RangeList<uint32_t> m_RangeBelow1MB;
    RangeList<uint32_t> m_RangeBelow16MB;

    RangeList<uint64_t> m_PhysicalRanges;

#if defined(ACPI)

    RangeList<uint64_t> m_AcpiRanges;
#endif

    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;
};

#endif