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

// x86/x64 specific flags
#if defined(X86_COMMON)

    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;
#endif

    static const size_t anonymous = 1 << 8;

    static PhysicalMemoryManager &instance();

    inline static size_t getPageSize() PURE
    {
        return PAGE_SIZE;
    }
    virtual physical_uintptr_t allocatePage(size_t pageConstraints = 0) = 0;
    virtual void freePage(physical_uintptr_t page) = 0;

    virtual void pin(physical_uintptr_t page) = 0;

    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