map_ptr_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 MAP_PTR_H
#define MAP_PTR_H

#include <gsl/gsl>

#include <vector>
#include <utility>
#include <cstdint>
#include <type_traits>

#include <memory.h>
#include <upper_lower.h>
#include <guard_exceptions.h>

#include <memory_manager/pat_x64.h>
#include <memory_manager/mem_attr_x64.h>
#include <memory_manager/memory_manager_x64.h>
#include <memory_manager/root_page_table_x64.h>

#include <intrinsics/x64.h>
#include <intrinsics/tlb_x64.h>
#include <intrinsics/msrs_x64.h>
#include <intrinsics/cache_x64.h>

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

namespace bfn
{

template <class T>
class unique_map_ptr_x64;

template<class T>
auto make_unique_map_x64(typename unique_map_ptr_x64<T>::pointer phys,
                         x64::memory_attr::attr_type attr = x64::memory_attr::rw_wb)
{
    auto &&vmap = g_mm->alloc_map(x64::page_size);

    try
    {
        return unique_map_ptr_x64<T>(reinterpret_cast<typename unique_map_ptr_x64<T>::integer_pointer>(vmap),
                                     reinterpret_cast<typename unique_map_ptr_x64<T>::integer_pointer>(phys),
                                     attr);
    }
    catch (...)
    {
        g_mm->free_map(vmap);
        throw;
    }
}

template<class T>
auto make_unique_map_x64(typename unique_map_ptr_x64<T>::integer_pointer phys,
                         x64::memory_attr::attr_type attr = x64::memory_attr::rw_wb)
{
    auto &&vmap = g_mm->alloc_map(x64::page_size);

    try
    {
        return unique_map_ptr_x64<T>(reinterpret_cast<typename unique_map_ptr_x64<T>::integer_pointer>(vmap),
                                     phys, attr);
    }
    catch (...)
    {
        g_mm->free_map(vmap);
        throw;
    }
}

template<class T>
auto make_unique_map_x64(const std::vector<std::pair<typename unique_map_ptr_x64<T>::integer_pointer, typename unique_map_ptr_x64<T>::size_type>> &list,
                         x64::memory_attr::attr_type attr = x64::memory_attr::rw_wb)
{
    typename unique_map_ptr_x64<T>::size_type size = 0;

    for (const auto &p : list)
        size += p.second;

    auto &&vmap = g_mm->alloc_map(size);

    try
    {
        return unique_map_ptr_x64<T>(reinterpret_cast<typename unique_map_ptr_x64<T>::integer_pointer>(vmap),
                                     list, attr);
    }
    catch (...)
    {
        g_mm->free_map(vmap);
        throw;
    }
}

template<class T>
auto make_unique_map_x64(typename unique_map_ptr_x64<T>::integer_pointer virt,
                         typename unique_map_ptr_x64<T>::integer_pointer cr3,
                         typename unique_map_ptr_x64<T>::size_type size,
                         x64::msrs::value_type pat)
{
    auto &&vmap = g_mm->alloc_map(size + lower(virt));

#ifdef MAP_PTR_TESTING

    (void) cr3;
    (void) pat;

    expects(virt != 0xDEADBEEF);
    return unique_map_ptr_x64<T> {reinterpret_cast<typename unique_map_ptr_x64<T>::integer_pointer>(vmap), size};

#else

    try
    {
        return unique_map_ptr_x64<T>(reinterpret_cast<typename unique_map_ptr_x64<T>::integer_pointer>(vmap),
                                     virt, cr3, size, pat);
    }
    catch (...)
    {
        g_mm->free_map(vmap);
        throw;
    }

#endif
}

uintptr_t virt_to_phys_with_cr3(uintptr_t virt, uintptr_t cr3);

void map_with_cr3(uintptr_t vmap, uintptr_t virt, uintptr_t cr3, size_t size, x64::msrs::value_type pat);

template <class T>
class unique_map_ptr_x64
{
public:

    using pointer = T*;
    using integer_pointer = uintptr_t;
    using size_type = size_t;
    using element_type = T;

    unique_map_ptr_x64() :
        m_virt(0),
        m_size(0),
        m_unaligned_size(0)
    { }

    unique_map_ptr_x64(std::nullptr_t donotcare) :
        m_virt(0),
        m_size(0),
        m_unaligned_size(0)
    { (void) donotcare; }

    unique_map_ptr_x64(integer_pointer virt, size_type size) :
        m_virt(virt),
        m_size(size),
        m_unaligned_size(size)
    { }

    unique_map_ptr_x64(integer_pointer vmap, integer_pointer phys, x64::memory_attr::attr_type attr) :
        m_virt(vmap),
        m_size(x64::page_size),
        m_unaligned_size(x64::page_size)
    {
        // [[ensures: get() != nullptr]]
        expects(vmap != 0);
        expects(lower(vmap) == 0);
        expects(phys != 0);
        expects(lower(phys) == 0);

        g_pt->map_4k(vmap, upper(phys), attr);

        flush();
    }

    unique_map_ptr_x64(integer_pointer vmap, const std::vector<std::pair<integer_pointer, size_type>> &list, x64::memory_attr::attr_type attr) :
        m_virt(0),
        m_size(0),
        m_unaligned_size(0)
    {
        // [[ensures: get() != nullptr]]
        expects(vmap != 0);
        expects(lower(vmap) == 0);
        expects(!list.empty());

        for (const auto &p : list)
        {
            expects(p.first != 0);
            expects(p.second != 0);
            expects(lower(p.second) == 0);

            m_size += p.second;
            m_unaligned_size += p.second;
        }

        m_virt |= lower(list.front().first);
        m_virt |= upper(vmap);

        auto &&voff = 0UL;
        auto &&poff = 0UL;

        for (const auto &p : list)
        {
            auto &&phys = upper(p.first);
            auto &&size = p.second;

            for (poff = 0; poff < size; poff += x64::page_size, voff += x64::page_size)
                g_pt->map_4k(vmap + voff, phys + poff, attr);
        }

        flush();
    }

    unique_map_ptr_x64(integer_pointer vmap, integer_pointer virt, integer_pointer cr3, size_type size, x64::msrs::value_type pat) :
        m_virt(0),
        m_size(size),
        m_unaligned_size(size)
    {
        // [[ensures: get() != nullptr]]

        m_virt |= lower(virt);
        m_virt |= upper(vmap);

        m_unaligned_size += lower(virt);

        map_with_cr3(vmap, virt, cr3, m_unaligned_size, pat);

        flush();
    }

    unique_map_ptr_x64(unique_map_ptr_x64 &&other) noexcept :
        m_virt(0),
        m_size(0),
        m_unaligned_size(0)
    { reset(other.release()); }

    virtual ~unique_map_ptr_x64() noexcept
    {
        guard_exceptions([&]
        { cleanup(m_virt, m_unaligned_size); });

        m_virt = 0;
        m_size = 0;
        m_unaligned_size = 0;
    }

    unique_map_ptr_x64 &operator=(unique_map_ptr_x64 &&other) noexcept
    {
        reset(other.release());
        return *this;
    }

    unique_map_ptr_x64 &operator=(std::nullptr_t dontcare) noexcept
    {
        (void) dontcare;

        reset();
        return *this;
    }

    typename std::add_lvalue_reference<T>::type operator*() const
    { return *reinterpret_cast<pointer>(m_virt); }

    auto operator->() const noexcept
    { return reinterpret_cast<pointer>(m_virt); }

    virtual pointer get() const noexcept
    { return reinterpret_cast<pointer>(m_virt); }

    operator bool() const noexcept
    { return m_virt != 0 && m_size != 0 && m_unaligned_size != 0; }

    virtual size_type size() const noexcept
    { return m_size; }

    auto release() noexcept
    {
        auto old_virt = m_virt;
        auto old_size = m_size;
        auto old_unaligned_size = m_unaligned_size;

        m_virt = 0;
        m_size = 0;
        m_unaligned_size = 0;

        return std::make_tuple(reinterpret_cast<pointer>(old_virt), old_size, old_unaligned_size);
    }

    void reset(pointer ptr = pointer(), size_type size = size_type(), size_type unaligned_size = size_type()) noexcept
    {
        auto old_virt = m_virt;
        auto old_unaligned_size = m_unaligned_size;

        m_virt = reinterpret_cast<integer_pointer>(ptr);
        m_size = size;
        m_unaligned_size = unaligned_size;

        cleanup(old_virt, old_unaligned_size);
    }

    void reset(const std::tuple<pointer, size_type, size_type> &p) noexcept
    { reset(std::get<0>(p), std::get<1>(p), std::get<2>(p)); }

    void swap(unique_map_ptr_x64 &other) noexcept
    {
        std::swap(m_virt, other.m_virt);
        std::swap(m_size, other.m_size);
        std::swap(m_unaligned_size, other.m_unaligned_size);
    }

    void flush() noexcept
    {
        auto &&vmap = upper(m_virt);
        for (auto vadr = vmap; vadr < vmap + m_unaligned_size; vadr += x64::page_size)
            x64::tlb::invlpg(reinterpret_cast<pointer>(vadr));
    }

    void cache_flush() noexcept
    {
        auto &&vmap = upper(m_virt);
        for (auto vadr = vmap; vadr < vmap + m_unaligned_size; vadr += x64::cache_line_size)
            x64::cache::clflush(reinterpret_cast<pointer>(vadr));
    }

private:

    void cleanup(integer_pointer virt, size_type size) noexcept
    {
        if (virt != 0 && size != 0)
        {
            auto &&vmap = upper(virt);
            for (auto vadr = vmap; vadr < vmap + size; vadr += x64::page_size)
                g_pt->unmap(vadr);

            g_mm->free_map(reinterpret_cast<pointer>(vmap));
        }
    }

private:

    integer_pointer m_virt;
    size_type m_size;
    size_type m_unaligned_size;

public:

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

template <class T>
void swap(unique_map_ptr_x64<T> &x, unique_map_ptr_x64<T> &y) noexcept
{ x.swap(y); }

template <class T1, class T2>
bool operator==(const unique_map_ptr_x64<T1> &x, const unique_map_ptr_x64<T2> &y)
{ return x.get() == y.get(); }

template <class T1, class T2>
bool operator!=(const unique_map_ptr_x64<T1> &x, const unique_map_ptr_x64<T2> &y)
{ return x.get() != y.get(); }

template <class T1, class T2>
bool operator<(const unique_map_ptr_x64<T1> &x, const unique_map_ptr_x64<T2> &y)
{ return x.get() < y.get(); }

template <class T1, class T2>
bool operator<=(const unique_map_ptr_x64<T1> &x, const unique_map_ptr_x64<T2> &y)
{ return x.get() <= y.get(); }

template <class T1, class T2>
bool operator>(const unique_map_ptr_x64<T1> &x, const unique_map_ptr_x64<T2> &y)
{ return x.get() > y.get(); }

template <class T1, class T2>
bool operator>=(const unique_map_ptr_x64<T1> &x, const unique_map_ptr_x64<T2> &y)
{ return x.get() >= y.get(); }

template <class T>
bool operator==(const unique_map_ptr_x64<T> &x, std::nullptr_t dontcare) noexcept
{ (void) dontcare; return !x; }

template <class T>
bool operator==(std::nullptr_t dontcare, const unique_map_ptr_x64<T> &y) noexcept
{ (void) dontcare; return !y; }

template <class T>
bool operator!=(const unique_map_ptr_x64<T> &x, std::nullptr_t dontcare) noexcept
{ (void) dontcare; return x; }

template <class T>
bool operator!=(std::nullptr_t dontcare, const unique_map_ptr_x64<T> &y) noexcept
{ (void) dontcare; return y; }

inline uintptr_t virt_to_phys_with_cr3(uintptr_t virt, uintptr_t cr3)
{
    uintptr_t from;

    expects(cr3 != 0);
    expects(lower(cr3) == 0);
    expects(virt != 0);

    from = x64::page_table::pml4::from;
    auto &&pml4_idx = x64::page_table::index(virt, from);
    auto &&pml4_map = bfn::make_unique_map_x64<uintptr_t>(cr3);
    auto &&pml4_pte = page_table_entry_x64{&pml4_map.get()[pml4_idx]};

    expects(pml4_pte.present());
    expects(pml4_pte.phys_addr() != 0);

    from = x64::page_table::pdpt::from;
    auto &&pdpt_idx = x64::page_table::index(virt, from);
    auto &&pdpt_map = bfn::make_unique_map_x64<uintptr_t>(pml4_pte.phys_addr());
    auto &&pdpt_pte = page_table_entry_x64{&pdpt_map.get()[pdpt_idx]};

    expects(pdpt_pte.present());
    expects(pdpt_pte.phys_addr() != 0);

    if (pdpt_pte.ps())
        return upper(pdpt_pte.phys_addr(), from) | lower(virt, from);

    from = x64::page_table::pd::from;
    auto &&pd_idx = x64::page_table::index(virt, from);
    auto &&pd_map = bfn::make_unique_map_x64<uintptr_t>(pdpt_pte.phys_addr());
    auto &&pd_pte = page_table_entry_x64{&pd_map.get()[pd_idx]};

    expects(pd_pte.present());
    expects(pd_pte.phys_addr() != 0);

    if (pd_pte.ps())
        return upper(pd_pte.phys_addr(), from) | lower(virt, from);

    from = x64::page_table::pt::from;
    auto &&pt_idx = x64::page_table::index(virt, from);
    auto &&pt_map = bfn::make_unique_map_x64<uintptr_t>(pd_pte.phys_addr());
    auto &&pt_pte = page_table_entry_x64{&pt_map.get()[pt_idx]};

    expects(pt_pte.present());
    expects(pt_pte.phys_addr() != 0);

    return upper(pt_pte.phys_addr(), from) | lower(virt, from);
}

}

#endif