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"

#define HOSTED_PHYSICAL_MEMORY_SIZE (1UL << 31)

class HostedPhysicalMemoryManager : public PhysicalMemoryManager
{
    friend class CacheManager;
    friend class Cache;
    friend class HostedVirtualAddressSpace;

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

    //
    // PhysicalMemoryManager Interface
    //
    virtual physical_uintptr_t allocatePage();
    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;

    void initialisationDone();

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

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

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

    inline int getBackingFile() const
    {
        return m_BackingFile;
    }

    void unmapRegion(MemoryRegion *pRegion);

    virtual void freePageUnlocked(physical_uintptr_t page);

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

        inline size_t freePages() const
        {
            return m_FreePages;
        }

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

        static const size_t StackCount = 1;

        void *m_Stack[StackCount];
        size_t m_StackMax[StackCount];
        size_t m_StackSize[StackCount];
        size_t m_FreePages;
    };

    PageStack m_PageStack;

    RangeList<uint64_t> m_PhysicalRanges;

    RangeList<uintptr_t> m_MemoryRegions;

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

    struct page *m_PageMetadata;

    int m_BackingFile;

    static HostedPhysicalMemoryManager m_Instance;
};

#endif