idt_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 IDT_X64_H
#define IDT_X64_H

#include <gsl/gsl>

#include <vector>
#include <algorithm>
#include <exception>

#include <guard_exceptions.h>

// -----------------------------------------------------------------------------
// Interrupt Descriptor Table Register
// -----------------------------------------------------------------------------

#pragma pack(push, 1)

struct idt_reg_x64_t
{
    using limit_type = uint16_t;
    using base_type = uint64_t *;

    limit_type limit;
    base_type base;

    idt_reg_x64_t() noexcept :
        limit(0),
        base(nullptr)
    {}

    idt_reg_x64_t(base_type b, limit_type l) noexcept :
        limit(l),
        base(b)
    {}
};

#pragma pack(pop)

// -----------------------------------------------------------------------------
// Intrinsics
// -----------------------------------------------------------------------------

extern "C" void __read_idt(idt_reg_x64_t *idt_reg) noexcept;
extern "C" void __write_idt(idt_reg_x64_t *idt_reg) noexcept;

// -----------------------------------------------------------------------------
// IDT Functions
// -----------------------------------------------------------------------------

// *INDENT-OFF*

namespace x64
{
namespace idt
{
    inline auto get() noexcept
    {
        auto &&reg = idt_reg_x64_t{};
        __read_idt(&reg);

        return reg;
    }

    inline void set(idt_reg_x64_t::base_type base, idt_reg_x64_t::limit_type limit) noexcept
    {
        auto &&reg = idt_reg_x64_t{base, limit};
        __write_idt(&reg);
    }

    namespace base
    {
        inline auto get() noexcept
        {
            auto &&reg = idt_reg_x64_t{};
            __read_idt(&reg);

            return reg.base;
        }

        inline void set(idt_reg_x64_t::base_type base) noexcept
        {
            auto &&reg = idt_reg_x64_t{};
            __read_idt(&reg);

            reg.base = base;
            __write_idt(&reg);
        }
    }

    namespace limit
    {
        inline auto get() noexcept
        {
            auto &&reg = idt_reg_x64_t{};
            __read_idt(&reg);

            return reg.limit;
        }

        inline void set(idt_reg_x64_t::limit_type limit) noexcept
        {
            auto &&reg = idt_reg_x64_t{};
            __read_idt(&reg);

            reg.limit = limit;
            __write_idt(&reg);
        }
    }
}
}
// *INDENT-ON*

// -----------------------------------------------------------------------------
// Interrupt Descriptor Table
// -----------------------------------------------------------------------------

class idt_x64
{
public:

    using size_type = uint16_t;
    using integer_pointer = uintptr_t;
    using interrupt_descriptor_type = uint64_t;

    idt_x64() noexcept
    {
        guard_exceptions([&]
        {
            m_idt_reg.base = x64::idt::base::get();
            m_idt_reg.limit = x64::idt::limit::get();
        });
    }

    idt_x64(size_type size) noexcept :
        m_idt(size)
    {
        guard_exceptions([&]
        {
            m_idt_reg.base = m_idt.data();
            m_idt_reg.limit = gsl::narrow_cast<size_type>((size << 3) - 1);
        });
    }

    ~idt_x64() = default;

    auto base() const
    { return reinterpret_cast<integer_pointer>(m_idt_reg.base); }

    auto limit() const
    { return m_idt_reg.limit; }

private:

    friend class intrinsics_ut;

    idt_reg_x64_t m_idt_reg;
    std::vector<interrupt_descriptor_type> m_idt;
};

#endif