root_page_table_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 ROOT_PAGE_TABLE_X64_H
#define ROOT_PAGE_TABLE_X64_H

#include <gsl/gsl>

#include <mutex>
#include <vector>

#include <memory.h>
#include <memory_manager/pat_x64.h>
#include <memory_manager/mem_attr_x64.h>
#include <memory_manager/page_table_x64.h>

#include <intrinsics/x64.h>

class root_page_table_x64
{
public:

    using pointer = void *;
    using integer_pointer = uintptr_t;
    using cr3_type = uint64_t;
    using attr_type = x64::memory_attr::attr_type;
    using size_type = size_t;
    using memory_descriptor_list = page_table_x64::memory_descriptor_list;

    root_page_table_x64(bool is_vmm = false);

    virtual ~root_page_table_x64() = default;

    virtual cr3_type cr3();

    virtual void map_1g(integer_pointer virt, integer_pointer phys, attr_type attr)
    { this->map_page(virt, phys, attr, x64::page_table::pdpt::size_bytes); }

    virtual void map_2m(integer_pointer virt, integer_pointer phys, attr_type attr)
    { this->map_page(virt, phys, attr, x64::page_table::pd::size_bytes); }

    virtual void map_4k(integer_pointer virt, integer_pointer phys, attr_type attr)
    { this->map_page(virt, phys, attr, x64::page_table::pt::size_bytes); }

    virtual void unmap(integer_pointer virt) noexcept;

    void setup_identity_map_1g(integer_pointer saddr, integer_pointer eaddr);

    void setup_identity_map_2m(integer_pointer saddr, integer_pointer eaddr);

    void setup_identity_map_4k(integer_pointer saddr, integer_pointer eaddr);

    void unmap_identity_map_1g(integer_pointer saddr, integer_pointer eaddr);

    void unmap_identity_map_2m(integer_pointer saddr, integer_pointer eaddr);

    void unmap_identity_map_4k(integer_pointer saddr, integer_pointer eaddr);

    page_table_entry_x64 virt_to_pte(integer_pointer virt) const;

    memory_descriptor_list pt_to_mdl() const;

private:

    page_table_entry_x64 add_page(integer_pointer virt, size_type size);

    void map_page(integer_pointer virt, integer_pointer phys, attr_type attr, size_type size);
    void unmap_page(integer_pointer virt) noexcept;

private:

    bool m_is_vmm;

    integer_pointer m_cr3;
    std::unique_ptr<page_table_x64> m_pt;

    mutable std::mutex m_mutex;

public:

    friend class memory_manager_ut;

    root_page_table_x64(root_page_table_x64 &&) = default;
    root_page_table_x64 &operator=(root_page_table_x64 &&) = default;

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

root_page_table_x64 *root_pt() noexcept;

#define g_pt root_pt()

#endif