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
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
|
/* SPDX-License-Identifier: GPL-2.0-or-later */
/* Copyright (C) 2026 Richard Qin */
#include <lume/selftest.h>
#include <lume/vmm.h>
#include <lume/addr.h>
#include <lume/errno.h>
#include <arch/pmap.h>
void selftest_vma() {
st_begin("vma: create and destroy VmSpace");
{
VmSpace* space = VmSpace::create();
ST_ASSERT(space != nullptr);
ST_ASSERT(space->root_pa != 0);
// Add a few regions to ensure destruction works
vmm_map_user(space, 0x1000, 0x1000, VM_READ);
vmm_map_user(space, 0x3000, 0x1000, VM_READ | VM_WRITE);
space->destroy();
}
st_pass();
st_begin("vma: map user region and handle demand paging");
{
VmSpace* space = VmSpace::create();
// Map 8KB (2 pages) at 0x400000 using MI-layer flags
int ret = vmm_map_user(space, 0x400000, 0x2000, VM_READ | VM_WRITE);
ST_ASSERT_EQ(ret, 0);
// Fault in the first page
ret = vmm_handle_page_fault(space, 0x400500, VmFaultCause::Read);
ST_ASSERT_EQ(ret, 0);
// Verify mapping in hardware page table
uint64 pa = 0;
bool mapped = pmap::lookup(space->root_pa, 0x400000, &pa);
ST_ASSERT(mapped);
ST_ASSERT_NE(pa, 0ULL);
// Fault in the second page
ret = vmm_handle_page_fault(space, 0x401FFF, VmFaultCause::Read);
ST_ASSERT_EQ(ret, 0);
// Should reject fault outside VMA with -EFAULT
ret = vmm_handle_page_fault(space, 0x402000, VmFaultCause::Read);
ST_ASSERT_EQ(ret, -EFAULT);
space->destroy();
}
st_pass();
st_begin("vma: unmap user region prevents page fault");
{
VmSpace* space = VmSpace::create();
vmm_map_user(space, 0x10000, 0x2000, VM_READ);
// Inside the region — should succeed
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x10500, VmFaultCause::Read), 0);
// Unmap exactly
vmm_unmap_user(space, 0x10000, 0x2000);
// Should fail now with -EFAULT
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x10500, VmFaultCause::Read), -EFAULT);
space->destroy();
}
st_pass();
st_begin("vma: duplicate page fault on same page returns 0");
{
VmSpace* space = VmSpace::create();
vmm_map_user(space, 0x200000, 0x1000, VM_READ | VM_WRITE);
// First fault allocates the physical page
int ret = vmm_handle_page_fault(space, 0x200000, VmFaultCause::Read);
ST_ASSERT_EQ(ret, 0);
// Second fault on the same page should hit "already mapped" path
ret = vmm_handle_page_fault(space, 0x200100, VmFaultCause::Read);
ST_ASSERT_EQ(ret, 0);
// Verify both land on the same physical page
uint64 pa1 = 0, pa2 = 0;
pmap::lookup(space->root_pa, 0x200000, &pa1);
pmap::lookup(space->root_pa, 0x200100, &pa2);
// Same page, so PA for both addresses should be the same base page
ST_ASSERT_EQ(pa1, pa2);
space->destroy();
}
st_pass();
st_begin("vma: vm_perm_to_pte flag translation correctness");
{
// Test each MI flag maps to correct hardware PTE bit
uint64 pte_r = pmap::vm_perm_to_pte(VM_READ);
ST_ASSERT(pte_r & pmap::PTE_R);
ST_ASSERT(!(pte_r & pmap::PTE_W));
ST_ASSERT(!(pte_r & pmap::PTE_X));
ST_ASSERT(!(pte_r & pmap::PTE_U));
uint64 pte_rw = pmap::vm_perm_to_pte(VM_READ | VM_WRITE);
ST_ASSERT(pte_rw & pmap::PTE_R);
ST_ASSERT(pte_rw & pmap::PTE_W);
uint64 pte_rx = pmap::vm_perm_to_pte(VM_READ | VM_EXEC);
ST_ASSERT(pte_rx & pmap::PTE_R);
ST_ASSERT(pte_rx & pmap::PTE_X);
ST_ASSERT(!(pte_rx & pmap::PTE_W));
uint64 pte_u = pmap::vm_perm_to_pte(VM_READ | VM_USER);
ST_ASSERT(pte_u & pmap::PTE_R);
ST_ASSERT(pte_u & pmap::PTE_U);
// All combined
uint64 pte_all = pmap::vm_perm_to_pte(VM_READ | VM_WRITE | VM_EXEC | VM_USER);
ST_ASSERT(pte_all & pmap::PTE_R);
ST_ASSERT(pte_all & pmap::PTE_W);
ST_ASSERT(pte_all & pmap::PTE_X);
ST_ASSERT(pte_all & pmap::PTE_U);
ST_ASSERT(pte_all & pmap::PTE_V); // Always valid
}
st_pass();
st_begin("vma: unmap subset only removes contained VMAs");
{
VmSpace* space = VmSpace::create();
// Map three separate regions
vmm_map_user(space, 0x50000, 0x1000, VM_READ);
vmm_map_user(space, 0x60000, 0x1000, VM_READ);
vmm_map_user(space, 0x70000, 0x1000, VM_READ);
// Unmap only the middle one (range covers 0x60000-0x61000)
vmm_unmap_user(space, 0x60000, 0x1000);
// First and third should still be reachable
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x50000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x70000, VmFaultCause::Read), 0);
// Middle should fail
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x60000, VmFaultCause::Read), -EFAULT);
space->destroy();
}
st_pass();
st_begin("vma: null space returns -EINVAL");
{
ST_ASSERT_EQ(vmm_map_user(nullptr, 0x1000, 0x1000, VM_READ), -EINVAL);
ST_ASSERT_EQ(vmm_unmap_user(nullptr, 0x1000, 0x1000), -EINVAL);
ST_ASSERT_EQ(vmm_handle_page_fault(nullptr, 0x1000, VmFaultCause::Read), -EINVAL);
}
st_pass();
st_begin("vma: clone and copy-on-write");
{
VmSpace* parent = VmSpace::create();
vmm_map_user(parent, 0x80000, 0x1000, VM_READ | VM_WRITE);
/* Trigger read fault in parent to allocate physical page */
ST_ASSERT_EQ(vmm_handle_page_fault(parent, 0x80000, VmFaultCause::Read), 0);
uint64 parent_pa_initial;
ST_ASSERT(pmap::lookup(parent->root_pa, 0x80000, &parent_pa_initial));
/* Clone the address space */
VmSpace* child = vmm_clone(parent);
ST_ASSERT(child != nullptr);
/* Verify child has the same physical page mapped but COW */
uint64 child_pa;
ST_ASSERT(pmap::lookup(child->root_pa, 0x80000, &child_pa));
ST_ASSERT_EQ(child_pa, parent_pa_initial);
ST_ASSERT(pmap::is_cow(child->root_pa, 0x80000));
ST_ASSERT(pmap::is_cow(parent->root_pa, 0x80000)); /* Parent also marked COW */
/* Trigger Store Page Fault (cause=15) in child */
ST_ASSERT_EQ(vmm_handle_page_fault(child, 0x80000, VmFaultCause::Write), 0);
/* Child should now have a new physical page, no longer COW */
uint64 child_pa_new;
ST_ASSERT(pmap::lookup(child->root_pa, 0x80000, &child_pa_new));
ST_ASSERT(child_pa_new != parent_pa_initial);
ST_ASSERT(!pmap::is_cow(child->root_pa, 0x80000));
/* Parent is still mapped to the old page, still COW because it hasn't written */
uint64 parent_pa_current;
ST_ASSERT(pmap::lookup(parent->root_pa, 0x80000, &parent_pa_current));
ST_ASSERT_EQ(parent_pa_current, parent_pa_initial);
ST_ASSERT(pmap::is_cow(parent->root_pa, 0x80000));
/* Trigger Store Page Fault in parent */
ST_ASSERT_EQ(vmm_handle_page_fault(parent, 0x80000, VmFaultCause::Write), 0);
ST_ASSERT(!pmap::is_cow(parent->root_pa, 0x80000));
child->destroy();
parent->destroy();
}
st_pass();
st_begin("vma: gap search finds next free range");
{
VmSpace* space = VmSpace::create();
vmm_map_user(space, 0x1000, 0x3000, VM_READ);
uint64 va = mm_find_free_va(space, 0x1000, kPageSize);
ST_ASSERT_EQ(va, 0x4000ULL);
space->destroy();
}
st_pass();
st_begin("vma: reject overlapping mapping");
{
VmSpace* space = VmSpace::create();
ST_ASSERT_EQ(vmm_map_user(space, 0x20000, 0x2000, VM_READ), 0);
ST_ASSERT_EQ(vmm_map_user(space, 0x21000, 0x1000, VM_READ), -EINVAL);
space->destroy();
}
st_pass();
st_begin("vma: partial unmap splits a single VMA");
{
VmSpace* space = VmSpace::create();
ST_ASSERT_EQ(vmm_map_user(space, 0x80000, 0x3000, VM_READ | VM_WRITE), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x80000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x81000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x82000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_unmap_user(space, 0x81000, 0x1000), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x80000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x82000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x81000, VmFaultCause::Read), -EFAULT);
space->destroy();
}
st_pass();
st_begin("vma: mprotect read-only blocks write faults");
{
VmSpace* space = VmSpace::create();
ST_ASSERT_EQ(vmm_map_user(space, 0x90000, 0x2000, VM_READ | VM_WRITE), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x90000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_protect_user(space, 0x90000, 0x1000, VM_READ), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x90000, VmFaultCause::Write), -EFAULT);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0x91000, VmFaultCause::Write), 0);
space->destroy();
}
st_pass();
st_begin("vma: PROT_NONE unmaps existing pages");
{
VmSpace* space = VmSpace::create();
ST_ASSERT_EQ(vmm_map_user(space, 0xA0000, 0x1000, VM_READ | VM_WRITE), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0xA0000, VmFaultCause::Read), 0);
ST_ASSERT_EQ(vmm_protect_user(space, 0xA0000, 0x1000, 0), 0);
ST_ASSERT_EQ(vmm_handle_page_fault(space, 0xA0000, VmFaultCause::Read), -EFAULT);
space->destroy();
}
st_pass();
st_begin("vma: range covered check");
{
VmSpace* space = VmSpace::create();
ST_ASSERT_EQ(vmm_map_user(space, 0xB0000, 0x2000, VM_READ), 0);
ST_ASSERT(vma_range_covered(space, 0xB0000, 0xB1000));
ST_ASSERT(!vma_range_covered(space, 0xB0000, 0xB3000));
space->destroy();
}
st_pass();
}
|
