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
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
|
#pragma once
#include "types.h"
#include "i386.h"
#include <AK/Retainable.h>
#include <AK/RetainPtr.h>
#include <AK/Vector.h>
#include <AK/HashMap.h>
class Task;
enum class PageFaultResponse {
ShouldCrash,
Continue,
};
struct Zone : public Retainable<Zone> {
public:
~Zone() { }
size_t size() const { return m_pages.size() * PAGE_SIZE; }
const Vector<PhysicalAddress>& pages() const { return m_pages; }
private:
friend class MemoryManager;
friend bool copyToZone(Zone&, const void* data, size_t);
explicit Zone(Vector<PhysicalAddress>&& pages)
: m_pages(move(pages))
{
}
Vector<PhysicalAddress> m_pages;
};
bool copyToZone(Zone&, const void* data, size_t);
class MemoryManager {
public:
static MemoryManager& the();
PhysicalAddress pageDirectoryBase() const { return PhysicalAddress(reinterpret_cast<dword>(m_pageDirectory)); }
static void initialize();
PageFaultResponse handlePageFault(const PageFault&);
RetainPtr<Zone> createZone(size_t);
// HACK: don't use this jeez :(
byte* quickMapOnePage(PhysicalAddress);
bool mapRegionsForTask(Task&);
bool unmapRegionsForTask(Task&);
private:
MemoryManager();
~MemoryManager();
void initializePaging();
void protectMap(LinearAddress, size_t length);
void identityMap(LinearAddress, size_t length);
Vector<PhysicalAddress> allocatePhysicalPages(size_t count);
struct PageDirectoryEntry {
explicit PageDirectoryEntry(dword* pde) : m_pde(pde) { }
dword* pageTableBase() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); }
void setPageTableBase(dword value)
{
*m_pde &= 0xfff;
*m_pde |= value & 0xfffff000;
}
dword raw() const { return *m_pde; }
dword* ptr() { return m_pde; }
enum Flags {
Present = 1 << 0,
ReadWrite = 1 << 1,
UserSupervisor = 1 << 2,
};
bool isPresent() const { return raw() & Present; }
void setPresent(bool b) { setBit(Present, b); }
bool isUserAllowed() const { return raw() & UserSupervisor; }
void setUserAllowed(bool b) { setBit(UserSupervisor, b); }
bool isWritable() const { return raw() & ReadWrite; }
void setWritable(bool b) { setBit(ReadWrite, b); }
void setBit(byte bit, bool value)
{
if (value)
*m_pde |= bit;
else
*m_pde &= ~bit;
}
dword* m_pde;
};
struct PageTableEntry {
explicit PageTableEntry(dword* pte) : m_pte(pte) { }
dword* physicalPageBase() { return reinterpret_cast<dword*>(raw() & 0xfffff000u); }
void setPhysicalPageBase(dword value)
{
*m_pte &= 0xfffu;
*m_pte |= value & 0xfffff000u;
}
dword raw() const { return *m_pte; }
dword* ptr() { return m_pte; }
enum Flags {
Present = 1 << 0,
ReadWrite = 1 << 1,
UserSupervisor = 1 << 2,
};
bool isPresent() const { return raw() & Present; }
void setPresent(bool b) { setBit(Present, b); }
bool isUserAllowed() const { return raw() & UserSupervisor; }
void setUserAllowed(bool b) { setBit(UserSupervisor, b); }
bool isWritable() const { return raw() & ReadWrite; }
void setWritable(bool b) { setBit(ReadWrite, b); }
void setBit(byte bit, bool value)
{
if (value)
*m_pte |= bit;
else
*m_pte &= ~bit;
}
dword* m_pte;
};
PageTableEntry ensurePTE(LinearAddress);
dword* m_pageDirectory;
dword* m_pageTableZero;
dword* m_pageTableOne;
HashMap<int, RetainPtr<Zone>> m_zones;
Vector<PhysicalAddress> m_freePages;
};
|
