memory_manager_x64.h

Go to the documentation of this file.

//
// Bareflank Hypervisor
//
// Copyright (C) 2015 Assured Information Security, Inc.
// Author: Rian Quinn        <quinnr@ainfosec.com>
// Author: Brendan Kerrigan  <kerriganb@ainfosec.com>
//
// This library is free software; you can redistribute it and/or
// modify it under the terms of the GNU Lesser General Public
// License as published by the Free Software Foundation; either
// version 2.1 of the License, or (at your option) any later version.
//
// This library is distributed in the hope that it will be useful,
// but WITHOUT ANY WARRANTY; without even the implied warranty of
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
// Lesser General Public License for more details.
//
// You should have received a copy of the GNU Lesser General Public
// License along with this library; if not, write to the Free Software
// Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA 02110-1301 USA

#ifndef MEMORY_MANAGER_X64_H
#define MEMORY_MANAGER_X64_H

#include <map>
#include <vector>

#include <memory.h>
#include <constants.h>

#include <intrinsics/x64.h>
#include <memory_manager/mem_pool.h>

class memory_manager_x64
{
public:

    using pointer = void *;
    using integer_pointer = uintptr_t;
    using size_type = std::size_t;
    using attr_type = decltype(memory_descriptor::type);
    using memory_descriptor_list = std::vector<memory_descriptor>;

    virtual ~memory_manager_x64() = default;

    static memory_manager_x64 *instance() noexcept;

    virtual pointer alloc(size_type size) noexcept;

    virtual pointer alloc_map(size_type size) noexcept;

    virtual void free(pointer ptr) noexcept;

    virtual void free_map(pointer ptr) noexcept;

    virtual size_type size(pointer ptr) const noexcept;

    virtual size_type size_map(pointer ptr) const noexcept;

    virtual integer_pointer virtint_to_physint(integer_pointer virt) const;

    virtual integer_pointer virtptr_to_physint(pointer virt) const;

    virtual pointer virtint_to_physptr(integer_pointer virt) const;

    virtual pointer virtptr_to_physptr(pointer virt) const;

    virtual integer_pointer physint_to_virtint(integer_pointer phys) const;

    virtual integer_pointer physptr_to_virtint(pointer phys) const;

    virtual pointer physint_to_virtptr(integer_pointer phys) const;

    virtual pointer physptr_to_virtptr(pointer phys) const;

    virtual attr_type virtint_to_attrint(integer_pointer virt) const;

    virtual attr_type virtptr_to_attrint(pointer virt) const;

    virtual void add_md(integer_pointer virt, integer_pointer phys, attr_type attr);

    virtual void remove_md(integer_pointer virt) noexcept;

    virtual memory_descriptor_list descriptors() const;

private:

    memory_manager_x64() noexcept;

    integer_pointer lower(integer_pointer ptr) const noexcept;
    integer_pointer upper(integer_pointer ptr) const noexcept;

private:

    std::map<integer_pointer, integer_pointer> m_virt_to_phys_map;
    std::map<integer_pointer, integer_pointer> m_phys_to_virt_map;
    std::map<integer_pointer, attr_type> m_virt_to_attr_map;

    mem_pool<MAX_HEAP_POOL, x64::cache_line_shift> g_heap_pool;
    mem_pool<MAX_PAGE_POOL, x64::page_shift> g_page_pool;
    mem_pool<MAX_MEM_MAP_POOL, x64::page_shift> g_mem_map_pool;

public:

    memory_manager_x64(const memory_manager_x64 &) = delete;
    memory_manager_x64 &operator=(const memory_manager_x64 &) = delete;
};

#define g_mm memory_manager_x64::instance()

#endif