diff --git a/src/arch/x86_64/paging/mod.rs b/src/arch/x86_64/paging/mod.rs
index 43369b9b05e58ab8b95ac6f3dc16897669e93e39..f29fead812ffe3ba29797132a242800bc6a9ef7a 100644
--- a/src/arch/x86_64/paging/mod.rs
+++ b/src/arch/x86_64/paging/mod.rs
@@ -316,14 +316,14 @@ impl ActivePageTable {
let p4_table = temporary_page.map_table_frame(backup.clone(), EntryFlags::PRESENT | EntryFlags::WRITABLE | EntryFlags::NO_EXECUTE, self);
// overwrite recursive mapping
- self.p4_mut()[511].set(table.p4_frame.clone(), EntryFlags::PRESENT | EntryFlags::WRITABLE | EntryFlags::NO_EXECUTE);
+ self.p4_mut()[::RECURSIVE_PAGE_PML4].set(table.p4_frame.clone(), EntryFlags::PRESENT | EntryFlags::WRITABLE | EntryFlags::NO_EXECUTE);
self.flush_all();
// execute f in the new context
f(self);
// restore recursive mapping to original p4 table
- p4_table[511].set(backup, EntryFlags::PRESENT | EntryFlags::WRITABLE | EntryFlags::NO_EXECUTE);
+ p4_table[::RECURSIVE_PAGE_PML4].set(backup, EntryFlags::PRESENT | EntryFlags::WRITABLE | EntryFlags::NO_EXECUTE);
self.flush_all();
}
@@ -347,7 +347,7 @@ impl InactivePageTable {
// now we are able to zero the table
table.zero();
// set up recursive mapping for the table
- table[511].set(frame.clone(), EntryFlags::PRESENT | EntryFlags::WRITABLE | EntryFlags::NO_EXECUTE);
+ table[::RECURSIVE_PAGE_PML4].set(frame.clone(), EntryFlags::PRESENT | EntryFlags::WRITABLE | EntryFlags::NO_EXECUTE);
}
temporary_page.unmap(active_table);
diff --git a/src/consts.rs b/src/consts.rs
index 52b2415b91cbdae178bce94ad440c1adcc525a29..5129460769acf89e1f999a7fe7c8fb66706b4304 100644
--- a/src/consts.rs
+++ b/src/consts.rs
@@ -5,12 +5,15 @@
// The second from the top (510) PML4 is reserved for the kernel
/// The size of a single PML4
pub const PML4_SIZE: usize = 0x0000_0080_0000_0000;
+ pub const PML4_MASK: usize = 0x0000_ff80_0000_0000;
/// Offset of recursive paging
pub const RECURSIVE_PAGE_OFFSET: usize = (-(PML4_SIZE as isize)) as usize;
+ pub const RECURSIVE_PAGE_PML4: usize = (RECURSIVE_PAGE_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset of kernel
pub const KERNEL_OFFSET: usize = RECURSIVE_PAGE_OFFSET - PML4_SIZE;
+ pub const KERNEL_PML4: usize = (KERNEL_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to kernel heap
pub const KERNEL_HEAP_OFFSET: usize = KERNEL_OFFSET + PML4_SIZE/2;
@@ -25,6 +28,7 @@
/// Offset to user image
pub const USER_OFFSET: usize = 0;
+ pub const USER_PML4: usize = (USER_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user TCB
pub const USER_TCB_OFFSET: usize = 0xB000_0000;
@@ -34,40 +38,52 @@
/// Offset to user heap
pub const USER_HEAP_OFFSET: usize = USER_OFFSET + PML4_SIZE;
+ pub const USER_HEAP_PML4: usize = (USER_HEAP_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user grants
pub const USER_GRANT_OFFSET: usize = USER_HEAP_OFFSET + PML4_SIZE;
+ pub const USER_GRANT_PML4: usize = (USER_GRANT_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user stack
pub const USER_STACK_OFFSET: usize = USER_GRANT_OFFSET + PML4_SIZE;
+ pub const USER_STACK_PML4: usize = (USER_STACK_OFFSET & PML4_MASK)/PML4_SIZE;
/// Size of user stack
pub const USER_STACK_SIZE: usize = 1024 * 1024; // 1 MB
/// Offset to user sigstack
pub const USER_SIGSTACK_OFFSET: usize = USER_STACK_OFFSET + PML4_SIZE;
+ pub const USER_SIGSTACK_PML4: usize = (USER_SIGSTACK_OFFSET & PML4_MASK)/PML4_SIZE;
/// Size of user sigstack
pub const USER_SIGSTACK_SIZE: usize = 256 * 1024; // 256 KB
/// Offset to user TLS
pub const USER_TLS_OFFSET: usize = USER_SIGSTACK_OFFSET + PML4_SIZE;
+ pub const USER_TLS_PML4: usize = (USER_TLS_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user temporary image (used when cloning)
pub const USER_TMP_OFFSET: usize = USER_TLS_OFFSET + PML4_SIZE;
+ pub const USER_TMP_PML4: usize = (USER_TMP_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user temporary heap (used when cloning)
pub const USER_TMP_HEAP_OFFSET: usize = USER_TMP_OFFSET + PML4_SIZE;
+ pub const USER_TMP_HEAP_PML4: usize = (USER_TMP_HEAP_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user temporary page for grants
pub const USER_TMP_GRANT_OFFSET: usize = USER_TMP_HEAP_OFFSET + PML4_SIZE;
+ pub const USER_TMP_GRANT_PML4: usize = (USER_TMP_GRANT_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user temporary stack (used when cloning)
pub const USER_TMP_STACK_OFFSET: usize = USER_TMP_GRANT_OFFSET + PML4_SIZE;
+ pub const USER_TMP_STACK_PML4: usize = (USER_TMP_STACK_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user temporary sigstack (used when cloning)
pub const USER_TMP_SIGSTACK_OFFSET: usize = USER_TMP_STACK_OFFSET + PML4_SIZE;
+ pub const USER_TMP_SIGSTACK_PML4: usize = (USER_TMP_SIGSTACK_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset to user temporary tls (used when cloning)
pub const USER_TMP_TLS_OFFSET: usize = USER_TMP_SIGSTACK_OFFSET + PML4_SIZE;
+ pub const USER_TMP_TLS_PML4: usize = (USER_TMP_TLS_OFFSET & PML4_MASK)/PML4_SIZE;
/// Offset for usage in other temporary pages
pub const USER_TMP_MISC_OFFSET: usize = USER_TMP_TLS_OFFSET + PML4_SIZE;
+ pub const USER_TMP_MISC_PML4: usize = (USER_TMP_MISC_OFFSET & PML4_MASK)/PML4_SIZE;
diff --git a/src/syscall/process.rs b/src/syscall/process.rs
index b64f3645b25fd54b8f67cff700ce3930a46a9c60..d3f72abfb33d037957b827b15b82a1f603d3333a 100644
--- a/src/syscall/process.rs
+++ b/src/syscall/process.rs
@@ -357,10 +357,10 @@ pub fn clone(flags: usize, stack_base: usize) -> Result<ContextId> {
// Copy kernel mapping
{
- let frame = active_table.p4()[510].pointed_frame().expect("kernel table not mapped");
- let flags = active_table.p4()[510].flags();
+ let frame = active_table.p4()[::KERNEL_PML4].pointed_frame().expect("kernel table not mapped");
+ let flags = active_table.p4()[::KERNEL_PML4].flags();
active_table.with(&mut new_table, &mut temporary_page, |mapper| {
- mapper.p4_mut()[510].set(frame, flags);
+ mapper.p4_mut()[::KERNEL_PML4].set(frame, flags);
});
}
@@ -381,30 +381,30 @@ pub fn clone(flags: usize, stack_base: usize) -> Result<ContextId> {
if flags & CLONE_VM == CLONE_VM {
// Copy user image mapping, if found
if ! image.is_empty() {
- let frame = active_table.p4()[0].pointed_frame().expect("user image not mapped");
- let flags = active_table.p4()[0].flags();
+ let frame = active_table.p4()[::USER_PML4].pointed_frame().expect("user image not mapped");
+ let flags = active_table.p4()[::USER_PML4].flags();
active_table.with(&mut new_table, &mut temporary_page, |mapper| {
- mapper.p4_mut()[0].set(frame, flags);
+ mapper.p4_mut()[::USER_PML4].set(frame, flags);
});
}
context.image = image;
// Copy user heap mapping, if found
if let Some(heap_shared) = heap_option {
- let frame = active_table.p4()[1].pointed_frame().expect("user heap not mapped");
- let flags = active_table.p4()[1].flags();
+ let frame = active_table.p4()[::USER_HEAP_PML4].pointed_frame().expect("user heap not mapped");
+ let flags = active_table.p4()[::USER_HEAP_PML4].flags();
active_table.with(&mut new_table, &mut temporary_page, |mapper| {
- mapper.p4_mut()[1].set(frame, flags);
+ mapper.p4_mut()[::USER_HEAP_PML4].set(frame, flags);
});
context.heap = Some(heap_shared);
}
// Copy grant mapping
if ! grants.lock().is_empty() {
- let frame = active_table.p4()[2].pointed_frame().expect("user grants not mapped");
- let flags = active_table.p4()[2].flags();
+ let frame = active_table.p4()[::USER_GRANT_PML4].pointed_frame().expect("user grants not mapped");
+ let flags = active_table.p4()[::USER_GRANT_PML4].flags();
active_table.with(&mut new_table, &mut temporary_page, |mapper| {
- mapper.p4_mut()[2].set(frame, flags);
+ mapper.p4_mut()[::USER_GRANT_PML4].set(frame, flags);
});
}
context.grants = grants;