page_table_entry_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 PAGE_TABLE_ENTRY_X64_H
#define PAGE_TABLE_ENTRY_X64_H

#include <gsl/gsl>

// -----------------------------------------------------------------------------
// Constants
// -----------------------------------------------------------------------------

// *INDENT-OFF*

namespace x64
{
namespace page_table
{
    constexpr const auto num_entries = 512UL;
    constexpr const auto num_bytes = num_entries * sizeof(uintptr_t);

    template<class T, class F> auto index(const T virt, const F from)
    { return (virt & ((0x1FFULL) << from)) >> from; }

    namespace pml4
    {
        constexpr const auto from = 39U;
        constexpr const auto size = 9U;
        constexpr const auto size_bytes = 0x8000000000UL;
    }

    namespace pdpt
    {
        constexpr const auto from = 30U;
        constexpr const auto size = 9U;
        constexpr const auto size_bytes = 0x40000000UL;
    }

    namespace pd
    {
        constexpr const auto from = 21U;
        constexpr const auto size = 9U;
        constexpr const auto size_bytes = 0x200000UL;
    }

    namespace pt
    {
        constexpr const auto from = 12U;
        constexpr const auto size = 9U;
        constexpr const auto size_bytes = 0x1000UL;
    }
}
}

// *INDENT-ON*

// -----------------------------------------------------------------------------
// Definition
// -----------------------------------------------------------------------------

class page_table_entry_x64
{
public:

    using pointer = uintptr_t *;
    using integer_pointer = uintptr_t;
    using pat_index_type = uint64_t;

    page_table_entry_x64(gsl::not_null<pointer> pte) noexcept;

    ~page_table_entry_x64() = default;

    bool present() const noexcept;

    void set_present(bool enabled) noexcept;

    bool rw() const noexcept;

    void set_rw(bool enabled) noexcept;

    bool us() const noexcept;

    void set_us(bool enabled) noexcept;

    bool pwt() const noexcept;

    void set_pwt(bool enabled) noexcept;

    bool pcd() const noexcept;

    void set_pcd(bool enabled) noexcept;

    bool accessed() const noexcept;

    void set_accessed(bool enabled) noexcept;

    bool dirty() const noexcept;

    void set_dirty(bool enabled) noexcept;

    bool ps() const noexcept;

    void set_ps(bool enabled) noexcept;

    bool pat_4k() const noexcept;

    void set_pat_4k(bool enabled) noexcept;

    bool pat_large() const noexcept;

    void set_pat_large(bool enabled) noexcept;

    bool global() const noexcept;

    void set_global(bool enabled) noexcept;

    integer_pointer phys_addr() const noexcept;

    void set_phys_addr(integer_pointer addr) noexcept;

    bool nx() const noexcept;

    void set_nx(bool enabled) noexcept;

    pat_index_type pat_index_4k() const noexcept;

    void set_pat_index_4k(pat_index_type index);

    pat_index_type pat_index_large() const noexcept;

    void set_pat_index_large(pat_index_type index);

    void clear() noexcept;

private:

    pointer m_pte;

public:

    page_table_entry_x64(page_table_entry_x64 &&) noexcept = default;
    page_table_entry_x64 &operator=(page_table_entry_x64 &&) noexcept = default;

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

#endif