1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
|
#include "x86_64/memory/kernel_mapper.hpp"
#include "kapi/cio.hpp"
#include "kapi/memory.hpp"
#include "kapi/system.hpp"
#include "x86_64/boot/ld.hpp"
#include "x86_64/memory/page_table.hpp"
#include "x86_64/memory/paging_root.hpp"
#include <elf/format.hpp>
#include <elf/section_header.hpp>
#include <algorithm>
#include <ranges>
namespace teachos::memory::x86_64
{
inline namespace
{
using namespace std::string_view_literals;
constexpr auto static ignored_section_prefixes = std::array{
".boot_"sv,
};
constexpr auto static user_accessible_prefixes = std::array{
".user"sv,
".stl"sv,
};
} // namespace
kernel_mapper::kernel_mapper(frame_allocator & allocator, multiboot2::information_view const * mbi)
: m_allocator{&allocator}
, m_mbi(std::move(mbi))
, m_kernel_load_base{std::bit_cast<std::uintptr_t>(&boot::x86_64::TEACHOS_VMA)}
{}
auto kernel_mapper::remap_kernel() -> void
{
auto elf_information = m_mbi->maybe_elf_symbols<elf::format::elf64>();
if (!elf_information)
{
system::panic("[x86_64:MEM] ELF section information is not available.");
}
auto sections = *elf_information;
auto allocated_sections =
std::views::all(sections) | std::views::filter(&elf::section_header<elf::format::elf64>::allocated) |
std::views::filter([&](auto const & section) -> auto {
auto name = sections.name(section);
return !std::ranges::any_of(ignored_section_prefixes,
[&](auto const & prefix) -> auto { return name.starts_with(prefix); });
});
if (allocated_sections.empty())
{
system::panic("[x86_64:MEM] No allocated ELF sections were found.");
}
std::ranges::for_each(allocated_sections,
[&](auto const & section) -> auto { map_section(section, sections.name(section)); });
}
auto kernel_mapper::map_section(section_header_type const & section, std::string_view name) -> void
{
cio::print("[x86_64:MEM] mapping ");
cio::println(name);
auto number_of_pages = (section.size + (PLATFORM_PAGE_SIZE - 1)) / PLATFORM_PAGE_SIZE;
auto linear_start_address = linear_address{section.virtual_load_address};
auto physical_start_address = physical_address{section.virtual_load_address & ~m_kernel_load_base};
auto first_page = page::containing(linear_start_address);
auto first_frame = frame::containing(physical_start_address);
auto page_flags = page_table::entry::flags::empty;
if (section.writable())
{
page_flags |= page_table::entry::flags::writable;
}
if (!section.executable())
{
page_flags |= page_table::entry::flags::no_execute;
}
auto is_prefix_of_name = [=](auto prefix) -> bool {
return name.starts_with(prefix);
};
if (std::ranges::any_of(user_accessible_prefixes, is_prefix_of_name))
{
page_flags |= page_table::entry::flags::user_accessible;
}
for (auto i = 0uz; i < number_of_pages; ++i)
{
paging_root::get().map(page{first_page.number() + i}, frame{first_frame.number() + i}, page_flags, *m_allocator);
}
}
} // namespace teachos::memory::x86_64
|
