blob: a07b2c01601381fe4f7deeb6bb41f54d6867f97e (
plain)
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
|
#include "arch/memory/paging.hpp"
#include "arch/exception_handling/assert.hpp"
namespace teachos::arch::memory
{
auto entry::is_unused() const -> bool { return flags == 0U; }
auto entry::set_unused() -> void { flags = 0U; }
auto entry::calculate_pointed_to_frame() const -> std::optional<physical_frame>
{
if (contains_flags(PRESENT))
{
auto physical_address = calculate_physical_address();
return physical_frame::containing_address(physical_address);
}
return std::nullopt;
}
auto entry::calculate_physical_address() const -> std::size_t
{
constexpr std::size_t start_bit = 12U;
constexpr std::size_t end_bit = 52U;
size_t value = 0U;
for (auto i = start_bit; i < end_bit; i++)
{
value |= (flags[i] ? (1 << (i - start_bit)) : 0);
}
return value;
}
auto entry::contains_flags(std::bitset<64U> other) const -> bool { return (flags & other) == other; }
auto entry::set_address(physical_frame frame) -> void
{
arch::exception_handling::assert((frame.start_address() & ~0x000fffff'fffff000) == 0,
"Start address is not aligned with Page");
flags = std::bitset<64U>(frame.start_address()) | flags;
}
auto page_table::zero_entries() -> void
{
for (size_t i = 0; i < sizeof(entries) / sizeof(entries[0]); ++i)
{
entries[i].set_unused();
}
}
auto page_table::next_table_address(std::size_t index) const -> std::optional<std::size_t>
{
auto entry = entries[index];
if (entry.contains_flags(entry.PRESENT) && !entry.contains_flags(entry.HUGE_PAGE))
{
std::size_t table_address = reinterpret_cast<std::size_t>(this);
return (table_address << 9) | (index << 12);
}
// TODO: Implement behaviour for huge pages currently not done
return std::nullopt;
}
auto page_table::next_table(std::size_t index) const -> std::optional<page_table const *>
{
auto address = next_table_address(index);
if (address.has_value())
{
return reinterpret_cast<page_table const *>(*address);
}
return std::nullopt;
}
entry & page_table::operator[](std::size_t index)
{
arch::exception_handling::assert(index < PAGE_TABLE_ENTRY_COUNT, "[Page Table] index out of bounds");
return entries[index];
}
} // namespace teachos::arch::memory
|
