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
|
#pragma once
#include <AK/Bitmap.h>
#include <AK/InlineLinkedList.h>
#include <AK/String.h>
#include <Kernel/Heap/SlabAllocator.h>
#include <Kernel/VM/PageDirectory.h>
#include <Kernel/VM/RangeAllocator.h>
class Inode;
class VMObject;
class Region final : public InlineLinkedListNode<Region> {
friend class MemoryManager;
MAKE_SLAB_ALLOCATED(Region)
public:
enum Access {
Read = 1,
Write = 2,
Execute = 4,
};
static NonnullOwnPtr<Region> create_user_accessible(const Range&, const StringView& name, u8 access);
static NonnullOwnPtr<Region> create_user_accessible(const Range&, NonnullRefPtr<VMObject>, size_t offset_in_vmobject, const StringView& name, u8 access);
static NonnullOwnPtr<Region> create_user_accessible(const Range&, NonnullRefPtr<Inode>, const StringView& name, u8 access);
static NonnullOwnPtr<Region> create_kernel_only(const Range&, const StringView& name, u8 access);
~Region();
const Range& range() const { return m_range; }
VirtualAddress vaddr() const { return m_range.base(); }
size_t size() const { return m_range.size(); }
bool is_readable() const { return m_access & Access::Read; }
bool is_writable() const { return m_access & Access::Write; }
bool is_executable() const { return m_access & Access::Execute; }
const String& name() const { return m_name; }
unsigned access() const { return m_access; }
void set_name(const String& name) { m_name = name; }
const VMObject& vmobject() const { return *m_vmobject; }
VMObject& vmobject() { return *m_vmobject; }
bool is_shared() const { return m_shared; }
void set_shared(bool shared) { m_shared = shared; }
bool is_user_accessible() const { return m_user_accessible; }
NonnullOwnPtr<Region> clone();
bool contains(VirtualAddress vaddr) const
{
return m_range.contains(vaddr);
}
bool contains(const Range& range) const
{
return m_range.contains(range);
}
unsigned page_index_from_address(VirtualAddress vaddr) const
{
return (vaddr - m_range.base()).get() / PAGE_SIZE;
}
size_t first_page_index() const
{
return m_offset_in_vmo / PAGE_SIZE;
}
size_t last_page_index() const
{
return (first_page_index() + page_count()) - 1;
}
size_t page_count() const
{
return size() / PAGE_SIZE;
}
size_t offset_in_vmobject() const
{
return m_offset_in_vmo;
}
int commit();
size_t amount_resident() const;
size_t amount_shared() const;
PageDirectory* page_directory() { return m_page_directory.ptr(); }
void set_page_directory(PageDirectory& page_directory)
{
ASSERT(!m_page_directory || m_page_directory == &page_directory);
m_page_directory = page_directory;
}
void release_page_directory()
{
ASSERT(m_page_directory);
m_page_directory.clear();
}
bool should_cow(size_t page_index) const;
void set_should_cow(size_t page_index, bool);
void set_writable(bool b)
{
if (b)
m_access |= Access::Read;
else
m_access &= ~Access::Write;
}
void remap_page(size_t index);
// For InlineLinkedListNode
Region* m_next { nullptr };
Region* m_prev { nullptr };
// NOTE: These are public so we can make<> them.
Region(const Range&, const String&, u8 access);
Region(const Range&, NonnullRefPtr<VMObject>, size_t offset_in_vmo, const String&, u8 access);
Region(const Range&, RefPtr<Inode>&&, const String&, u8 access);
private:
Bitmap& ensure_cow_map() const;
RefPtr<PageDirectory> m_page_directory;
Range m_range;
size_t m_offset_in_vmo { 0 };
NonnullRefPtr<VMObject> m_vmobject;
String m_name;
u8 m_access { 0 };
bool m_shared { false };
bool m_user_accessible { false };
mutable OwnPtr<Bitmap> m_cow_map;
};
|
